Merge Monty
[m6w6/libmemcached] / libmemcached / memcached_response.c
1 /*
2 Memcached library
3
4 memcached_response() is used to determine the return result
5 from an issued command.
6 */
7
8 #include "common.h"
9 #include "memcached_io.h"
10
11 static memcached_return textual_read_one_response(memcached_server_st *ptr,
12 char *buffer, size_t buffer_length,
13 memcached_result_st *result);
14 static memcached_return binary_read_one_response(memcached_server_st *ptr,
15 char *buffer, size_t buffer_length,
16 memcached_result_st *result);
17
18 memcached_return memcached_read_one_response(memcached_server_st *ptr,
19 char *buffer, size_t buffer_length,
20 memcached_result_st *result)
21 {
22 memcached_server_response_decrement(ptr);
23
24 if (result == NULL)
25 result = &ptr->root->result;
26
27 memcached_return rc;
28 if (ptr->root->flags & MEM_BINARY_PROTOCOL)
29 rc= binary_read_one_response(ptr, buffer, buffer_length, result);
30 else
31 rc= textual_read_one_response(ptr, buffer, buffer_length, result);
32
33 unlikely(rc == MEMCACHED_UNKNOWN_READ_FAILURE ||
34 rc == MEMCACHED_PROTOCOL_ERROR ||
35 rc == MEMCACHED_CLIENT_ERROR ||
36 rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
37 memcached_io_reset(ptr);
38
39 return rc;
40 }
41
42 memcached_return memcached_response(memcached_server_st *ptr,
43 char *buffer, size_t buffer_length,
44 memcached_result_st *result)
45 {
46 /* We may have old commands in the buffer not set, first purge */
47 if (ptr->root->flags & MEM_NO_BLOCK)
48 (void)memcached_io_write(ptr, NULL, 0, 1);
49
50 /*
51 * The previous implementation purged all pending requests and just
52 * returned the last one. Purge all pending messages to ensure backwards
53 * compatibility.
54 */
55 if ((ptr->root->flags & MEM_BINARY_PROTOCOL) == 0)
56 while (memcached_server_response_count(ptr) > 1)
57 {
58 memcached_return rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
59
60 unlikely (rc != MEMCACHED_END &&
61 rc != MEMCACHED_STORED &&
62 rc != MEMCACHED_SUCCESS &&
63 rc != MEMCACHED_STAT &&
64 rc != MEMCACHED_DELETED &&
65 rc != MEMCACHED_NOTFOUND &&
66 rc != MEMCACHED_NOTSTORED &&
67 rc != MEMCACHED_DATA_EXISTS)
68 return rc;
69 }
70
71 return memcached_read_one_response(ptr, buffer, buffer_length, result);
72 }
73
74 static memcached_return textual_value_fetch(memcached_server_st *ptr,
75 char *buffer,
76 memcached_result_st *result)
77 {
78 memcached_return rc= MEMCACHED_SUCCESS;
79 char *string_ptr;
80 char *end_ptr;
81 char *next_ptr;
82 size_t value_length;
83 size_t to_read;
84 char *value_ptr;
85
86 if (ptr->root->flags & MEM_USE_UDP)
87 return MEMCACHED_NOT_SUPPORTED;
88
89 WATCHPOINT_ASSERT(ptr->root);
90 end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
91
92 memcached_result_reset(result);
93
94 string_ptr= buffer;
95 string_ptr+= 6; /* "VALUE " */
96
97
98 /* We load the key */
99 {
100 char *key;
101 size_t prefix_length;
102
103 key= result->key;
104 result->key_length= 0;
105
106 for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
107 {
108 if (prefix_length == 0)
109 {
110 *key= *string_ptr;
111 key++;
112 result->key_length++;
113 }
114 else
115 prefix_length--;
116 }
117 result->key[result->key_length]= 0;
118 }
119
120 if (end_ptr == string_ptr)
121 goto read_error;
122
123 /* Flags fetch move past space */
124 string_ptr++;
125 if (end_ptr == string_ptr)
126 goto read_error;
127 for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
128 result->flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
129
130 if (end_ptr == string_ptr)
131 goto read_error;
132
133 /* Length fetch move past space*/
134 string_ptr++;
135 if (end_ptr == string_ptr)
136 goto read_error;
137
138 for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
139 value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
140
141 if (end_ptr == string_ptr)
142 goto read_error;
143
144 /* Skip spaces */
145 if (*string_ptr == '\r')
146 {
147 /* Skip past the \r\n */
148 string_ptr+= 2;
149 }
150 else
151 {
152 string_ptr++;
153 for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
154 result->cas= strtoull(next_ptr, &string_ptr, 10);
155 }
156
157 if (end_ptr < string_ptr)
158 goto read_error;
159
160 /* We add two bytes so that we can walk the \r\n */
161 rc= memcached_string_check(&result->value, value_length+2);
162 if (rc != MEMCACHED_SUCCESS)
163 {
164 value_length= 0;
165 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
166 }
167
168 value_ptr= memcached_string_value(&result->value);
169 /*
170 We read the \r\n into the string since not doing so is more
171 cycles then the waster of memory to do so.
172
173 We are null terminating through, which will most likely make
174 some people lazy about using the return length.
175 */
176 to_read= (value_length) + 2;
177 ssize_t read_length= 0;
178 memcached_return rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
179 if (rrc != MEMCACHED_SUCCESS)
180 return rrc;
181
182 if (read_length != (ssize_t)(value_length + 2))
183 {
184 goto read_error;
185 }
186
187 /* This next bit blows the API, but this is internal....*/
188 {
189 char *char_ptr;
190 char_ptr= memcached_string_value(&result->value);;
191 char_ptr[value_length]= 0;
192 char_ptr[value_length + 1]= 0;
193 memcached_string_set_length(&result->value, value_length);
194 }
195
196 return MEMCACHED_SUCCESS;
197
198 read_error:
199 memcached_io_reset(ptr);
200
201 return MEMCACHED_PARTIAL_READ;
202 }
203
204 static memcached_return textual_read_one_response(memcached_server_st *ptr,
205 char *buffer, size_t buffer_length,
206 memcached_result_st *result)
207 {
208 memcached_return rc= memcached_io_readline(ptr, buffer, buffer_length);
209 if (rc != MEMCACHED_SUCCESS)
210 return rc;
211
212 switch(buffer[0])
213 {
214 case 'V': /* VALUE || VERSION */
215 if (buffer[1] == 'A') /* VALUE */
216 {
217 /* We add back in one because we will need to search for END */
218 memcached_server_response_increment(ptr);
219 return textual_value_fetch(ptr, buffer, result);
220 }
221 else if (buffer[1] == 'E') /* VERSION */
222 {
223 return MEMCACHED_SUCCESS;
224 }
225 else
226 {
227 WATCHPOINT_STRING(buffer);
228 WATCHPOINT_ASSERT(0);
229 return MEMCACHED_UNKNOWN_READ_FAILURE;
230 }
231 case 'O': /* OK */
232 return MEMCACHED_SUCCESS;
233 case 'S': /* STORED STATS SERVER_ERROR */
234 {
235 if (buffer[2] == 'A') /* STORED STATS */
236 {
237 memcached_server_response_increment(ptr);
238 return MEMCACHED_STAT;
239 }
240 else if (buffer[1] == 'E') /* SERVER_ERROR */
241 {
242 char *rel_ptr;
243 char *startptr= buffer + 13, *endptr= startptr;
244
245 while (*endptr != '\r' && *endptr != '\n') endptr++;
246
247 /*
248 Yes, we could make this "efficent" but to do that we would need
249 to maintain more state for the size of the buffer. Why waste
250 memory in the struct, which is important, for something that
251 rarely should happen?
252 */
253 rel_ptr= (char *)ptr->root->call_realloc(ptr->root,
254 ptr->cached_server_error,
255 (size_t) (endptr - startptr + 1));
256
257 if (rel_ptr == NULL)
258 {
259 /* If we happened to have some memory, we just null it since we don't know the size */
260 if (ptr->cached_server_error)
261 ptr->cached_server_error[0]= 0;
262 return MEMCACHED_SERVER_ERROR;
263 }
264 ptr->cached_server_error= rel_ptr;
265
266 memcpy(ptr->cached_server_error, startptr, (size_t) (endptr - startptr));
267 ptr->cached_server_error[endptr - startptr]= 0;
268 return MEMCACHED_SERVER_ERROR;
269 }
270 else if (buffer[1] == 'T')
271 return MEMCACHED_STORED;
272 else
273 {
274 WATCHPOINT_STRING(buffer);
275 WATCHPOINT_ASSERT(0);
276 return MEMCACHED_UNKNOWN_READ_FAILURE;
277 }
278 }
279 case 'D': /* DELETED */
280 return MEMCACHED_DELETED;
281 case 'N': /* NOT_FOUND */
282 {
283 if (buffer[4] == 'F')
284 return MEMCACHED_NOTFOUND;
285 else if (buffer[4] == 'S')
286 return MEMCACHED_NOTSTORED;
287 else
288 return MEMCACHED_UNKNOWN_READ_FAILURE;
289 }
290 case 'E': /* PROTOCOL ERROR or END */
291 {
292 if (buffer[1] == 'N')
293 return MEMCACHED_END;
294 else if (buffer[1] == 'R')
295 return MEMCACHED_PROTOCOL_ERROR;
296 else if (buffer[1] == 'X')
297 return MEMCACHED_DATA_EXISTS;
298 else
299 return MEMCACHED_UNKNOWN_READ_FAILURE;
300 }
301 case 'I': /* CLIENT ERROR */
302 /* We add back in one because we will need to search for END */
303 memcached_server_response_increment(ptr);
304 return MEMCACHED_ITEM;
305 case 'C': /* CLIENT ERROR */
306 return MEMCACHED_CLIENT_ERROR;
307 default:
308 {
309 unsigned long long auto_return_value;
310
311 if (sscanf(buffer, "%llu", &auto_return_value) == 1)
312 return MEMCACHED_SUCCESS;
313
314 return MEMCACHED_UNKNOWN_READ_FAILURE;
315 }
316 }
317
318 /* NOTREACHED */
319 }
320
321 char *memcached_result_value(memcached_result_st *ptr)
322 {
323 memcached_string_st *sptr= &ptr->value;
324 return memcached_string_value(sptr);
325 }
326
327 size_t memcached_result_length(memcached_result_st *ptr)
328 {
329 memcached_string_st *sptr= &ptr->value;
330 return memcached_string_length(sptr);
331 }
332
333 static memcached_return binary_read_one_response(memcached_server_st *ptr,
334 char *buffer, size_t buffer_length,
335 memcached_result_st *result)
336 {
337 protocol_binary_response_header header;
338
339 unlikely (memcached_safe_read(ptr, &header.bytes,
340 sizeof(header.bytes)) != MEMCACHED_SUCCESS)
341 return MEMCACHED_UNKNOWN_READ_FAILURE;
342
343 unlikely (header.response.magic != PROTOCOL_BINARY_RES)
344 return MEMCACHED_PROTOCOL_ERROR;
345
346 /*
347 ** Convert the header to host local endian!
348 */
349 header.response.keylen= ntohs(header.response.keylen);
350 header.response.status= ntohs(header.response.status);
351 header.response.bodylen= ntohl(header.response.bodylen);
352 header.response.cas= ntohll(header.response.cas);
353 uint32_t bodylen= header.response.bodylen;
354
355 if (header.response.status == 0)
356 {
357 switch (header.response.opcode)
358 {
359 case PROTOCOL_BINARY_CMD_GETK:
360 case PROTOCOL_BINARY_CMD_GETKQ:
361 {
362 uint16_t keylen= header.response.keylen;
363 memcached_result_reset(result);
364 result->cas= header.response.cas;
365
366 if (memcached_safe_read(ptr, &result->flags,
367 sizeof (result->flags)) != MEMCACHED_SUCCESS)
368 return MEMCACHED_UNKNOWN_READ_FAILURE;
369
370 result->flags= ntohl(result->flags);
371 bodylen -= header.response.extlen;
372
373 result->key_length= keylen;
374 if (memcached_safe_read(ptr, result->key, keylen) != MEMCACHED_SUCCESS)
375 return MEMCACHED_UNKNOWN_READ_FAILURE;
376
377 bodylen -= keylen;
378 if (memcached_string_check(&result->value,
379 bodylen) != MEMCACHED_SUCCESS)
380 return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
381
382 char *vptr= memcached_string_value(&result->value);
383 if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
384 return MEMCACHED_UNKNOWN_READ_FAILURE;
385
386 memcached_string_set_length(&result->value, bodylen);
387 }
388 break;
389 case PROTOCOL_BINARY_CMD_INCREMENT:
390 case PROTOCOL_BINARY_CMD_DECREMENT:
391 {
392 if (bodylen != sizeof(uint64_t) || buffer_length != sizeof(uint64_t))
393 return MEMCACHED_PROTOCOL_ERROR;
394
395 WATCHPOINT_ASSERT(bodylen == buffer_length);
396 uint64_t val;
397 if (memcached_safe_read(ptr, &val, sizeof(val)) != MEMCACHED_SUCCESS)
398 return MEMCACHED_UNKNOWN_READ_FAILURE;
399
400 val= ntohll(val);
401 memcpy(buffer, &val, sizeof(val));
402 }
403 break;
404 case PROTOCOL_BINARY_CMD_VERSION:
405 {
406 memset(buffer, 0, buffer_length);
407 if (bodylen >= buffer_length)
408 /* not enough space in buffer.. should not happen... */
409 return MEMCACHED_UNKNOWN_READ_FAILURE;
410 else if (memcached_safe_read(ptr, buffer, bodylen) != MEMCACHED_SUCCESS)
411 return MEMCACHED_UNKNOWN_READ_FAILURE;
412 }
413 break;
414 case PROTOCOL_BINARY_CMD_FLUSH:
415 case PROTOCOL_BINARY_CMD_QUIT:
416 case PROTOCOL_BINARY_CMD_SET:
417 case PROTOCOL_BINARY_CMD_ADD:
418 case PROTOCOL_BINARY_CMD_REPLACE:
419 case PROTOCOL_BINARY_CMD_APPEND:
420 case PROTOCOL_BINARY_CMD_PREPEND:
421 case PROTOCOL_BINARY_CMD_DELETE:
422 {
423 WATCHPOINT_ASSERT(bodylen == 0);
424 return MEMCACHED_SUCCESS;
425 }
426 case PROTOCOL_BINARY_CMD_NOOP:
427 {
428 WATCHPOINT_ASSERT(bodylen == 0);
429 return MEMCACHED_END;
430 }
431 case PROTOCOL_BINARY_CMD_STAT:
432 {
433 if (bodylen == 0)
434 return MEMCACHED_END;
435 else if (bodylen + 1 > buffer_length)
436 /* not enough space in buffer.. should not happen... */
437 return MEMCACHED_UNKNOWN_READ_FAILURE;
438 else
439 {
440 size_t keylen= header.response.keylen;
441 memset(buffer, 0, buffer_length);
442 if (memcached_safe_read(ptr, buffer, keylen) != MEMCACHED_SUCCESS ||
443 memcached_safe_read(ptr, buffer + keylen + 1,
444 bodylen - keylen) != MEMCACHED_SUCCESS)
445 return MEMCACHED_UNKNOWN_READ_FAILURE;
446 }
447 }
448 break;
449 default:
450 {
451 /* Command not implemented yet! */
452 WATCHPOINT_ASSERT(0);
453 return MEMCACHED_PROTOCOL_ERROR;
454 }
455 }
456 }
457 else if (header.response.bodylen)
458 {
459 /* What should I do with the error message??? just discard it for now */
460 char hole[SMALL_STRING_LEN];
461 while (bodylen > 0)
462 {
463 size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
464 if (memcached_safe_read(ptr, hole, nr) != MEMCACHED_SUCCESS)
465 return MEMCACHED_UNKNOWN_READ_FAILURE;
466 bodylen-= (uint32_t) nr;
467 }
468
469 /* This might be an error from one of the quiet commands.. if
470 * so, just throw it away and get the next one. What about creating
471 * a callback to the user with the error information?
472 */
473 switch (header.response.opcode)
474 {
475 case PROTOCOL_BINARY_CMD_SETQ:
476 case PROTOCOL_BINARY_CMD_ADDQ:
477 case PROTOCOL_BINARY_CMD_REPLACEQ:
478 case PROTOCOL_BINARY_CMD_APPENDQ:
479 case PROTOCOL_BINARY_CMD_PREPENDQ:
480 return binary_read_one_response(ptr, buffer, buffer_length, result);
481 default:
482 break;
483 }
484 }
485
486 memcached_return rc= MEMCACHED_SUCCESS;
487 unlikely(header.response.status != 0)
488 switch (header.response.status)
489 {
490 case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
491 rc= MEMCACHED_NOTFOUND;
492 break;
493 case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
494 rc= MEMCACHED_DATA_EXISTS;
495 break;
496 case PROTOCOL_BINARY_RESPONSE_E2BIG:
497 case PROTOCOL_BINARY_RESPONSE_EINVAL:
498 case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
499 case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
500 case PROTOCOL_BINARY_RESPONSE_ENOMEM:
501 default:
502 /* @todo fix the error mappings */
503 rc= MEMCACHED_PROTOCOL_ERROR;
504 break;
505 }
506
507 return rc;
508 }