};
-static memcached_return_t set_data(memcached_stat_st *memc_stat, char *key, char *value)
+static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key, const char *value)
{
if (strlen(key) < 1)
else if (not strcmp("rusage_user", key))
{
char *walk_ptr;
- for (walk_ptr= value; (!ispunct(*walk_ptr)); walk_ptr++) {};
+ for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
*walk_ptr= 0;
walk_ptr++;
memc_stat->rusage_user_seconds= strtoul(value, (char **)NULL, 10);
else if (not strcmp("rusage_system", key))
{
char *walk_ptr;
- for (walk_ptr= value; (!ispunct(*walk_ptr)); walk_ptr++) {};
+ for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
*walk_ptr= 0;
walk_ptr++;
memc_stat->rusage_system_seconds= strtoul(value, (char **)NULL, 10);
static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
const char *args,
const size_t args_length,
- memcached_server_write_instance_st instance,
+ org::libmemcached::Instance* instance,
struct local_context *check)
{
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
protocol_binary_request_stats request= {}; // = {.bytes= {0}};
- request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+
+ initialize_binary_request(instance, request.message.header);
+
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_STAT;
request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
request.message.header.request.keylen= htons(uint16_t(args_length));
request.message.header.request.bodylen= htonl(uint32_t( args_length));
- struct libmemcached_io_vector_st vector[]=
+ libmemcached_io_vector_st vector[]=
{
{ request.bytes, sizeof(request.bytes) },
{ args, args_length }
}
else
{
- struct libmemcached_io_vector_st vector[]=
+ libmemcached_io_vector_st vector[]=
{
{ request.bytes, sizeof(request.bytes) }
};
return rc;
}
- if (memc_stat)
- {
- if ((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
- {
- WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
- WATCHPOINT_ASSERT(0);
- }
- }
-
if (check && check->func)
{
size_t key_length= strlen(buffer);
buffer+key_length+1, strlen(buffer+key_length+1),
check->context);
}
+
+ if (memc_stat)
+ {
+ if ((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
+ {
+ WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
+ WATCHPOINT_ASSERT(0);
+ }
+ }
} while (1);
/*
* memcached_response will decrement the counter, so I need to reset it..
* todo: look at this and try to find a better solution.
* */
- instance->cursor_active= 0;
+ instance->cursor_active_= 0;
return MEMCACHED_SUCCESS;
}
static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
const char *args,
const size_t args_length,
- memcached_server_write_instance_st instance,
+ org::libmemcached::Instance* instance,
struct local_context *check)
{
- struct libmemcached_io_vector_st vector[]=
+ libmemcached_io_vector_st vector[]=
{
{ memcached_literal_param("stats ") },
{ args, args_length },
if (memcached_success(rc))
{
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
- while ((rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL)) == MEMCACHED_STAT)
+ while ((rc= memcached_response(instance, buffer, sizeof(buffer), NULL)) == MEMCACHED_STAT)
{
- char *string_ptr, *end_ptr;
- char *key, *value;
-
- string_ptr= buffer;
+ char *string_ptr= buffer;
string_ptr+= 5; /* Move past STAT */
+
+ char *end_ptr;
for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++) {};
- key= string_ptr;
- key[(size_t)(end_ptr-string_ptr)]= 0;
+ char *key= string_ptr;
+ key[size_t(end_ptr-string_ptr)]= 0;
string_ptr= end_ptr + 1;
for (end_ptr= string_ptr; !(isspace(*end_ptr)); end_ptr++) {};
- value= string_ptr;
+ char *value= string_ptr;
value[(size_t)(end_ptr -string_ptr)]= 0;
- if (memc_stat)
- {
- unlikely((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
- {
- WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
- WATCHPOINT_ASSERT(0);
- }
- }
+#if 0
+ bool check_bool= bool(check);
+ bool check_func_bool= bool(check) ? bool(check->func) : false;
+ fprintf(stderr, "%s:%d %s %s %d:%d\n", __FILE__, __LINE__, key, value, check_bool, check_func_bool);
+#endif
- if (check && check->func)
+ if (check and check->func)
{
check->func(instance,
key, strlen(key),
value, strlen(value),
check->context);
}
+
+ if (memc_stat)
+ {
+ if((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
+ {
+ WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
+ WATCHPOINT_ASSERT(0);
+ }
+ }
}
}
+ if (rc == MEMCACHED_ERROR)
+ {
+ return MEMCACHED_INVALID_ARGUMENTS;
+ }
+
if (rc == MEMCACHED_END)
{
return MEMCACHED_SUCCESS;
error= &unused;
}
- memcached_return_t rc;
- if (memcached_failed(rc= initialize_query(self)))
+ if (memcached_failed(*error= initialize_query(self, true)))
{
- *error= rc;
return NULL;
}
- if (self->flags.use_udp)
+ if (memcached_is_udp(self))
{
*error= memcached_set_error(*self, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
return NULL;
}
+ memcached_return_t rc;
size_t args_length= 0;
if (args)
{
stat_instance->pid= -1;
stat_instance->root= self;
- memcached_server_write_instance_st instance= memcached_server_instance_fetch(self, x);
+ org::libmemcached::Instance* instance= memcached_instance_fetch(self, x);
memcached_return_t temp_return;
- if (self->flags.binary_protocol)
+ if (memcached_is_binary(self))
{
temp_return= binary_stats_fetch(stat_instance, args, args_length, instance, NULL);
}
temp_return= ascii_stats_fetch(stat_instance, args, args_length, instance, NULL);
}
+ // Special case where "args" is invalid
+ if (temp_return == MEMCACHED_INVALID_ARGUMENTS)
+ {
+ rc= MEMCACHED_INVALID_ARGUMENTS;
+ break;
+ }
+
if (memcached_failed(temp_return))
{
rc= MEMCACHED_SOME_ERRORS;
return rc;
}
- if (memcached_success(rc= initialize_query(memc_ptr)))
+ if (memcached_success(rc= initialize_query(memc_ptr, true)))
{
size_t args_length= 0;
if (args)
if (memcached_success(rc))
{
- memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc_ptr, 0);
+ org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
if (memc.flags.binary_protocol)
{
rc= binary_stats_fetch(memc_stat, args, args_length, instance, NULL);
memcached_stat_st *,
memcached_return_t *error)
{
- if (not ptr)
+ if (ptr == NULL)
+ {
return NULL;
+ }
char **list= static_cast<char **>(libmemcached_malloc(ptr, sizeof(memcached_stat_keys)));
if (not list)
}
static memcached_return_t call_stat_fn(memcached_st *ptr,
- memcached_server_write_instance_st instance,
+ org::libmemcached::Instance* instance,
void *context)
{
memcached_return_t rc;
- struct local_context *check= (struct local_context *)context;
+ local_context *check= (struct local_context *)context;
- if (ptr->flags.binary_protocol)
+ if (memcached_is_binary(ptr))
{
rc= binary_stats_fetch(NULL, check->args, check->args_length, instance, check);
}
{
memcached_version(memc);
- struct local_context check(func, context, args, args ? strlen(args) : 0);
+ local_context check(func, context, args, args ? strlen(args) : 0);
return memcached_server_execute(memc, call_stat_fn, (void *)&check);
}
projects / m6w6 / libmemcached / blobdiff