X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fstats.cc;h=eb3376802664956d50af89f060b8372b5e5bca47;hb=5d44e2b91e7055316b538128ec37c0fa81bbc28d;hp=9b3535822b9d21e2aaa17af2cfcc856f489beda8;hpb=444fb45cfefbc668e1ece02c24ab6e7bc3be0301;p=awesomized%2Flibmemcached

diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc
index 9b353582..eb337680 100644
--- a/libmemcached/stats.cc
+++ b/libmemcached/stats.cc
@@ -81,7 +81,7 @@ struct local_context
 };
 
 
-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)
@@ -95,11 +95,11 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, char *key, char
 
     if (temp <= INT32_MAX and ( sizeof(pid_t) == sizeof(int32_t) ))
     {
-      memc_stat->pid= temp;
+      memc_stat->pid= pid_t(temp);
     }
     else if (temp > -1)
     {
-      memc_stat->pid= temp;
+      memc_stat->pid= pid_t(temp);
     }
     else
     {
@@ -127,7 +127,7 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, char *key, char
   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);
@@ -136,7 +136,7 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, char *key, char
   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);
@@ -232,11 +232,10 @@ char *memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_
 {
   char buffer[SMALL_STRING_LEN];
   int length;
-  char *ret;
 
   *error= MEMCACHED_SUCCESS;
 
-  if (not memcmp("pid", key, sizeof("pid") -1))
+  if (memcmp("pid", key, sizeof("pid") -1) == 0)
   {
     length= snprintf(buffer, SMALL_STRING_LEN,"%lld", (signed long long)memc_stat->pid);
   }
@@ -336,7 +335,8 @@ char *memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_
     return NULL;
   }
 
-  ret= static_cast<char *>(libmemcached_malloc(ptr, (size_t) (length + 1)));
+  // User is responsible for free() memory, so use malloc()
+  char *ret= static_cast<char *>(malloc(size_t(length +1)));
   memcpy(ret, buffer, (size_t) length);
   ret[length]= '\0';
 
@@ -346,12 +346,14 @@ char *memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_
 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;
 
@@ -360,7 +362,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
     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 }
@@ -374,7 +376,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
   }
   else
   {
-    struct libmemcached_io_vector_st vector[]=
+    libmemcached_io_vector_st vector[]=
     {
       { request.bytes, sizeof(request.bytes) }
     };
@@ -387,7 +389,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
   }
 
   memcached_server_response_decrement(instance);
-  do
+  while (1)
   {
     memcached_return_t rc= memcached_response(instance, buffer, sizeof(buffer), NULL);
 
@@ -402,15 +404,6 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
       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);
@@ -420,13 +413,22 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
                   buffer+key_length+1, strlen(buffer+key_length+1),
                   check->context);
     }
-  } while (1);
+
+    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);
+      }
+    }
+  }
 
   /* 
    * 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;
 }
@@ -434,10 +436,10 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
 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 },
@@ -448,40 +450,50 @@ static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
   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;
@@ -498,19 +510,18 @@ memcached_stat_st *memcached_stat(memcached_st *self, char *args, memcached_retu
     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)
   {
@@ -541,10 +552,10 @@ memcached_stat_st *memcached_stat(memcached_st *self, char *args, memcached_retu
     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);
     }
@@ -553,6 +564,13 @@ memcached_stat_st *memcached_stat(memcached_st *self, char *args, memcached_retu
       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;
@@ -569,6 +587,12 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
 {
   memcached_st memc;
 
+  memcached_stat_st unused_memc_stat;
+  if (memc_stat == NULL)
+  {
+    memc_stat= &unused_memc_stat;
+  }
+
   memset(memc_stat, 0, sizeof(memcached_stat_st));
 
   memcached_st *memc_ptr= memcached_create(&memc);
@@ -584,7 +608,7 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
     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)
@@ -595,7 +619,7 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
 
     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);
@@ -616,68 +640,74 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
   We make a copy of the keys since at some point in the not so distant future
   we will add support for "found" keys.
 */
-char ** memcached_stat_get_keys(memcached_st *ptr,
+char ** memcached_stat_get_keys(memcached_st *memc,
                                 memcached_stat_st *,
                                 memcached_return_t *error)
 {
-  if (not ptr)
-    return NULL;
-
-  char **list= static_cast<char **>(libmemcached_malloc(ptr, sizeof(memcached_stat_keys)));
-  if (not list)
+  if (memc)
   {
-    *error= memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
-    return NULL;
-  }
+    char **list= static_cast<char **>(libmemcached_malloc(memc, sizeof(memcached_stat_keys)));
+    if (list == NULL)
+    {
+      if (error)
+      {
+        *error= memcached_set_error(*memc, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
+      }
+
+      return NULL;
+    }
 
-  memcpy(list, memcached_stat_keys, sizeof(memcached_stat_keys));
+    memcpy(list, memcached_stat_keys, sizeof(memcached_stat_keys));
 
-  *error= MEMCACHED_SUCCESS;
+    if (error)
+    {
+      *error= MEMCACHED_SUCCESS;
+    }
 
-  return list;
+    return list;
+  }
+
+  return NULL;
 }
 
 void memcached_stat_free(const memcached_st *, memcached_stat_st *memc_stat)
 {
   WATCHPOINT_ASSERT(memc_stat); // Be polite, but when debugging catch this as an error
-  if (memc_stat == NULL)
-  {
-    return;
-  }
-
-  if (memc_stat->root)
+  if (memc_stat)
   {
     libmemcached_free(memc_stat->root, memc_stat);
-    return;
   }
-
-  libmemcached_free(NULL, memc_stat);
 }
 
-static memcached_return_t call_stat_fn(memcached_st *ptr,
-                                       memcached_server_write_instance_st instance,
+static memcached_return_t call_stat_fn(memcached_st *memc,
+                                       org::libmemcached::Instance* instance,
                                        void *context)
 {
-  memcached_return_t rc;
-  struct local_context *check= (struct local_context *)context;
-
-  if (ptr->flags.binary_protocol)
+  if (memc)
   {
-    rc= binary_stats_fetch(NULL, check->args, check->args_length, instance, check);
-  }
-  else
-  {
-    rc= ascii_stats_fetch(NULL, check->args, check->args_length, instance, check);
+    local_context *check= (struct local_context *)context;
+
+    if (memcached_is_binary(memc))
+    {
+      return binary_stats_fetch(NULL, check->args, check->args_length, instance, check);
+    }
+    else
+    {
+      return ascii_stats_fetch(NULL, check->args, check->args_length, instance, check);
+    }
   }
 
-  return rc;
+  return MEMCACHED_INVALID_ARGUMENTS;
 }
 
 memcached_return_t memcached_stat_execute(memcached_st *memc, const char *args,  memcached_stat_fn func, void *context)
 {
-  memcached_version(memc);
+  if (memcached_fatal(memcached_version(memc)))
+  {
+    return memcached_last_error(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);
 }