projects / awesomized / libmemcached / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
On success, we should exit the loop.
[awesomized/libmemcached] / libmemcached / protocol / binary_handler.c
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * Libmemcached library
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 *
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following disclaimer
16 * in the documentation and/or other materials provided with the
17 * distribution.
18 *
19 * * The names of its contributors may not be used to endorse or
20 * promote products derived from this software without specific prior
21 * written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 */
36
37 #include <libmemcached/protocol/common.h>
38 #include <libmemcached/byteorder.h>
39
40 #include <stdlib.h>
41 #include <sys/types.h>
42 #include <errno.h>
43 #include <stdbool.h>
44 #include <string.h>
45 #include <stdio.h>
46
47 /*
48 ** **********************************************************************
49 ** INTERNAL INTERFACE
50 ** **********************************************************************
51 */
52
53 /**
54 * Send a preformatted packet back to the client. If the connection is in
55 * pedantic mode, it will validate the packet and refuse to send it if it
56 * breaks the specification.
57 *
58 * @param cookie client identification
59 * @param request the original request packet
60 * @param response the packet to send
61 * @return The status of the operation
62 */
63 static protocol_binary_response_status
64 raw_response_handler(const void *cookie,
65 protocol_binary_request_header *request,
66 protocol_binary_response_header *response)
67 {
68 memcached_protocol_client_st *client= (void*)cookie;
69
70 if (client->root->pedantic &&
71 !memcached_binary_protocol_pedantic_check_response(request, response))
72 {
73 return PROTOCOL_BINARY_RESPONSE_EINVAL;
74 }
75
76 if (!client->root->drain(client))
77 {
78 return PROTOCOL_BINARY_RESPONSE_EINTERNAL;
79 }
80
81 size_t len= sizeof(*response) + htonl(response->response.bodylen);
82 size_t offset= 0;
83 char *ptr= (void*)response;
84
85 if (client->output == NULL)
86 {
87 /* I can write directly to the socket.... */
88 do
89 {
90 size_t num_bytes= len - offset;
91 ssize_t nw= client->root->send(client,
92 client->sock,
93 ptr + offset,
94 num_bytes);
95 if (nw == -1)
96 {
97 if (get_socket_errno() == EWOULDBLOCK)
98 {
99 break;
100 }
101 else if (get_socket_errno() != EINTR)
102 {
103 client->error= errno;
104 return PROTOCOL_BINARY_RESPONSE_EINTERNAL;
105 }
106 }
107 else
108 {
109 offset += (size_t)nw;
110 }
111 } while (offset < len);
112 }
113
114 return client->root->spool(client, ptr, len - offset);
115 }
116
117 /*
118 * Version 0 of the interface is really low level and protocol specific,
119 * while the version 1 of the interface is more API focused. We need a
120 * way to translate between the command codes on the wire and the
121 * application level interface in V1, so let's just use the V0 of the
122 * interface as a map instead of creating a huuuge switch :-)
123 */
124
125 /**
126 * Callback for the GET/GETQ/GETK and GETKQ responses
127 * @param cookie client identifier
128 * @param key the key for the item
129 * @param keylen the length of the key
130 * @param body the length of the body
131 * @param bodylen the length of the body
132 * @param flags the flags for the item
133 * @param cas the CAS id for the item
134 */
135 static protocol_binary_response_status
136 get_response_handler(const void *cookie,
137 const void *key,
138 uint16_t keylen,
139 const void *body,
140 uint32_t bodylen,
141 uint32_t flags,
142 uint64_t cas) {
143
144 memcached_protocol_client_st *client= (void*)cookie;
145 uint8_t opcode= client->current_command->request.opcode;
146
147 if (opcode == PROTOCOL_BINARY_CMD_GET || opcode == PROTOCOL_BINARY_CMD_GETQ)
148 {
149 keylen= 0;
150 }
151
152 protocol_binary_response_get response= {
153 .message.header.response= {
154 .magic= PROTOCOL_BINARY_RES,
155 .opcode= opcode,
156 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
157 .opaque= client->current_command->request.opaque,
158 .cas= memcached_htonll(cas),
159 .keylen= htons(keylen),
160 .extlen= 4,
161 .bodylen= htonl(bodylen + keylen + 4),
162 },
163 };
164
165 response.message.body.flags= htonl(flags);
166
167 protocol_binary_response_status rval;
168 const protocol_binary_response_status success= PROTOCOL_BINARY_RESPONSE_SUCCESS;
169 if ((rval= client->root->spool(client, response.bytes, sizeof(response.bytes))) != success ||
170 (rval= client->root->spool(client, key, keylen)) != success ||
171 (rval= client->root->spool(client, body, bodylen)) != success)
172 {
173 return rval;
174 }
175
176 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
177 }
178
179 /**
180 * Callback for the STAT responses
181 * @param cookie client identifier
182 * @param key the key for the item
183 * @param keylen the length of the key
184 * @param body the length of the body
185 * @param bodylen the length of the body
186 */
187 static protocol_binary_response_status stat_response_handler(const void *cookie,
188 const void *key,
189 uint16_t keylen,
190 const void *body,
191 uint32_t bodylen)
192 {
193
194 memcached_protocol_client_st *client= (void*)cookie;
195
196 protocol_binary_response_no_extras response= {
197 .message.header.response= {
198 .magic= PROTOCOL_BINARY_RES,
199 .opcode= client->current_command->request.opcode,
200 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
201 .opaque= client->current_command->request.opaque,
202 .keylen= htons(keylen),
203 .bodylen= htonl(bodylen + keylen),
204 .cas= 0
205 },
206 };
207
208 protocol_binary_response_status rval;
209 const protocol_binary_response_status success= PROTOCOL_BINARY_RESPONSE_SUCCESS;
210 if ((rval= client->root->spool(client, response.bytes, sizeof(response.bytes))) != success ||
211 (rval= client->root->spool(client, key, keylen)) != success ||
212 (rval= client->root->spool(client, body, bodylen)) != success)
213 {
214 return rval;
215 }
216
217 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
218 }
219
220 /**
221 * Callback for the VERSION responses
222 * @param cookie client identifier
223 * @param text the length of the body
224 * @param textlen the length of the body
225 */
226 static protocol_binary_response_status
227 version_response_handler(const void *cookie,
228 const void *text,
229 uint32_t textlen) {
230
231 memcached_protocol_client_st *client= (void*)cookie;
232
233 protocol_binary_response_no_extras response= {
234 .message.header.response= {
235 .magic= PROTOCOL_BINARY_RES,
236 .opcode= client->current_command->request.opcode,
237 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
238 .opaque= client->current_command->request.opaque,
239 .bodylen= htonl(textlen),
240 .cas= 0
241 },
242 };
243
244 protocol_binary_response_status rval;
245 const protocol_binary_response_status success= PROTOCOL_BINARY_RESPONSE_SUCCESS;
246 if ((rval= client->root->spool(client, response.bytes, sizeof(response.bytes))) != success ||
247 (rval= client->root->spool(client, text, textlen)) != success)
248 {
249 return rval;
250 }
251
252 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
253 }
254
255 /**
256 * Callback for ADD and ADDQ
257 * @param cookie the calling client
258 * @param header the add/addq command
259 * @param response_handler not used
260 * @return the result of the operation
261 */
262 static protocol_binary_response_status
263 add_command_handler(const void *cookie,
264 protocol_binary_request_header *header,
265 memcached_binary_protocol_raw_response_handler response_handler)
266 {
267 protocol_binary_response_status rval;
268
269 memcached_protocol_client_st *client= (void*)cookie;
270 if (client->root->callback->interface.v1.add != NULL)
271 {
272 uint16_t keylen= ntohs(header->request.keylen);
273 uint32_t datalen= ntohl(header->request.bodylen) - keylen - 8;
274 protocol_binary_request_add *request= (void*)header;
275 uint32_t flags= ntohl(request->message.body.flags);
276 uint32_t timeout= ntohl(request->message.body.expiration);
277 char *key= ((char*)header) + sizeof(*header) + 8;
278 char *data= key + keylen;
279 uint64_t cas;
280
281 rval= client->root->callback->interface.v1.add(cookie, key, keylen,
282 data, datalen, flags,
283 timeout, &cas);
284
285 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
286 header->request.opcode == PROTOCOL_BINARY_CMD_ADD)
287 {
288 /* Send a positive request */
289 protocol_binary_response_no_extras response= {
290 .message= {
291 .header.response= {
292 .magic= PROTOCOL_BINARY_RES,
293 .opcode= PROTOCOL_BINARY_CMD_ADD,
294 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
295 .opaque= header->request.opaque,
296 .cas= memcached_ntohll(cas)
297 }
298 }
299 };
300 rval= response_handler(cookie, header, (void*)&response);
301 }
302 }
303 else
304 {
305 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
306 }
307
308 return rval;
309 }
310
311 /**
312 * Callback for DECREMENT and DECREMENTQ
313 * @param cookie the calling client
314 * @param header the command
315 * @param response_handler not used
316 * @return the result of the operation
317 */
318 static protocol_binary_response_status
319 decrement_command_handler(const void *cookie,
320 protocol_binary_request_header *header,
321 memcached_binary_protocol_raw_response_handler response_handler)
322 {
323 (void)response_handler;
324 protocol_binary_response_status rval;
325
326 memcached_protocol_client_st *client= (void*)cookie;
327 if (client->root->callback->interface.v1.decrement != NULL)
328 {
329 uint16_t keylen= ntohs(header->request.keylen);
330 protocol_binary_request_decr *request= (void*)header;
331 uint64_t init= memcached_ntohll(request->message.body.initial);
332 uint64_t delta= memcached_ntohll(request->message.body.delta);
333 uint32_t timeout= ntohl(request->message.body.expiration);
334 void *key= request->bytes + sizeof(request->bytes);
335 uint64_t result;
336 uint64_t cas;
337
338 rval= client->root->callback->interface.v1.decrement(cookie, key, keylen,
339 delta, init, timeout,
340 &result, &cas);
341 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
342 header->request.opcode == PROTOCOL_BINARY_CMD_DECREMENT)
343 {
344 /* Send a positive request */
345 protocol_binary_response_decr response= {
346 .message= {
347 .header.response= {
348 .magic= PROTOCOL_BINARY_RES,
349 .opcode= PROTOCOL_BINARY_CMD_DECREMENT,
350 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
351 .opaque= header->request.opaque,
352 .cas= memcached_ntohll(cas),
353 .bodylen= htonl(8)
354 },
355 .body.value= memcached_htonll(result)
356 }
357 };
358 rval= response_handler(cookie, header, (void*)&response);
359 }
360 }
361 else
362 {
363 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
364 }
365
366 return rval;
367 }
368
369 /**
370 * Callback for DELETE and DELETEQ
371 * @param cookie the calling client
372 * @param header the command
373 * @param response_handler not used
374 * @return the result of the operation
375 */
376 static protocol_binary_response_status
377 delete_command_handler(const void *cookie,
378 protocol_binary_request_header *header,
379 memcached_binary_protocol_raw_response_handler response_handler)
380 {
381 (void)response_handler;
382 protocol_binary_response_status rval;
383
384 memcached_protocol_client_st *client= (void*)cookie;
385 if (client->root->callback->interface.v1.delete != NULL)
386 {
387 uint16_t keylen= ntohs(header->request.keylen);
388 void *key= (header +1);
389 uint64_t cas= memcached_ntohll(header->request.cas);
390 rval= client->root->callback->interface.v1.delete(cookie, key, keylen, cas);
391 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
392 header->request.opcode == PROTOCOL_BINARY_CMD_DELETE)
393 {
394 /* Send a positive request */
395 protocol_binary_response_no_extras response= {
396 .message= {
397 .header.response= {
398 .magic= PROTOCOL_BINARY_RES,
399 .opcode= PROTOCOL_BINARY_CMD_DELETE,
400 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
401 .opaque= header->request.opaque,
402 }
403 }
404 };
405 rval= response_handler(cookie, header, (void*)&response);
406 }
407 }
408 else
409 {
410 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
411 }
412
413 return rval;
414 }
415
416 /**
417 * Callback for FLUSH and FLUSHQ
418 * @param cookie the calling client
419 * @param header the command
420 * @param response_handler not used
421 * @return the result of the operation
422 */
423 static protocol_binary_response_status
424 flush_command_handler(const void *cookie,
425 protocol_binary_request_header *header,
426 memcached_binary_protocol_raw_response_handler response_handler)
427 {
428 (void)response_handler;
429 protocol_binary_response_status rval;
430
431 memcached_protocol_client_st *client= (void*)cookie;
432 if (client->root->callback->interface.v1.flush != NULL)
433 {
434 protocol_binary_request_flush *flush= (void*)header;
435 uint32_t timeout= 0;
436 if (htonl(header->request.bodylen) == 4)
437 {
438 timeout= ntohl(flush->message.body.expiration);
439 }
440
441 rval= client->root->callback->interface.v1.flush(cookie, timeout);
442 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
443 header->request.opcode == PROTOCOL_BINARY_CMD_FLUSH)
444 {
445 /* Send a positive request */
446 protocol_binary_response_no_extras response= {
447 .message= {
448 .header.response= {
449 .magic= PROTOCOL_BINARY_RES,
450 .opcode= PROTOCOL_BINARY_CMD_FLUSH,
451 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
452 .opaque= header->request.opaque,
453 }
454 }
455 };
456 rval= response_handler(cookie, header, (void*)&response);
457 }
458 }
459 else
460 {
461 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
462 }
463
464 return rval;
465 }
466
467 /**
468 * Callback for GET, GETK, GETQ, GETKQ
469 * @param cookie the calling client
470 * @param header the command
471 * @param response_handler not used
472 * @return the result of the operation
473 */
474 static protocol_binary_response_status
475 get_command_handler(const void *cookie,
476 protocol_binary_request_header *header,
477 memcached_binary_protocol_raw_response_handler response_handler)
478 {
479 (void)response_handler;
480 protocol_binary_response_status rval;
481
482 memcached_protocol_client_st *client= (void*)cookie;
483 if (client->root->callback->interface.v1.get != NULL)
484 {
485 uint16_t keylen= ntohs(header->request.keylen);
486 void *key= (header + 1);
487 rval= client->root->callback->interface.v1.get(cookie, key, keylen,
488 get_response_handler);
489
490 if (rval == PROTOCOL_BINARY_RESPONSE_KEY_ENOENT &&
491 (header->request.opcode == PROTOCOL_BINARY_CMD_GETQ ||
492 header->request.opcode == PROTOCOL_BINARY_CMD_GETKQ))
493 {
494 /* Quiet commands shouldn't respond on cache misses */
495 rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
496 }
497 }
498 else
499 {
500 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
501 }
502
503 return rval;
504 }
505
506 /**
507 * Callback for INCREMENT and INCREMENTQ
508 * @param cookie the calling client
509 * @param header the command
510 * @param response_handler not used
511 * @return the result of the operation
512 */
513 static protocol_binary_response_status
514 increment_command_handler(const void *cookie,
515 protocol_binary_request_header *header,
516 memcached_binary_protocol_raw_response_handler response_handler)
517 {
518 (void)response_handler;
519 protocol_binary_response_status rval;
520
521 memcached_protocol_client_st *client= (void*)cookie;
522 if (client->root->callback->interface.v1.increment != NULL)
523 {
524 uint16_t keylen= ntohs(header->request.keylen);
525 protocol_binary_request_incr *request= (void*)header;
526 uint64_t init= memcached_ntohll(request->message.body.initial);
527 uint64_t delta= memcached_ntohll(request->message.body.delta);
528 uint32_t timeout= ntohl(request->message.body.expiration);
529 void *key= request->bytes + sizeof(request->bytes);
530 uint64_t cas;
531 uint64_t result;
532
533 rval= client->root->callback->interface.v1.increment(cookie, key, keylen,
534 delta, init, timeout,
535 &result, &cas);
536 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
537 header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENT)
538 {
539 /* Send a positive request */
540 protocol_binary_response_incr response= {
541 .message= {
542 .header.response= {
543 .magic= PROTOCOL_BINARY_RES,
544 .opcode= PROTOCOL_BINARY_CMD_INCREMENT,
545 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
546 .opaque= header->request.opaque,
547 .cas= memcached_ntohll(cas),
548 .bodylen= htonl(8)
549 },
550 .body.value= memcached_htonll(result)
551 }
552 };
553
554 rval= response_handler(cookie, header, (void*)&response);
555 }
556 }
557 else
558 {
559 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
560 }
561
562 return rval;
563 }
564
565 /**
566 * Callback for noop. Inform the v1 interface about the noop packet, and
567 * create and send a packet back to the client
568 *
569 * @param cookie the calling client
570 * @param header the command
571 * @param response_handler the response handler
572 * @return the result of the operation
573 */
574 static protocol_binary_response_status
575 noop_command_handler(const void *cookie,
576 protocol_binary_request_header *header,
577 memcached_binary_protocol_raw_response_handler response_handler)
578 {
579 memcached_protocol_client_st *client= (void*)cookie;
580 if (client->root->callback->interface.v1.noop != NULL)
581 {
582 client->root->callback->interface.v1.noop(cookie);
583 }
584
585 protocol_binary_response_no_extras response= {
586 .message= {
587 .header.response= {
588 .magic= PROTOCOL_BINARY_RES,
589 .opcode= PROTOCOL_BINARY_CMD_NOOP,
590 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
591 .opaque= header->request.opaque,
592 }
593 }
594 };
595
596 return response_handler(cookie, header, (void*)&response);
597 }
598
599 /**
600 * Callback for APPEND and APPENDQ
601 * @param cookie the calling client
602 * @param header the command
603 * @param response_handler not used
604 * @return the result of the operation
605 */
606 static protocol_binary_response_status
607 append_command_handler(const void *cookie,
608 protocol_binary_request_header *header,
609 memcached_binary_protocol_raw_response_handler response_handler)
610 {
611 (void)response_handler;
612 protocol_binary_response_status rval;
613
614 memcached_protocol_client_st *client= (void*)cookie;
615 if (client->root->callback->interface.v1.append != NULL)
616 {
617 uint16_t keylen= ntohs(header->request.keylen);
618 uint32_t datalen= ntohl(header->request.bodylen) - keylen;
619 char *key= (void*)(header +1);
620 char *data= key +keylen;
621 uint64_t cas= memcached_ntohll(header->request.cas);
622 uint64_t result_cas;
623
624 rval= client->root->callback->interface.v1.append(cookie, key, keylen,
625 data, datalen, cas,
626 &result_cas);
627 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
628 header->request.opcode == PROTOCOL_BINARY_CMD_APPEND)
629 {
630 /* Send a positive request */
631 protocol_binary_response_no_extras response= {
632 .message= {
633 .header.response= {
634 .magic= PROTOCOL_BINARY_RES,
635 .opcode= PROTOCOL_BINARY_CMD_APPEND,
636 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
637 .opaque= header->request.opaque,
638 .cas= memcached_ntohll(result_cas),
639 },
640 }
641 };
642 rval= response_handler(cookie, header, (void*)&response);
643 }
644 }
645 else
646 {
647 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
648 }
649
650 return rval;
651 }
652
653 /**
654 * Callback for PREPEND and PREPENDQ
655 * @param cookie the calling client
656 * @param header the command
657 * @param response_handler not used
658 * @return the result of the operation
659 */
660 static protocol_binary_response_status
661 prepend_command_handler(const void *cookie,
662 protocol_binary_request_header *header,
663 memcached_binary_protocol_raw_response_handler response_handler)
664 {
665 (void)response_handler;
666 protocol_binary_response_status rval;
667
668 memcached_protocol_client_st *client= (void*)cookie;
669 if (client->root->callback->interface.v1.prepend != NULL)
670 {
671 uint16_t keylen= ntohs(header->request.keylen);
672 uint32_t datalen= ntohl(header->request.bodylen) - keylen;
673 char *key= (char*)(header + 1);
674 char *data= key + keylen;
675 uint64_t cas= memcached_ntohll(header->request.cas);
676 uint64_t result_cas;
677 rval= client->root->callback->interface.v1.prepend(cookie, key, keylen,
678 data, datalen, cas,
679 &result_cas);
680 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
681 header->request.opcode == PROTOCOL_BINARY_CMD_PREPEND)
682 {
683 /* Send a positive request */
684 protocol_binary_response_no_extras response= {
685 .message= {
686 .header.response= {
687 .magic= PROTOCOL_BINARY_RES,
688 .opcode= PROTOCOL_BINARY_CMD_PREPEND,
689 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
690 .opaque= header->request.opaque,
691 .cas= memcached_ntohll(result_cas),
692 },
693 }
694 };
695 rval= response_handler(cookie, header, (void*)&response);
696 }
697 }
698 else
699 {
700 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
701 }
702
703 return rval;
704 }
705
706 /**
707 * Callback for QUIT and QUITQ. Notify the client and shut down the connection
708 * @param cookie the calling client
709 * @param header the command
710 * @param response_handler not used
711 * @return the result of the operation
712 */
713 static protocol_binary_response_status
714 quit_command_handler(const void *cookie,
715 protocol_binary_request_header *header,
716 memcached_binary_protocol_raw_response_handler response_handler)
717 {
718 memcached_protocol_client_st *client= (void*)cookie;
719 if (client->root->callback->interface.v1.quit != NULL)
720 {
721 client->root->callback->interface.v1.quit(cookie);
722 }
723
724 protocol_binary_response_no_extras response= {
725 .message= {
726 .header.response= {
727 .magic= PROTOCOL_BINARY_RES,
728 .opcode= PROTOCOL_BINARY_CMD_QUIT,
729 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
730 .opaque= header->request.opaque
731 }
732 }
733 };
734
735 if (header->request.opcode == PROTOCOL_BINARY_CMD_QUIT)
736 {
737 response_handler(cookie, header, (void*)&response);
738 }
739
740 /* I need a better way to signal to close the connection */
741 return PROTOCOL_BINARY_RESPONSE_EINTERNAL;
742 }
743
744 /**
745 * Callback for REPLACE and REPLACEQ
746 * @param cookie the calling client
747 * @param header the command
748 * @param response_handler not used
749 * @return the result of the operation
750 */
751 static protocol_binary_response_status
752 replace_command_handler(const void *cookie,
753 protocol_binary_request_header *header,
754 memcached_binary_protocol_raw_response_handler response_handler)
755 {
756 (void)response_handler;
757 protocol_binary_response_status rval;
758
759 memcached_protocol_client_st *client= (void*)cookie;
760 if (client->root->callback->interface.v1.replace != NULL)
761 {
762 uint16_t keylen= ntohs(header->request.keylen);
763 uint32_t datalen= ntohl(header->request.bodylen) - keylen - 8;
764 protocol_binary_request_replace *request= (void*)header;
765 uint32_t flags= ntohl(request->message.body.flags);
766 uint32_t timeout= ntohl(request->message.body.expiration);
767 char *key= ((char*)header) + sizeof(*header) + 8;
768 char *data= key + keylen;
769 uint64_t cas= memcached_ntohll(header->request.cas);
770 uint64_t result_cas;
771
772 rval= client->root->callback->interface.v1.replace(cookie, key, keylen,
773 data, datalen, flags,
774 timeout, cas,
775 &result_cas);
776 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
777 header->request.opcode == PROTOCOL_BINARY_CMD_REPLACE)
778 {
779 /* Send a positive request */
780 protocol_binary_response_no_extras response= {
781 .message= {
782 .header.response= {
783 .magic= PROTOCOL_BINARY_RES,
784 .opcode= PROTOCOL_BINARY_CMD_REPLACE,
785 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
786 .opaque= header->request.opaque,
787 .cas= memcached_ntohll(result_cas),
788 },
789 }
790 };
791 rval= response_handler(cookie, header, (void*)&response);
792 }
793 }
794 else
795 {
796 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
797 }
798
799 return rval;
800 }
801
802 /**
803 * Callback for SET and SETQ
804 * @param cookie the calling client
805 * @param header the command
806 * @param response_handler not used
807 * @return the result of the operation
808 */
809 static protocol_binary_response_status
810 set_command_handler(const void *cookie,
811 protocol_binary_request_header *header,
812 memcached_binary_protocol_raw_response_handler response_handler)
813 {
814 (void)response_handler;
815 protocol_binary_response_status rval;
816
817 memcached_protocol_client_st *client= (void*)cookie;
818 if (client->root->callback->interface.v1.set != NULL)
819 {
820 uint16_t keylen= ntohs(header->request.keylen);
821 uint32_t datalen= ntohl(header->request.bodylen) - keylen - 8;
822 protocol_binary_request_replace *request= (void*)header;
823 uint32_t flags= ntohl(request->message.body.flags);
824 uint32_t timeout= ntohl(request->message.body.expiration);
825 char *key= ((char*)header) + sizeof(*header) + 8;
826 char *data= key + keylen;
827 uint64_t cas= memcached_ntohll(header->request.cas);
828 uint64_t result_cas;
829
830
831 rval= client->root->callback->interface.v1.set(cookie, key, keylen,
832 data, datalen, flags,
833 timeout, cas, &result_cas);
834 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS &&
835 header->request.opcode == PROTOCOL_BINARY_CMD_SET)
836 {
837 /* Send a positive request */
838 protocol_binary_response_no_extras response= {
839 .message= {
840 .header.response= {
841 .magic= PROTOCOL_BINARY_RES,
842 .opcode= PROTOCOL_BINARY_CMD_SET,
843 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
844 .opaque= header->request.opaque,
845 .cas= memcached_ntohll(result_cas),
846 },
847 }
848 };
849 rval= response_handler(cookie, header, (void*)&response);
850 }
851 }
852 else
853 {
854 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
855 }
856
857 return rval;
858 }
859
860 /**
861 * Callback for STAT
862 * @param cookie the calling client
863 * @param header the command
864 * @param response_handler not used
865 * @return the result of the operation
866 */
867 static protocol_binary_response_status
868 stat_command_handler(const void *cookie,
869 protocol_binary_request_header *header,
870 memcached_binary_protocol_raw_response_handler response_handler)
871 {
872 (void)response_handler;
873 protocol_binary_response_status rval;
874
875 memcached_protocol_client_st *client= (void*)cookie;
876 if (client->root->callback->interface.v1.stat != NULL)
877 {
878 uint16_t keylen= ntohs(header->request.keylen);
879
880 rval= client->root->callback->interface.v1.stat(cookie,
881 (void*)(header + 1),
882 keylen,
883 stat_response_handler);
884 }
885 else
886 {
887 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
888 }
889
890 return rval;
891 }
892
893 /**
894 * Callback for VERSION
895 * @param cookie the calling client
896 * @param header the command
897 * @param response_handler not used
898 * @return the result of the operation
899 */
900 static protocol_binary_response_status
901 version_command_handler(const void *cookie,
902 protocol_binary_request_header *header,
903 memcached_binary_protocol_raw_response_handler response_handler)
904 {
905 (void)response_handler;
906 (void)header;
907 protocol_binary_response_status rval;
908
909 memcached_protocol_client_st *client= (void*)cookie;
910 if (client->root->callback->interface.v1.version != NULL)
911 {
912 rval= client->root->callback->interface.v1.version(cookie,
913 version_response_handler);
914 }
915 else
916 {
917 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
918 }
919
920 return rval;
921 }
922
923 /**
924 * The map to remap between the com codes and the v1 logical setting
925 */
926 static memcached_binary_protocol_command_handler comcode_v0_v1_remap[256]= {
927 [PROTOCOL_BINARY_CMD_ADDQ]= add_command_handler,
928 [PROTOCOL_BINARY_CMD_ADD]= add_command_handler,
929 [PROTOCOL_BINARY_CMD_APPENDQ]= append_command_handler,
930 [PROTOCOL_BINARY_CMD_APPEND]= append_command_handler,
931 [PROTOCOL_BINARY_CMD_DECREMENTQ]= decrement_command_handler,
932 [PROTOCOL_BINARY_CMD_DECREMENT]= decrement_command_handler,
933 [PROTOCOL_BINARY_CMD_DELETEQ]= delete_command_handler,
934 [PROTOCOL_BINARY_CMD_DELETE]= delete_command_handler,
935 [PROTOCOL_BINARY_CMD_FLUSHQ]= flush_command_handler,
936 [PROTOCOL_BINARY_CMD_FLUSH]= flush_command_handler,
937 [PROTOCOL_BINARY_CMD_GETKQ]= get_command_handler,
938 [PROTOCOL_BINARY_CMD_GETK]= get_command_handler,
939 [PROTOCOL_BINARY_CMD_GETQ]= get_command_handler,
940 [PROTOCOL_BINARY_CMD_GET]= get_command_handler,
941 [PROTOCOL_BINARY_CMD_INCREMENTQ]= increment_command_handler,
942 [PROTOCOL_BINARY_CMD_INCREMENT]= increment_command_handler,
943 [PROTOCOL_BINARY_CMD_NOOP]= noop_command_handler,
944 [PROTOCOL_BINARY_CMD_PREPENDQ]= prepend_command_handler,
945 [PROTOCOL_BINARY_CMD_PREPEND]= prepend_command_handler,
946 [PROTOCOL_BINARY_CMD_QUITQ]= quit_command_handler,
947 [PROTOCOL_BINARY_CMD_QUIT]= quit_command_handler,
948 [PROTOCOL_BINARY_CMD_REPLACEQ]= replace_command_handler,
949 [PROTOCOL_BINARY_CMD_REPLACE]= replace_command_handler,
950 [PROTOCOL_BINARY_CMD_SETQ]= set_command_handler,
951 [PROTOCOL_BINARY_CMD_SET]= set_command_handler,
952 [PROTOCOL_BINARY_CMD_STAT]= stat_command_handler,
953 [PROTOCOL_BINARY_CMD_VERSION]= version_command_handler,
954 };
955
956 /**
957 * Try to execute a command. Fire the pre/post functions and the specialized
958 * handler function if it's set. If not, the unknown probe should be fired
959 * if it's present.
960 * @param client the client connection to operate on
961 * @param header the command to execute
962 * @return true if success or false if a fatal error occured so that the
963 * connection should be shut down.
964 */
965 static protocol_binary_response_status execute_command(memcached_protocol_client_st *client, protocol_binary_request_header *header)
966 {
967 if (client->root->pedantic &&
968 memcached_binary_protocol_pedantic_check_request(header))
969 {
970 /* @todo return invalid command packet */
971 }
972
973 /* we got all data available, execute the callback! */
974 if (client->root->callback->pre_execute != NULL)
975 {
976 client->root->callback->pre_execute(client, header);
977 }
978
979 protocol_binary_response_status rval;
980 rval= PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND;
981 uint8_t cc= header->request.opcode;
982
983 switch (client->root->callback->interface_version)
984 {
985 case 0:
986 if (client->root->callback->interface.v0.comcode[cc] != NULL) {
987 rval= client->root->callback->interface.v0.comcode[cc](client, header, raw_response_handler);
988 }
989 break;
990 case 1:
991 if (comcode_v0_v1_remap[cc] != NULL) {
992 rval= comcode_v0_v1_remap[cc](client, header, raw_response_handler);
993 }
994 break;
995 default:
996 /* Unknown interface.
997 * It should be impossible to get here so I'll just call abort
998 * to avoid getting a compiler warning :-)
999 */
1000 abort();
1001 }
1002
1003
1004 if (rval == PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND &&
1005 client->root->callback->unknown != NULL)
1006 {
1007 rval= client->root->callback->unknown(client, header, raw_response_handler);
1008 }
1009
1010 if (rval != PROTOCOL_BINARY_RESPONSE_SUCCESS &&
1011 rval != PROTOCOL_BINARY_RESPONSE_EINTERNAL &&
1012 rval != PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED)
1013 {
1014 protocol_binary_response_no_extras response= {
1015 .message= {
1016 .header.response= {
1017 .magic= PROTOCOL_BINARY_RES,
1018 .opcode= cc,
1019 .status= htons(rval),
1020 .opaque= header->request.opaque,
1021 },
1022 }
1023 };
1024 rval= raw_response_handler(client, header, (void*)&response);
1025 }
1026
1027 if (client->root->callback->post_execute != NULL)
1028 {
1029 client->root->callback->post_execute(client, header);
1030 }
1031
1032 return rval;
1033 }
1034
1035 /*
1036 ** **********************************************************************
1037 ** "PROTOECTED" INTERFACE
1038 ** **********************************************************************
1039 */
1040 memcached_protocol_event_t memcached_binary_protocol_process_data(memcached_protocol_client_st *client, ssize_t *length, void **endptr)
1041 {
1042 /* try to parse all of the received packets */
1043 protocol_binary_request_header *header;
1044 header= (void*)client->root->input_buffer;
1045 if (header->request.magic != (uint8_t)PROTOCOL_BINARY_REQ)
1046 {
1047 client->error= EINVAL;
1048 return MEMCACHED_PROTOCOL_ERROR_EVENT;
1049 }
1050 ssize_t len= *length;
1051
1052 while (len >= (ssize_t)sizeof(*header) &&
1053 (len >= (ssize_t)(sizeof(*header) + ntohl(header->request.bodylen))))
1054 {
1055 /* I have the complete package */
1056 client->current_command= header;
1057 protocol_binary_response_status rv= execute_command(client, header);
1058
1059 if (rv == PROTOCOL_BINARY_RESPONSE_EINTERNAL)
1060 {
1061 *length= len;
1062 *endptr= (void*)header;
1063 return MEMCACHED_PROTOCOL_ERROR_EVENT;
1064 } else if (rv == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED)
1065 return MEMCACHED_PROTOCOL_PAUSE_EVENT;
1066
1067 ssize_t total= (ssize_t)(sizeof(*header) + ntohl(header->request.bodylen));
1068 len -= total;
1069 if (len > 0)
1070 {
1071 intptr_t ptr= (intptr_t)header;
1072 ptr += total;
1073 if ((ptr % 8) == 0)
1074 {
1075 header= (void*)ptr;
1076 }
1077 else
1078 {
1079 /* Fix alignment */
1080 memmove(client->root->input_buffer, (void*)ptr, (size_t)len);
1081 header= (void*)client->root->input_buffer;
1082 }
1083 }
1084 *length= len;
1085 *endptr= (void*)header;
1086 }
1087
1088 return MEMCACHED_PROTOCOL_READ_EVENT;
1089 }
1090
1091 /*
1092 ** **********************************************************************
1093 ** PUBLIC INTERFACE
1094 ** **********************************************************************
1095 */
1096 memcached_binary_protocol_callback_st *memcached_binary_protocol_get_callbacks(memcached_protocol_st *instance)
1097 {
1098 return instance->callback;
1099 }
1100
1101 void memcached_binary_protocol_set_callbacks(memcached_protocol_st *instance, memcached_binary_protocol_callback_st *callback)
1102 {
1103 instance->callback= callback;
1104 }
1105
1106 memcached_binary_protocol_raw_response_handler memcached_binary_protocol_get_raw_response_handler(const void *cookie)
1107 {
1108 (void)cookie;
1109 return raw_response_handler;
1110 }
1111
1112 void memcached_binary_protocol_set_pedantic(memcached_protocol_st *instance, bool enable)
1113 {
1114 instance->pedantic= enable;
1115 }
1116
1117 bool memcached_binary_protocol_get_pedantic(memcached_protocol_st *instance)
1118 {
1119 return instance->pedantic;
1120 }
1121
Resurrection of libmemcached