git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/version.c

   1 #include "common.h"
   2
   3 const char * memcached_lib_version(void)
   4 {
   5   return LIBMEMCACHED_VERSION_STRING;
   6 }
   7
   8 static inline memcached_return_t memcached_version_binary(memcached_st *ptr);
   9 static inline memcached_return_t memcached_version_textual(memcached_st *ptr);
  10
  11 memcached_return_t memcached_version(memcached_st *ptr)
  12 {
  13   if (ptr->flags.use_udp)
  14     return MEMCACHED_NOT_SUPPORTED;
  15
  16   if (ptr->flags.binary_protocol)
  17     return memcached_version_binary(ptr);
  18   else
  19     return memcached_version_textual(ptr);
  20 }
  21
  22 static inline memcached_return_t memcached_version_textual(memcached_st *ptr)
  23 {
  24   size_t send_length;
  25   memcached_return_t rc;
  26   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
  27   char *response_ptr;
  28   const char *command= "version\r\n";
  29
  30   send_length= strlen(command);
  31
  32   rc= MEMCACHED_SUCCESS;
  33   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
  34   {
  35     memcached_return_t rrc;
  36     memcached_server_write_instance_st instance=
  37       memcached_server_instance_fetch(ptr, x);
  38
  39     rrc= memcached_do(instance, command, send_length, true);
  40     if (rrc != MEMCACHED_SUCCESS)
  41     {
  42       rc= MEMCACHED_SOME_ERRORS;
  43       continue;
  44     }
  45
  46     rrc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
  47     if (rrc != MEMCACHED_SUCCESS)
  48     {
  49       rc= MEMCACHED_SOME_ERRORS;
  50       continue;
  51     }
  52
  53     /* Find the space, and then move one past it to copy version */
  54     response_ptr= index(buffer, ' ');
  55     response_ptr++;
  56
  57     instance->major_version= (uint8_t)strtol(response_ptr, (char **)NULL, 10);
  58     response_ptr= index(response_ptr, '.');
  59     response_ptr++;
  60     instance->minor_version= (uint8_t)strtol(response_ptr, (char **)NULL, 10);
  61     response_ptr= index(response_ptr, '.');
  62     response_ptr++;
  63     instance->micro_version= (uint8_t)strtol(response_ptr, (char **)NULL, 10);
  64   }
  65
  66   return rc;
  67 }
  68
  69 static inline memcached_return_t memcached_version_binary(memcached_st *ptr)
  70 {
  71   memcached_return_t rc;
  72   protocol_binary_request_version request= { .bytes= {0}};
  73   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
  74   request.message.header.request.opcode= PROTOCOL_BINARY_CMD_VERSION;
  75   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
  76
  77   rc= MEMCACHED_SUCCESS;
  78   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
  79   {
  80     memcached_return_t rrc;
  81
  82     memcached_server_write_instance_st instance=
  83       memcached_server_instance_fetch(ptr, x);
  84
  85     rrc= memcached_do(instance, request.bytes, sizeof(request.bytes), true);
  86     if (rrc != MEMCACHED_SUCCESS)
  87     {
  88       memcached_io_reset(instance);
  89       rc= MEMCACHED_SOME_ERRORS;
  90       continue;
  91     }
  92   }
  93
  94   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
  95   {
  96     memcached_server_write_instance_st instance=
  97       memcached_server_instance_fetch(ptr, x);
  98
  99     if (memcached_server_response_count(instance) > 0)
 100     {
 101       memcached_return_t rrc;
 102       char buffer[32];
 103       char *p;
 104
 105       rrc= memcached_response(instance, buffer, sizeof(buffer), NULL);
 106       if (rrc != MEMCACHED_SUCCESS)
 107       {
 108         memcached_io_reset(instance);
 109         rc= MEMCACHED_SOME_ERRORS;
 110         continue;
 111       }
 112
 113       instance->major_version= (uint8_t)strtol(buffer, &p, 10);
 114       instance->minor_version= (uint8_t)strtol(p + 1, &p, 10);
 115       instance->micro_version= (uint8_t)strtol(p + 1, NULL, 10);
 116     }
 117   }
 118
 119   return rc;
 120 }