1 /*
2 */
3 
4 #include "common.h"
5 
6 static const char *memcached_stat_keys[] = {
7   "pid",
8   "uptime",
9   "time",
10   "version",
11   "pointer_size",
12   "rusage_user",
13   "rusage_system",
14   "curr_items",
15   "total_items",
16   "bytes",
17   "curr_connections",
18   "total_connections",
19   "connection_structures",
20   "cmd_get",
21   "cmd_set",
22   "get_hits",
23   "get_misses",
24   "evictions",
25   "bytes_read",
26   "bytes_written",
27   "limit_maxbytes",
28   "threads",
29   NULL
30 };
31 
32 struct local_context
33 {
34   memcached_stat_fn func;
35   void *context;
36   const char *args;
37 };
38 
39 
set_data(memcached_stat_st *memc_stat, char *key, char *value)40 static memcached_return_t set_data(memcached_stat_st *memc_stat, char *key, char *value)
41 {
42 
43   if (strlen(key) < 1)
44   {
45     WATCHPOINT_STRING(key);
46     return MEMCACHED_UNKNOWN_STAT_KEY;
47   }
48   else if (!strcmp("pid", key))
49   {
50     memc_stat->pid= (uint32_t) strtol(value, (char **)NULL, 10);
51   }
52   else if (!strcmp("uptime", key))
53   {
54     memc_stat->uptime= (uint32_t) strtol(value, (char **)NULL, 10);
55   }
56   else if (!strcmp("time", key))
57   {
58     memc_stat->time= (uint32_t) strtol(value, (char **)NULL, 10);
59   }
60   else if (!strcmp("version", key))
61   {
62     memcpy(memc_stat->version, value, strlen(value));
63     memc_stat->version[strlen(value)]= 0;
64   }
65   else if (!strcmp("pointer_size", key))
66   {
67     memc_stat->pointer_size= (uint32_t) strtol(value, (char **)NULL, 10);
68   }
69   else if (!strcmp("rusage_user", key))
70   {
71     char *walk_ptr;
72     for (walk_ptr= value; (!ispunct(*walk_ptr)); walk_ptr++);
73     *walk_ptr= 0;
74     walk_ptr++;
75     memc_stat->rusage_user_seconds= (uint32_t) strtol(value, (char **)NULL, 10);
76     memc_stat->rusage_user_microseconds= (uint32_t) strtol(walk_ptr, (char **)NULL, 10);
77   }
78   else if (!strcmp("rusage_system", key))
79   {
80     char *walk_ptr;
81     for (walk_ptr= value; (!ispunct(*walk_ptr)); walk_ptr++);
82     *walk_ptr= 0;
83     walk_ptr++;
84     memc_stat->rusage_system_seconds= (uint32_t) strtol(value, (char **)NULL, 10);
85     memc_stat->rusage_system_microseconds= (uint32_t) strtol(walk_ptr, (char **)NULL, 10);
86   }
87   else if (!strcmp("curr_items", key))
88   {
89     memc_stat->curr_items= (uint32_t) strtol(value, (char **)NULL, 10);
90   }
91   else if (!strcmp("total_items", key))
92   {
93     memc_stat->total_items= (uint32_t) strtol(value, (char **)NULL, 10);
94   }
95   else if (!strcmp("bytes_read", key))
96   {
97     memc_stat->bytes_read= (uint32_t) strtoll(value, (char **)NULL, 10);
98   }
99   else if (!strcmp("bytes_written", key))
100   {
101     memc_stat->bytes_written= (uint32_t) strtoll(value, (char **)NULL, 10);
102   }
103   else if (!strcmp("bytes", key))
104   {
105     memc_stat->bytes= (uint32_t) strtoll(value, (char **)NULL, 10);
106   }
107   else if (!strcmp("curr_connections", key))
108   {
109     memc_stat->curr_connections= (uint32_t) strtoll(value, (char **)NULL, 10);
110   }
111   else if (!strcmp("total_connections", key))
112   {
113     memc_stat->total_connections= (uint32_t) strtoll(value, (char **)NULL, 10);
114   }
115   else if (!strcmp("connection_structures", key))
116   {
117     memc_stat->connection_structures= (uint32_t) strtol(value, (char **)NULL, 10);
118   }
119   else if (!strcmp("cmd_get", key))
120   {
121     memc_stat->cmd_get= (uint64_t) strtoll(value, (char **)NULL, 10);
122   }
123   else if (!strcmp("cmd_set", key))
124   {
125     memc_stat->cmd_set= (uint64_t) strtoll(value, (char **)NULL, 10);
126   }
127   else if (!strcmp("get_hits", key))
128   {
129     memc_stat->get_hits= (uint64_t) strtoll(value, (char **)NULL, 10);
130   }
131   else if (!strcmp("get_misses", key))
132   {
133     memc_stat->get_misses= (uint64_t)strtoll(value, (char **)NULL, 10);
134   }
135   else if (!strcmp("evictions", key))
136   {
137     memc_stat->evictions= (uint64_t)strtoll(value, (char **)NULL, 10);
138   }
139   else if (!strcmp("limit_maxbytes", key))
140   {
141     memc_stat->limit_maxbytes= (uint64_t) strtoll(value, (char **)NULL, 10);
142   }
143   else if (!strcmp("threads", key))
144   {
145     memc_stat->threads= (uint32_t) strtol(value, (char **)NULL, 10);
146   }
147   else if (!(strcmp("delete_misses", key) == 0 ||/* New stats in the 1.3 beta */
148              strcmp("delete_hits", key) == 0 ||/* Just swallow them for now.. */
149              strcmp("incr_misses", key) == 0 ||
150              strcmp("incr_hits", key) == 0 ||
151              strcmp("decr_misses", key) == 0 ||
152              strcmp("decr_hits", key) == 0 ||
153              strcmp("cas_misses", key) == 0 ||
154              strcmp("cas_hits", key) == 0 ||
155              strcmp("cas_badval", key) == 0 ||
156              strcmp("cmd_flush", key) == 0 ||
157              strcmp("accepting_conns", key) == 0 ||
158              strcmp("listen_disabled_num", key) == 0 ||
159              strcmp("conn_yields", key) == 0 ||
160              strcmp("auth_cmds", key) == 0 ||
161              strcmp("auth_errors", key) == 0 ||
162              strcmp("reclaimed", key) == 0))
163   {
164     WATCHPOINT_STRING(key);
165     /* return MEMCACHED_UNKNOWN_STAT_KEY; */
166     return MEMCACHED_SUCCESS;
167   }
168 
169   return MEMCACHED_SUCCESS;
170 }
171 
memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_stat, const char *key, memcached_return_t *error)172 char *memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_stat,
173                                const char *key, memcached_return_t *error)
174 {
175   char buffer[SMALL_STRING_LEN];
176   int length;
177   char *ret;
178 
179   *error= MEMCACHED_SUCCESS;
180 
181   if (!memcmp("pid", key, strlen("pid")))
182     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->pid);
183   else if (!memcmp("uptime", key, strlen("uptime")))
184     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->uptime);
185   else if (!memcmp("time", key, strlen("time")))
186     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->time);
187   else if (!memcmp("version", key, strlen("version")))
188     length= snprintf(buffer, SMALL_STRING_LEN,"%s", memc_stat->version);
189   else if (!memcmp("pointer_size", key, strlen("pointer_size")))
190     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->pointer_size);
191   else if (!memcmp("rusage_user", key, strlen("rusage_user")))
192     length= snprintf(buffer, SMALL_STRING_LEN,"%u.%u", memc_stat->rusage_user_seconds, memc_stat->rusage_user_microseconds);
193   else if (!memcmp("rusage_system", key, strlen("rusage_system")))
194     length= snprintf(buffer, SMALL_STRING_LEN,"%u.%u", memc_stat->rusage_system_seconds, memc_stat->rusage_system_microseconds);
195   else if (!memcmp("curr_items", key, strlen("curr_items")))
196     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->curr_items);
197   else if (!memcmp("total_items", key, strlen("total_items")))
198     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->total_items);
199   else if (!memcmp("curr_connections", key, strlen("curr_connections")))
200     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->curr_connections);
201   else if (!memcmp("total_connections", key, strlen("total_connections")))
202     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->total_connections);
203   else if (!memcmp("connection_structures", key, strlen("connection_structures")))
204     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->connection_structures);
205   else if (!memcmp("cmd_get", key, strlen("cmd_get")))
206     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->cmd_get);
207   else if (!memcmp("cmd_set", key, strlen("cmd_set")))
208     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->cmd_set);
209   else if (!memcmp("get_hits", key, strlen("get_hits")))
210     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->get_hits);
211   else if (!memcmp("get_misses", key, strlen("get_misses")))
212     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->get_misses);
213   else if (!memcmp("evictions", key, strlen("evictions")))
214     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->evictions);
215   else if (!memcmp("bytes_read", key, strlen("bytes_read")))
216     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->bytes_read);
217   else if (!memcmp("bytes_written", key, strlen("bytes_written")))
218     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->bytes_written);
219   else if (!memcmp("bytes", key, strlen("bytes")))
220     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->bytes);
221   else if (!memcmp("limit_maxbytes", key, strlen("limit_maxbytes")))
222     length= snprintf(buffer, SMALL_STRING_LEN,"%"PRIu64"u", (uint64_t)memc_stat->limit_maxbytes);
223   else if (!memcmp("threads", key, strlen("threads")))
224     length= snprintf(buffer, SMALL_STRING_LEN,"%u", memc_stat->threads);
225   else
226   {
227     *error= MEMCACHED_NOTFOUND;
228     return NULL;
229   }
230 
231   if (length >= SMALL_STRING_LEN || length < 0)
232   {
233     *error= MEMCACHED_FAILURE;
234     return NULL;
235   }
236 
237   ret= libmemcached_malloc(ptr, (size_t) (length + 1));
238   memcpy(ret, buffer, (size_t) length);
239   ret[length]= '\0';
240 
241   return ret;
242 }
243 
binary_stats_fetch(memcached_stat_st *memc_stat, const char *args, memcached_server_write_instance_st instance, struct local_context *check)244 static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
245                                              const char *args,
246                                              memcached_server_write_instance_st instance,
247                                              struct local_context *check)
248 {
249   memcached_return_t rc;
250   struct libmemcached_io_vector_st vector[2];
251 
252   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
253   protocol_binary_request_stats request;
254   memset(&request, 0, sizeof(request));
255   memset(&vector, 0, sizeof(vector));
256   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
257   request.message.header.request.opcode= PROTOCOL_BINARY_CMD_STAT;
258   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
259 
260   if (args != NULL)
261   {
262     size_t len= strlen(args);
263 
264     rc= memcached_validate_key_length(len, true);
265     unlikely (rc != MEMCACHED_SUCCESS)
266       return rc;
267 
268     request.message.header.request.keylen= htons((uint16_t)len);
269     request.message.header.request.bodylen= htonl((uint32_t) len);
270 
271     vector[0].length= sizeof(request.bytes);
272     vector[0].buffer= request.bytes;
273     vector[1].length= len;
274     vector[1].buffer= args;
275 
276     if (memcached_vdo(instance, vector, 2, true) != MEMCACHED_SUCCESS)
277     {
278       memcached_io_reset(instance);
279       return MEMCACHED_WRITE_FAILURE;
280     }
281   }
282   else
283   {
284     if (memcached_do(instance, request.bytes,
285                      sizeof(request.bytes), true) != MEMCACHED_SUCCESS)
286     {
287       memcached_io_reset(instance);
288       return MEMCACHED_WRITE_FAILURE;
289     }
290   }
291 
292   memcached_server_response_decrement(instance);
293   do
294   {
295     rc= memcached_response(instance, buffer, sizeof(buffer), NULL);
296 
297     if (rc == MEMCACHED_END)
298       break;
299 
300     unlikely (rc != MEMCACHED_SUCCESS)
301     {
302       memcached_io_reset(instance);
303       return rc;
304     }
305 
306     if (memc_stat)
307     {
308       unlikely((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
309       {
310         WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
311         WATCHPOINT_ASSERT(0);
312       }
313     }
314 
315     if (check && check->func)
316     {
317       size_t key_length= strlen(buffer);
318 
319       check->func(instance,
320                   buffer, key_length,
321                   buffer+key_length+1, strlen(buffer+key_length+1),
322                   check->context);
323     }
324   } while (1);
325 
326   /* shit... memcached_response will decrement the counter, so I need to
327    ** reset it.. todo: look at this and try to find a better solution.
328  */
329   instance->cursor_active= 0;
330 
331   return MEMCACHED_SUCCESS;
332 }
333 
ascii_stats_fetch(memcached_stat_st *memc_stat, const char *args, memcached_server_write_instance_st instance, struct local_context *check)334 static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
335                                             const char *args,
336                                             memcached_server_write_instance_st instance,
337                                             struct local_context *check)
338 {
339   memcached_return_t rc;
340   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
341   int send_length;
342 
343   if (args)
344     send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
345                                    "stats %s\r\n", args);
346   else
347     send_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
348                                    "stats\r\n");
349 
350   if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE || send_length < 0)
351     return MEMCACHED_WRITE_FAILURE;
352 
353   rc= memcached_do(instance, buffer, (size_t)send_length, true);
354   if (rc != MEMCACHED_SUCCESS)
355     goto error;
356 
357   while (1)
358   {
359     rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
360 
361     if (rc == MEMCACHED_STAT)
362     {
363       char *string_ptr, *end_ptr;
364       char *key, *value;
365 
366       string_ptr= buffer;
367       string_ptr+= 5; /* Move past STAT */
368       for (end_ptr= string_ptr; isgraph(*end_ptr); end_ptr++);
369       key= string_ptr;
370       key[(size_t)(end_ptr-string_ptr)]= 0;
371 
372       string_ptr= end_ptr + 1;
373       for (end_ptr= string_ptr; !(isspace(*end_ptr)); end_ptr++);
374       value= string_ptr;
375       value[(size_t)(end_ptr-string_ptr)]= 0;
376       string_ptr= end_ptr + 2;
377       if (memc_stat)
378       {
379         unlikely((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
380         {
381           WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
382           WATCHPOINT_ASSERT(0);
383         }
384       }
385 
386       if (check && check->func)
387       {
388         check->func(instance,
389                     key, strlen(key),
390                     value, strlen(value),
391                     check->context);
392       }
393     }
394     else
395       break;
396   }
397 
398 error:
399   if (rc == MEMCACHED_END)
400     return MEMCACHED_SUCCESS;
401   else
402     return rc;
403 }
404 
memcached_stat(memcached_st *ptr, char *args, memcached_return_t *error)405 memcached_stat_st *memcached_stat(memcached_st *ptr, char *args, memcached_return_t *error)
406 {
407   memcached_return_t rc;
408   memcached_stat_st *stats;
409   uint32_t x;
410 
411   unlikely (ptr->flags.use_udp)
412   {
413     *error= MEMCACHED_NOT_SUPPORTED;
414     return NULL;
415   }
416 
417   stats= libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(memcached_stat_st));
418 
419   if (! stats)
420   {
421     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
422     return NULL;
423   }
424 
425   rc= MEMCACHED_SUCCESS;
426   for (x= 0; x < memcached_server_count(ptr); x++)
427   {
428     memcached_return_t temp_return;
429     memcached_server_write_instance_st instance;
430     memcached_stat_st *stat_instance;
431 
432     stat_instance= stats + x;
433 
434     stat_instance->root= ptr;
435 
436     instance= memcached_server_instance_fetch(ptr, x);
437 
438     if (ptr->flags.binary_protocol)
439     {
440       temp_return= binary_stats_fetch(stat_instance, args, instance, NULL);
441     }
442     else
443     {
444       temp_return= ascii_stats_fetch(stat_instance, args, instance, NULL);
445     }
446 
447     if (temp_return != MEMCACHED_SUCCESS)
448       rc= MEMCACHED_SOME_ERRORS;
449   }
450 
451   *error= rc;
452   return stats;
453 }
454 
memcached_stat_servername(memcached_stat_st *memc_stat, char *args, const char *hostname, in_port_t port)455 memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char *args,
456                                              const char *hostname, in_port_t port)
457 {
458   memcached_return_t rc;
459   memcached_st memc;
460   memcached_st *memc_ptr;
461   memcached_server_write_instance_st instance;
462 
463   memset(memc_stat, 0, sizeof(memcached_stat_st));
464 
465   memc_ptr= memcached_create(&memc);
466   WATCHPOINT_ASSERT(memc_ptr);
467 
468   memcached_server_add(&memc, hostname, port);
469 
470   instance= memcached_server_instance_fetch(memc_ptr, 0);
471 
472   if (memc.flags.binary_protocol)
473   {
474     rc= binary_stats_fetch(memc_stat, args, instance, NULL);
475   }
476   else
477   {
478     rc= ascii_stats_fetch(memc_stat, args, instance, NULL);
479   }
480 
481   memcached_free(&memc);
482 
483   return rc;
484 }
485 
486 /*
487   We make a copy of the keys since at some point in the not so distant future
488   we will add support for "found" keys.
489 */
memcached_stat_get_keys(const memcached_st *ptr, memcached_stat_st *memc_stat, memcached_return_t *error)490 char ** memcached_stat_get_keys(const memcached_st *ptr,
491                                 memcached_stat_st *memc_stat,
492                                 memcached_return_t *error)
493 {
494   char **list;
495   size_t length= sizeof(memcached_stat_keys);
496 
497   (void)memc_stat;
498 
499   list= libmemcached_malloc(ptr, length);
500 
501   if (! list)
502   {
503     *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
504     return NULL;
505   }
506 
507   memcpy(list, memcached_stat_keys, sizeof(memcached_stat_keys));
508 
509   *error= MEMCACHED_SUCCESS;
510 
511   return list;
512 }
513 
memcached_stat_free(const memcached_st *ptr, memcached_stat_st *memc_stat)514 void memcached_stat_free(const memcached_st *ptr, memcached_stat_st *memc_stat)
515 {
516   if (memc_stat == NULL)
517   {
518     WATCHPOINT_ASSERT(0); /* Be polite, but when debugging catch this as an error */
519     return;
520   }
521 
522   if (memc_stat->root)
523   {
524     libmemcached_free(memc_stat->root, memc_stat);
525   }
526   else if (ptr)
527   {
528     libmemcached_free(ptr, memc_stat);
529   }
530   else
531   {
532     free(memc_stat);
533   }
534 }
535 
call_stat_fn(memcached_st *ptr, memcached_server_write_instance_st instance, void *context)536 static memcached_return_t call_stat_fn(memcached_st *ptr,
537                                        memcached_server_write_instance_st instance,
538                                        void *context)
539 {
540   memcached_return_t rc;
541   struct local_context *check= (struct local_context *)context;
542 
543   if (ptr->flags.binary_protocol)
544   {
545     rc= binary_stats_fetch(NULL, check->args, instance, check);
546   }
547   else
548   {
549     rc= ascii_stats_fetch(NULL, check->args, instance, check);
550   }
551 
552   return rc;
553 }
554 
memcached_stat_execute(memcached_st *memc, const char *args, memcached_stat_fn func, void *context)555 memcached_return_t memcached_stat_execute(memcached_st *memc, const char *args,  memcached_stat_fn func, void *context)
556 {
557    struct local_context check;
558    memset(&check, 0, sizeof(check));
559 
560    memcached_version(memc);
561 
562    check.func= func;
563    check.context= context;
564    check.args= args;
565 
566  return memcached_server_execute(memc, call_stat_fn, (void *)&check);
567 }
568