Temp save for Monty.
[awesomized/libmemcached] / example / interface_v0.c
1 /* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2 /**
3 * This file contains an implementation of the callback interface for level 0
4 * in the protocol library. You might want to have your copy of the protocol
5 * specification next to your coffee ;-)
6 */
7 #include "config.h"
8 #include <assert.h>
9 #include <sys/types.h>
10 #include <sys/socket.h>
11 #include <netdb.h>
12 #include <netinet/tcp.h>
13 #include <stdio.h>
14 #include <unistd.h>
15 #include <fcntl.h>
16 #include <errno.h>
17 #include <stdlib.h>
18 #include <string.h>
19
20 #include <libmemcached/protocol_handler.h>
21 #include <libmemcached/byteorder.h>
22 #include "storage.h"
23 #include "memcached_light.h"
24
25 static protocol_binary_response_status noop_command_handler(const void *cookie,
26 protocol_binary_request_header *header,
27 memcached_binary_protocol_raw_response_handler response_handler)
28 {
29 protocol_binary_response_no_extras response= {
30 .message.header.response= {
31 .magic= PROTOCOL_BINARY_RES,
32 .opcode= PROTOCOL_BINARY_CMD_NOOP,
33 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
34 .opaque= header->request.opaque
35 }
36 };
37
38 return response_handler(cookie, header, (void*)&response);
39 }
40
41 static protocol_binary_response_status quit_command_handler(const void *cookie,
42 protocol_binary_request_header *header,
43 memcached_binary_protocol_raw_response_handler response_handler)
44 {
45 protocol_binary_response_no_extras response= {
46 .message.header.response= {
47 .magic= PROTOCOL_BINARY_RES,
48 .opcode= PROTOCOL_BINARY_CMD_QUIT,
49 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
50 .opaque= header->request.opaque
51 }
52 };
53
54 if (header->request.opcode == PROTOCOL_BINARY_CMD_QUIT)
55 response_handler(cookie, header, (void*)&response);
56
57 /* I need a better way to signal to close the connection */
58 return PROTOCOL_BINARY_RESPONSE_EIO;
59 }
60
61 static protocol_binary_response_status get_command_handler(const void *cookie,
62 protocol_binary_request_header *header,
63 memcached_binary_protocol_raw_response_handler response_handler)
64 {
65 uint8_t opcode= header->request.opcode;
66 union {
67 protocol_binary_response_get response;
68 char buffer[4096];
69 } msg= {
70 .response.message.header.response= {
71 .magic= PROTOCOL_BINARY_RES,
72 .opcode= opcode,
73 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
74 .opaque= header->request.opaque
75 }
76 };
77
78 struct item *item= get_item(header + 1, ntohs(header->request.keylen));
79 if (item)
80 {
81 msg.response.message.body.flags= htonl(item->flags);
82 char *ptr= (char*)(msg.response.bytes + sizeof(*header) + 4);
83 uint32_t bodysize= 4;
84 msg.response.message.header.response.cas= htonll(item->cas);
85 if (opcode == PROTOCOL_BINARY_CMD_GETK || opcode == PROTOCOL_BINARY_CMD_GETKQ)
86 {
87 memcpy(ptr, item->key, item->nkey);
88 msg.response.message.header.response.keylen= htons((uint16_t)item->nkey);
89 ptr += item->nkey;
90 bodysize += (uint32_t)item->nkey;
91 }
92 memcpy(ptr, item->data, item->size);
93 bodysize += (uint32_t)item->size;
94 msg.response.message.header.response.bodylen= htonl(bodysize);
95 msg.response.message.header.response.extlen= 4;
96
97 release_item(item);
98 return response_handler(cookie, header, (void*)&msg);
99 }
100 else if (opcode == PROTOCOL_BINARY_CMD_GET || opcode == PROTOCOL_BINARY_CMD_GETK)
101 {
102 msg.response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
103 return response_handler(cookie, header, (void*)&msg);
104 }
105
106 /* Q shouldn't report a miss ;-) */
107 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
108 }
109
110 static protocol_binary_response_status delete_command_handler(const void *cookie,
111 protocol_binary_request_header *header,
112 memcached_binary_protocol_raw_response_handler response_handler)
113 {
114 size_t keylen= ntohs(header->request.keylen);
115 char *key= ((char*)header) + sizeof(*header);
116 protocol_binary_response_no_extras response= {
117 .message.header.response= {
118 .magic= PROTOCOL_BINARY_RES,
119 .opcode= header->request.opcode,
120 .opaque= header->request.opaque
121 }
122 };
123
124 if (!delete_item(key, keylen))
125 {
126 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
127 return response_handler(cookie, header, (void*)&response);
128 }
129 else if (header->request.opcode == PROTOCOL_BINARY_CMD_DELETE)
130 {
131 /* DELETEQ doesn't want success response */
132 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS);
133 return response_handler(cookie, header, (void*)&response);
134 }
135
136 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
137 }
138
139 static protocol_binary_response_status flush_command_handler(const void *cookie,
140 protocol_binary_request_header *header,
141 memcached_binary_protocol_raw_response_handler response_handler)
142 {
143 uint8_t opcode= header->request.opcode;
144
145 /* @fixme sett inn when! */
146 flush(0);
147
148 if (opcode == PROTOCOL_BINARY_CMD_FLUSH)
149 {
150 protocol_binary_response_no_extras response= {
151 .message.header.response= {
152 .magic= PROTOCOL_BINARY_RES,
153 .opcode= opcode,
154 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
155 .opaque= header->request.opaque
156 }
157 };
158 return response_handler(cookie, header, (void*)&response);
159 }
160
161 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
162 }
163
164 static protocol_binary_response_status arithmetic_command_handler(const void *cookie,
165 protocol_binary_request_header *header,
166 memcached_binary_protocol_raw_response_handler response_handler)
167 {
168 protocol_binary_request_incr *req= (void*)header;
169 protocol_binary_response_incr response= {
170 .message.header.response= {
171 .magic= PROTOCOL_BINARY_RES,
172 .opcode= header->request.opcode,
173 .opaque= header->request.opaque,
174 },
175 };
176
177 uint16_t keylen= ntohs(header->request.keylen);
178 uint64_t initial= ntohll(req->message.body.initial);
179 uint64_t delta= ntohll(req->message.body.delta);
180 uint32_t expiration= ntohl(req->message.body.expiration);
181 uint32_t flags= 0;
182 void *key= req->bytes + sizeof(req->bytes);
183 protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
184
185 uint64_t value= initial;
186
187 struct item *item= get_item(key, keylen);
188 if (item != NULL)
189 {
190 if (header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENT ||
191 header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENTQ)
192 {
193 value= (*(uint64_t*)item->data) + delta;
194 }
195 else
196 {
197 if (delta > *(uint64_t*)item->data)
198 {
199 value= 0;
200 }
201 else
202 {
203 value= *(uint64_t*)item->data - delta;
204 }
205 }
206 expiration= (uint32_t)item->exp;
207 flags= item->flags;
208
209 release_item(item);
210 delete_item(key, keylen);
211 }
212
213 item= create_item(key, keylen, NULL, sizeof(value), flags, (time_t)expiration);
214 if (item == NULL)
215 {
216 rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
217 }
218 else
219 {
220 memcpy(item->data, &value, sizeof(value));
221 put_item(item);
222 }
223
224 response.message.header.response.status= htons(rval);
225 if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
226 {
227 response.message.header.response.bodylen= ntohl(8);
228 response.message.body.value= ntohll((*(uint64_t*)item->data));
229 response.message.header.response.cas= ntohll(item->cas);
230
231 release_item(item);
232 if (header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENTQ ||
233 header->request.opcode == PROTOCOL_BINARY_CMD_DECREMENTQ)
234 {
235 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
236 }
237 }
238
239 return response_handler(cookie, header, (void*)&response);
240 }
241
242 static protocol_binary_response_status version_command_handler(const void *cookie,
243 protocol_binary_request_header *header,
244 memcached_binary_protocol_raw_response_handler response_handler)
245 {
246 const char *versionstring= "1.0.0";
247 union {
248 protocol_binary_response_header packet;
249 char buffer[256];
250 } response= {
251 .packet.response= {
252 .magic= PROTOCOL_BINARY_RES,
253 .opcode= PROTOCOL_BINARY_CMD_VERSION,
254 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
255 .opaque= header->request.opaque,
256 .bodylen= htonl((uint32_t)strlen(versionstring))
257 }
258 };
259
260 memcpy(response.buffer + sizeof(response.packet), versionstring, strlen(versionstring));
261
262 return response_handler(cookie, header, (void*)&response);
263 }
264
265 static protocol_binary_response_status concat_command_handler(const void *cookie,
266 protocol_binary_request_header *header,
267 memcached_binary_protocol_raw_response_handler response_handler)
268 {
269 protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
270 uint16_t keylen= ntohs(header->request.keylen);
271 uint64_t cas= ntohll(header->request.cas);
272 void *key= header + 1;
273 uint32_t vallen= ntohl(header->request.bodylen) - keylen;
274 void *val= (char*)key + keylen;
275
276 struct item *item= get_item(key, keylen);
277 struct item *nitem= NULL;
278
279 if (item == NULL)
280 {
281 rval= PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
282 }
283 else if (cas != 0 && cas != item->cas)
284 {
285 rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
286 }
287 else if ((nitem= create_item(key, keylen, NULL, item->size + vallen,
288 item->flags, item->exp)) == NULL)
289 {
290 release_item(item);
291 rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
292 }
293 else
294 {
295 if (header->request.opcode == PROTOCOL_BINARY_CMD_APPEND ||
296 header->request.opcode == PROTOCOL_BINARY_CMD_APPENDQ)
297 {
298 memcpy(nitem->data, item->data, item->size);
299 memcpy(((char*)(nitem->data)) + item->size, val, vallen);
300 }
301 else
302 {
303 memcpy(nitem->data, val, vallen);
304 memcpy(((char*)(nitem->data)) + vallen, item->data, item->size);
305 }
306 release_item(item);
307 delete_item(key, keylen);
308 put_item(nitem);
309 cas= nitem->cas;
310 release_item(nitem);
311
312 if (header->request.opcode == PROTOCOL_BINARY_CMD_APPEND ||
313 header->request.opcode == PROTOCOL_BINARY_CMD_PREPEND)
314 {
315 protocol_binary_response_no_extras response= {
316 .message= {
317 .header.response= {
318 .magic= PROTOCOL_BINARY_RES,
319 .opcode= header->request.opcode,
320 .status= htons(rval),
321 .opaque= header->request.opaque,
322 .cas= htonll(cas),
323 }
324 }
325 };
326 return response_handler(cookie, header, (void*)&response);
327 }
328 }
329
330 return rval;
331 }
332
333 static protocol_binary_response_status set_command_handler(const void *cookie,
334 protocol_binary_request_header *header,
335 memcached_binary_protocol_raw_response_handler response_handler)
336 {
337 size_t keylen= ntohs(header->request.keylen);
338 size_t datalen= ntohl(header->request.bodylen) - keylen - 8;
339 protocol_binary_request_replace *request= (void*)header;
340 uint32_t flags= ntohl(request->message.body.flags);
341 time_t timeout= (time_t)ntohl(request->message.body.expiration);
342 char *key= ((char*)header) + sizeof(*header) + 8;
343 char *data= key + keylen;
344
345 protocol_binary_response_no_extras response= {
346 .message= {
347 .header.response= {
348 .magic= PROTOCOL_BINARY_RES,
349 .opcode= header->request.opcode,
350 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
351 .opaque= header->request.opaque
352 }
353 }
354 };
355
356 if (header->request.cas != 0)
357 {
358 /* validate cas */
359 struct item* item= get_item(key, keylen);
360 if (item != NULL)
361 {
362 if (item->cas != ntohll(header->request.cas))
363 {
364 release_item(item);
365 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
366 return response_handler(cookie, header, (void*)&response);
367 }
368 release_item(item);
369 }
370 }
371
372 delete_item(key, keylen);
373 struct item* item= create_item(key, keylen, data, datalen, flags, timeout);
374 if (item == NULL)
375 {
376 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
377 }
378 else
379 {
380 put_item(item);
381 /* SETQ shouldn't return a message */
382 if (header->request.opcode == PROTOCOL_BINARY_CMD_SET)
383 {
384 response.message.header.response.cas= htonll(item->cas);
385 release_item(item);
386 return response_handler(cookie, header, (void*)&response);
387 }
388 release_item(item);
389
390 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
391 }
392
393 return response_handler(cookie, header, (void*)&response);
394 }
395
396 static protocol_binary_response_status add_command_handler(const void *cookie,
397 protocol_binary_request_header *header,
398 memcached_binary_protocol_raw_response_handler response_handler)
399 {
400 size_t keylen= ntohs(header->request.keylen);
401 size_t datalen= ntohl(header->request.bodylen) - keylen - 8;
402 protocol_binary_request_add *request= (void*)header;
403 uint32_t flags= ntohl(request->message.body.flags);
404 time_t timeout= (time_t)ntohl(request->message.body.expiration);
405 char *key= ((char*)header) + sizeof(*header) + 8;
406 char *data= key + keylen;
407
408 protocol_binary_response_no_extras response= {
409 .message= {
410 .header.response= {
411 .magic= PROTOCOL_BINARY_RES,
412 .opcode= header->request.opcode,
413 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
414 .opaque= header->request.opaque
415 }
416 }
417 };
418
419 struct item* item= get_item(key, keylen);
420 if (item == NULL)
421 {
422 item= create_item(key, keylen, data, datalen, flags, timeout);
423 if (item == NULL)
424 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
425 else
426 {
427 put_item(item);
428 /* ADDQ shouldn't return a message */
429 if (header->request.opcode == PROTOCOL_BINARY_CMD_ADD)
430 {
431 response.message.header.response.cas= htonll(item->cas);
432 release_item(item);
433 return response_handler(cookie, header, (void*)&response);
434 }
435 release_item(item);
436 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
437 }
438 }
439 else
440 {
441 release_item(item);
442 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
443 }
444
445 return response_handler(cookie, header, (void*)&response);
446 }
447
448 static protocol_binary_response_status replace_command_handler(const void *cookie,
449 protocol_binary_request_header *header,
450 memcached_binary_protocol_raw_response_handler response_handler)
451 {
452 size_t keylen= ntohs(header->request.keylen);
453 size_t datalen= ntohl(header->request.bodylen) - keylen - 8;
454 protocol_binary_request_replace *request= (void*)header;
455 uint32_t flags= ntohl(request->message.body.flags);
456 time_t timeout= (time_t)ntohl(request->message.body.expiration);
457 char *key= ((char*)header) + sizeof(*header) + 8;
458 char *data= key + keylen;
459
460 protocol_binary_response_no_extras response= {
461 .message= {
462 .header.response= {
463 .magic= PROTOCOL_BINARY_RES,
464 .opcode= header->request.opcode,
465 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
466 .opaque= header->request.opaque
467 }
468 }
469 };
470
471 struct item* item= get_item(key, keylen);
472 if (item == NULL)
473 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
474 else if (header->request.cas == 0 || ntohll(header->request.cas) == item->cas)
475 {
476 release_item(item);
477 delete_item(key, keylen);
478 item= create_item(key, keylen, data, datalen, flags, timeout);
479 if (item == NULL)
480 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
481 else
482 {
483 put_item(item);
484 /* REPLACEQ shouldn't return a message */
485 if (header->request.opcode == PROTOCOL_BINARY_CMD_REPLACE)
486 {
487 response.message.header.response.cas= htonll(item->cas);
488 release_item(item);
489 return response_handler(cookie, header, (void*)&response);
490 }
491 release_item(item);
492 return PROTOCOL_BINARY_RESPONSE_SUCCESS;
493 }
494 }
495 else
496 {
497 response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
498 release_item(item);
499 }
500
501 return response_handler(cookie, header, (void*)&response);
502 }
503
504 static protocol_binary_response_status stat_command_handler(const void *cookie,
505 protocol_binary_request_header *header,
506 memcached_binary_protocol_raw_response_handler response_handler)
507 {
508 /* Just send the terminating packet*/
509 protocol_binary_response_no_extras response= {
510 .message= {
511 .header.response= {
512 .magic= PROTOCOL_BINARY_RES,
513 .opcode= PROTOCOL_BINARY_CMD_STAT,
514 .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
515 .opaque= header->request.opaque
516 }
517 }
518 };
519
520 return response_handler(cookie, header, (void*)&response);
521 }
522
523 memcached_binary_protocol_callback_st interface_v0_impl= {
524 .interface_version= MEMCACHED_PROTOCOL_HANDLER_V0,
525 #ifdef FUTURE
526 /*
527 ** There is a number of bugs in the extra options for gcc causing
528 ** warning on these struct initializers. It hurts my heart to remove
529 ** it so I'll just leave it in here so that we can enable it when
530 ** we can drop support for the broken compilers
531 */
532 .interface.v0.comcode[PROTOCOL_BINARY_CMD_GET]= get_command_handler,
533 .interface.v0.comcode[PROTOCOL_BINARY_CMD_SET]= set_command_handler,
534 .interface.v0.comcode[PROTOCOL_BINARY_CMD_ADD]= add_command_handler,
535 .interface.v0.comcode[PROTOCOL_BINARY_CMD_REPLACE]= replace_command_handler,
536 .interface.v0.comcode[PROTOCOL_BINARY_CMD_DELETE]= delete_command_handler,
537 .interface.v0.comcode[PROTOCOL_BINARY_CMD_INCREMENT]= arithmetic_command_handler,
538 .interface.v0.comcode[PROTOCOL_BINARY_CMD_DECREMENT]= arithmetic_command_handler,
539 .interface.v0.comcode[PROTOCOL_BINARY_CMD_QUIT]= quit_command_handler,
540 .interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSH]= flush_command_handler,
541 .interface.v0.comcode[PROTOCOL_BINARY_CMD_GETQ]= get_command_handler,
542 .interface.v0.comcode[PROTOCOL_BINARY_CMD_NOOP]= noop_command_handler,
543 .interface.v0.comcode[PROTOCOL_BINARY_CMD_VERSION]= version_command_handler,
544 .interface.v0.comcode[PROTOCOL_BINARY_CMD_GETK]= get_command_handler,
545 .interface.v0.comcode[PROTOCOL_BINARY_CMD_GETKQ]= get_command_handler,
546 .interface.v0.comcode[PROTOCOL_BINARY_CMD_APPEND]= concat_command_handler,
547 .interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPEND]= concat_command_handler,
548 .interface.v0.comcode[PROTOCOL_BINARY_CMD_STAT]= stat_command_handler,
549 .interface.v0.comcode[PROTOCOL_BINARY_CMD_SETQ]= set_command_handler,
550 .interface.v0.comcode[PROTOCOL_BINARY_CMD_ADDQ]= add_command_handler,
551 .interface.v0.comcode[PROTOCOL_BINARY_CMD_REPLACEQ]= replace_command_handler,
552 .interface.v0.comcode[PROTOCOL_BINARY_CMD_DELETEQ]= delete_command_handler,
553 .interface.v0.comcode[PROTOCOL_BINARY_CMD_INCREMENTQ]= arithmetic_command_handler,
554 .interface.v0.comcode[PROTOCOL_BINARY_CMD_DECREMENTQ]= arithmetic_command_handler,
555 .interface.v0.comcode[PROTOCOL_BINARY_CMD_QUITQ]= quit_command_handler,
556 .interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSHQ]= flush_command_handler,
557 .interface.v0.comcode[PROTOCOL_BINARY_CMD_APPENDQ]= concat_command_handler,
558 .interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPENDQ]= concat_command_handler,
559 #endif
560 };
561
562 void initialize_interface_v0_handler(void)
563 {
564 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GET]= get_command_handler;
565 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_SET]= set_command_handler;
566 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_ADD]= add_command_handler;
567 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_REPLACE]= replace_command_handler;
568 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DELETE]= delete_command_handler;
569 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_INCREMENT]= arithmetic_command_handler;
570 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DECREMENT]= arithmetic_command_handler;
571 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_QUIT]= quit_command_handler;
572 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSH]= flush_command_handler;
573 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GETQ]= get_command_handler;
574 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_NOOP]= noop_command_handler;
575 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_VERSION]= version_command_handler;
576 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GETK]= get_command_handler;
577 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GETKQ]= get_command_handler;
578 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_APPEND]= concat_command_handler;
579 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPEND]= concat_command_handler;
580 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_STAT]= stat_command_handler;
581 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_SETQ]= set_command_handler;
582 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_ADDQ]= add_command_handler;
583 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_REPLACEQ]= replace_command_handler;
584 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DELETEQ]= delete_command_handler;
585 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_INCREMENTQ]= arithmetic_command_handler;
586 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DECREMENTQ]= arithmetic_command_handler;
587 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_QUITQ]= quit_command_handler;
588 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSHQ]= flush_command_handler;
589 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_APPENDQ]= concat_command_handler;
590 interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPENDQ]= concat_command_handler;
591 }