merge upstream

[m6w6/libmemcached] / libmemcached / memcached_stats.c

diff --git a/libmemcached/memcached_stats.c b/libmemcached/memcached_stats.c
index 87bc3ace254455680d813f7640ee6cedf2d22ad7..d52f781a641199d03fe857238cb40f7fa3555a4e 100644 (file)
--- a/libmemcached/memcached_stats.c
+++ b/libmemcached/memcached_stats.c
@@ -30,12 +30,13 @@ static char *memcached_stat_keys[] = {
 };
 
 
-static void set_data(memcached_stat_st *stat, char *key, char *value)
+static memcached_return set_data(memcached_stat_st *stat, char *key, char *value)
 {
 
   if(strlen(key) < 1) 
   {
-    fprintf(stderr, "Invalid key %s\n", key);
+    WATCHPOINT_STRING(key);
+    return MEMCACHED_UNKNOWN_STAT_KEY;
   }
   else if (!strcmp("pid", key))
   {
@@ -136,10 +137,24 @@ static void set_data(memcached_stat_st *stat, char *key, char *value)
   {
     stat->threads= strtol(value, (char **)NULL, 10);
   }
-  else
+  else if (!(strcmp("delete_misses", key) == 0 ||/* New stats in the 1.3 beta */
+             strcmp("delete_hits", key) == 0 ||/* Just swallow them for now.. */
+             strcmp("incr_misses", key) == 0 ||
+             strcmp("incr_hits", key) == 0 ||
+             strcmp("decr_misses", key) == 0 ||
+             strcmp("decr_hits", key) == 0 ||
+             strcmp("cas_misses", key) == 0 ||
+             strcmp("cas_hits", key) == 0 ||
+             strcmp("cas_badval", key) == 0 ||
+             strcmp("cmd_flush", key) == 0 ||
+             strcmp("accepting_conns", key) == 0 ||
+             strcmp("listen_disabled_num", key) == 0))
   {
-    fprintf(stderr, "Unknown key %s\n", key);
+    WATCHPOINT_STRING(key);
+    return MEMCACHED_UNKNOWN_STAT_KEY;
   }
+
+  return MEMCACHED_SUCCESS;
 }
 
 char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *stat, 
@@ -201,10 +216,7 @@ char *memcached_stat_get_value(memcached_st *ptr, memcached_stat_st *stat,
     return NULL;
   }
 
-  if (ptr->call_malloc)
-    ret= ptr->call_malloc(ptr, length + 1);
-  else
-    ret= malloc(length + 1);
+  ret= ptr->call_malloc(ptr, length + 1);
   memcpy(ret, buffer, length);
   ret[length]= '\0';
 
@@ -227,6 +239,11 @@ static memcached_return binary_stats_fetch(memcached_st *ptr,
   if (args != NULL) 
   {
     int len= strlen(args);
+
+    rc= memcached_validate_key_length(len, true);
+    unlikely (rc != MEMCACHED_SUCCESS)
+      return rc;
+
     request.message.header.request.keylen= htons((uint16_t)len);
     request.message.header.request.bodylen= htonl(len);
       
@@ -262,7 +279,11 @@ static memcached_return binary_stats_fetch(memcached_st *ptr,
         return rc;
      }
      
-     set_data(stat, buffer, buffer + strlen(buffer) + 1);
+     unlikely((set_data(stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
+     {
+       WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
+       WATCHPOINT_ASSERT(0);
+     }
   } while (1);
   
   /* shit... memcached_response will decrement the counter, so I need to
@@ -316,7 +337,11 @@ static memcached_return ascii_stats_fetch(memcached_st *ptr,
       value= string_ptr;
       value[(size_t)(end_ptr-string_ptr)]= 0;
       string_ptr= end_ptr + 2;
-      set_data(stat, key, value);
+      unlikely((set_data(stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
+      {
+        WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
+        WATCHPOINT_ASSERT(0);
+      }
     }
     else
       break;
@@ -335,22 +360,19 @@ memcached_stat_st *memcached_stat(memcached_st *ptr, char *args, memcached_retur
   memcached_return rc;
   memcached_stat_st *stats;
 
-  if (ptr->call_malloc)
-    stats= (memcached_stat_st *)ptr->call_malloc(ptr, sizeof(memcached_stat_st)*(ptr->number_of_hosts));
-  else
-    stats= (memcached_stat_st *)malloc(sizeof(memcached_stat_st)*(ptr->number_of_hosts));
+  unlikely (ptr->flags & MEM_USE_UDP)
+  {
+    *error= MEMCACHED_NOT_SUPPORTED;
+    return NULL;
+  }
+
+  stats= ptr->call_calloc(ptr, ptr->number_of_hosts, sizeof(memcached_stat_st));
 
   if (!stats)
   {
     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-    if (ptr->call_free)
-      ptr->call_free(ptr, stats);
-    else
-      free(stats);
-
     return NULL;
   }
-  memset(stats, 0, sizeof(memcached_stat_st)*(ptr->number_of_hosts));
 
   rc= MEMCACHED_SUCCESS;
   for (x= 0; x < ptr->number_of_hosts; x++)
@@ -400,17 +422,13 @@ char ** memcached_stat_get_keys(memcached_st *ptr, memcached_stat_st *stat __att
   char **list;
   size_t length= sizeof(memcached_stat_keys);
 
-  if (ptr->call_malloc)
-    list= (char **)ptr->call_malloc(ptr, length);
-  else
-    list= (char **)malloc(length);
+  list= ptr->call_malloc(ptr, length);
 
   if (!list)
   {
     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
     return NULL;
   }
-  memset(list, 0, sizeof(memcached_stat_keys));
 
   memcpy(list, memcached_stat_keys, sizeof(memcached_stat_keys));
 
@@ -427,7 +445,7 @@ void memcached_stat_free(memcached_st *ptr, memcached_stat_st *stat)
     return;
   }
 
-  if (ptr && ptr->call_free)
+  if (ptr)
     ptr->call_free(ptr, stat);
   else
     free(stat);