git.m6w6.name Git - m6w6/libmemcached/blob - lib/memcached_fetch.c

   1 #include "common.h"
   2 #include "memcached_io.h"
   3
   4 memcached_return value_fetch(memcached_server_st *ptr,
   5                              char *buffer,
   6                              memcached_result_st *result)
   7 {
   8   memcached_return rc= MEMCACHED_SUCCESS;
   9   char *string_ptr;
  10   char *end_ptr;
  11   char *next_ptr;
  12   size_t value_length;
  13   size_t read_length;
  14   size_t to_read;
  15   char *value_ptr;
  16
  17   end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
  18
  19   result->key_length= 0;
  20   result->flags= 0;
  21   memcached_string_reset(&result->value);
  22
  23   string_ptr= buffer;
  24   string_ptr+= 6; /* "VALUE " */
  25
  26
  27   /* We load the key */
  28   {
  29     char *key;
  30
  31     key= result->key;
  32     result->key_length= 0;
  33
  34     for (; isgraph(*string_ptr); string_ptr++)
  35     {
  36       *key= *string_ptr;
  37       key++;
  38       result->key_length++;
  39     }
  40     result->key[result->key_length]= 0;
  41   }
  42
  43   if (end_ptr == string_ptr)
  44     goto read_error;
  45
  46   /* Flags fetch move past space */
  47   string_ptr++;
  48   if (end_ptr == string_ptr)
  49     goto read_error;
  50   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
  51   result->flags= (uint32_t)strtol(next_ptr, &string_ptr, 10);
  52
  53   if (end_ptr == string_ptr)
  54     goto read_error;
  55
  56   /* Length fetch move past space*/
  57   string_ptr++;
  58   if (end_ptr == string_ptr)
  59     goto read_error;
  60
  61   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
  62   value_length= (size_t)strtoll(next_ptr, &string_ptr, 10);
  63
  64   if (end_ptr == string_ptr)
  65     goto read_error;
  66
  67   /* Skip spaces */
  68   if (*string_ptr == '\r')
  69   {
  70     /* Skip past the \r\n */
  71     string_ptr+= 2;
  72     result->cas= 0;
  73   }
  74   else
  75   {
  76     string_ptr++;
  77     for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
  78     result->cas= (size_t)strtoll(next_ptr, &string_ptr, 10);
  79   }
  80
  81   if (end_ptr < string_ptr)
  82     goto read_error;
  83
  84   /* We add two bytes so that we can walk the \r\n */
  85   rc= memcached_string_check(&result->value, value_length+2);
  86   if (rc != MEMCACHED_SUCCESS)
  87   {
  88     value_length= 0;
  89     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  90   }
  91
  92   value_ptr= memcached_string_value(&result->value);
  93   read_length= 0;
  94   /*
  95     We read the \r\n into the string since not doing so is more
  96     cycles then the waster of memory to do so.
  97
  98     We are null terminating through, which will most likely make
  99     some people lazy about using the return length.
 100   */
 101   to_read= (value_length) + 2;
 102   read_length= memcached_io_read(ptr, value_ptr, to_read);
 103   if (read_length != (size_t)(value_length + 2))
 104   {
 105     goto read_error;
 106   }
 107
 108 /* This next bit blows the API, but this is internal....*/
 109   {
 110     char *char_ptr;
 111     char_ptr= memcached_string_value(&result->value);;
 112     char_ptr[value_length]= 0;
 113     char_ptr[value_length + 1]= 0;
 114     memcached_string_set_length(&result->value, value_length);
 115   }
 116
 117   return MEMCACHED_SUCCESS;
 118
 119 read_error:
 120   memcached_io_reset(ptr);
 121
 122   return MEMCACHED_PARTIAL_READ;
 123 }
 124
 125 char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length,
 126                     size_t *value_length,
 127                     uint32_t *flags,
 128                     memcached_return *error)
 129 {
 130   memcached_result_st *result_buffer= &ptr->result;
 131
 132   while (ptr->cursor_server < ptr->number_of_hosts)
 133   {
 134     char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
 135
 136     if (memcached_server_response_count(&ptr->hosts[ptr->cursor_server]) == 0)
 137     {
 138       ptr->cursor_server++;
 139       continue;
 140     }
 141
 142   *error= memcached_response(&ptr->hosts[ptr->cursor_server], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, result_buffer);
 143
 144     if (*error == MEMCACHED_END) /* END means that we move on to the next */
 145     {
 146       memcached_server_response_reset(&ptr->hosts[ptr->cursor_server]);
 147       ptr->cursor_server++;
 148       continue;
 149     }
 150     else if (*error == MEMCACHED_SUCCESS)
 151     {
 152       *value_length= memcached_string_length(&result_buffer->value);
 153
 154       if (key)
 155       {
 156         strncpy(key, result_buffer->key, result_buffer->key_length);
 157         *key_length= result_buffer->key_length;
 158       }
 159
 160       if (result_buffer->flags)
 161         *flags= result_buffer->flags;
 162
 163       return  memcached_string_c_copy(&result_buffer->value);
 164     }
 165     else
 166     {
 167       *value_length= 0;
 168       return NULL;
 169     }
 170   }
 171
 172   ptr->cursor_server= 0;
 173   *value_length= 0;
 174   return NULL;
 175 }
 176
 177 memcached_result_st *memcached_fetch_result(memcached_st *ptr,
 178                                             memcached_result_st *result,
 179                                             memcached_return *error)
 180 {
 181   if (result == NULL)
 182     result= memcached_result_create(ptr, NULL);
 183
 184   WATCHPOINT_ASSERT(result->value.is_allocated != MEMCACHED_USED);
 185
 186 #ifdef UNUSED
 187   if (ptr->flags & MEM_NO_BLOCK)
 188     memcached_io_preread(ptr);
 189 #endif
 190
 191   while (ptr->cursor_server < ptr->number_of_hosts)
 192   {
 193     char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
 194
 195     if (memcached_server_response_count(&ptr->hosts[ptr->cursor_server]) == 0)
 196     {
 197       ptr->cursor_server++;
 198       continue;
 199     }
 200
 201     *error= memcached_response(&ptr->hosts[ptr->cursor_server], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, result);
 202
 203     if (*error == MEMCACHED_END) /* END means that we move on to the next */
 204     {
 205       memcached_server_response_reset(&ptr->hosts[ptr->cursor_server]);
 206       ptr->cursor_server++;
 207       continue;
 208     }
 209     else if (*error == MEMCACHED_SUCCESS)
 210       return result;
 211     else
 212       return NULL;
 213   }
 214
 215   /* We have completed reading data */
 216   if (result->is_allocated == MEMCACHED_ALLOCATED)
 217     memcached_result_free(result);
 218   else
 219     memcached_string_reset(&result->value);
 220
 221   ptr->cursor_server= 0;
 222   return NULL;
 223 }