Updating for 1.0.2 release
[awesomized/libmemcached] / libmemcachedprotocol-0.0 / binary.h
1 /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /*
3 * Copyright (c) <2008>, Sun Microsystems, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the nor the
14 * names of its contributors may be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY SUN MICROSYSTEMS, INC. ``AS IS'' AND ANY
18 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 * DISCLAIMED. IN NO EVENT SHALL SUN MICROSYSTEMS, INC. BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28 /*
29 * Summary: Constants used by to implement the binary protocol.
30 *
31 * Copy: See Copyright for the status of this software.
32 *
33 * Author: Trond Norbye <trond.norbye@sun.com>
34 */
35
36 #ifndef PROTOCOL_BINARY_H
37 #define PROTOCOL_BINARY_H
38
39 #include <libmemcachedprotocol-0.0/vbucket.h>
40
41 /**
42 * \addtogroup Protocol
43 * @{
44 */
45
46 /**
47 * This file contains definitions of the constants and packet formats
48 * defined in the binary specification. Please note that you _MUST_ remember
49 * to convert each multibyte field to / from network byte order to / from
50 * host order.
51 */
52 #ifdef __cplusplus
53 extern "C"
54 {
55 #endif
56
57 /**
58 * Definition of the legal "magic" values used in a packet.
59 * See section 3.1 Magic byte
60 */
61 typedef enum {
62 PROTOCOL_BINARY_REQ = 0x80,
63 PROTOCOL_BINARY_RES = 0x81
64 } protocol_binary_magic;
65
66 /**
67 * Definition of the valid response status numbers.
68 * See section 3.2 Response Status
69 */
70 typedef enum {
71 PROTOCOL_BINARY_RESPONSE_SUCCESS = 0x00,
72 PROTOCOL_BINARY_RESPONSE_KEY_ENOENT = 0x01,
73 PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS = 0x02,
74 PROTOCOL_BINARY_RESPONSE_E2BIG = 0x03,
75 PROTOCOL_BINARY_RESPONSE_EINVAL = 0x04,
76 PROTOCOL_BINARY_RESPONSE_NOT_STORED = 0x05,
77 PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL = 0x06,
78 PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET = 0x07,
79 PROTOCOL_BINARY_RESPONSE_AUTH_ERROR = 0x20,
80 PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE = 0x21,
81 PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND = 0x81,
82 PROTOCOL_BINARY_RESPONSE_ENOMEM = 0x82,
83 PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED = 0x83,
84 PROTOCOL_BINARY_RESPONSE_EINTERNAL = 0x84,
85 PROTOCOL_BINARY_RESPONSE_EBUSY = 0x85,
86 PROTOCOL_BINARY_RESPONSE_ETMPFAIL = 0x86
87 } protocol_binary_response_status;
88
89 /**
90 * Defintion of the different command opcodes.
91 * See section 3.3 Command Opcodes
92 */
93 typedef enum {
94 PROTOCOL_BINARY_CMD_GET = 0x00,
95 PROTOCOL_BINARY_CMD_SET = 0x01,
96 PROTOCOL_BINARY_CMD_ADD = 0x02,
97 PROTOCOL_BINARY_CMD_REPLACE = 0x03,
98 PROTOCOL_BINARY_CMD_DELETE = 0x04,
99 PROTOCOL_BINARY_CMD_INCREMENT = 0x05,
100 PROTOCOL_BINARY_CMD_DECREMENT = 0x06,
101 PROTOCOL_BINARY_CMD_QUIT = 0x07,
102 PROTOCOL_BINARY_CMD_FLUSH = 0x08,
103 PROTOCOL_BINARY_CMD_GETQ = 0x09,
104 PROTOCOL_BINARY_CMD_NOOP = 0x0a,
105 PROTOCOL_BINARY_CMD_VERSION = 0x0b,
106 PROTOCOL_BINARY_CMD_GETK = 0x0c,
107 PROTOCOL_BINARY_CMD_GETKQ = 0x0d,
108 PROTOCOL_BINARY_CMD_APPEND = 0x0e,
109 PROTOCOL_BINARY_CMD_PREPEND = 0x0f,
110 PROTOCOL_BINARY_CMD_STAT = 0x10,
111 PROTOCOL_BINARY_CMD_SETQ = 0x11,
112 PROTOCOL_BINARY_CMD_ADDQ = 0x12,
113 PROTOCOL_BINARY_CMD_REPLACEQ = 0x13,
114 PROTOCOL_BINARY_CMD_DELETEQ = 0x14,
115 PROTOCOL_BINARY_CMD_INCREMENTQ = 0x15,
116 PROTOCOL_BINARY_CMD_DECREMENTQ = 0x16,
117 PROTOCOL_BINARY_CMD_QUITQ = 0x17,
118 PROTOCOL_BINARY_CMD_FLUSHQ = 0x18,
119 PROTOCOL_BINARY_CMD_APPENDQ = 0x19,
120 PROTOCOL_BINARY_CMD_PREPENDQ = 0x1a,
121 PROTOCOL_BINARY_CMD_VERBOSITY = 0x1b,
122 PROTOCOL_BINARY_CMD_TOUCH = 0x1c,
123 PROTOCOL_BINARY_CMD_GAT = 0x1d,
124 PROTOCOL_BINARY_CMD_GATQ = 0x1e,
125
126 PROTOCOL_BINARY_CMD_SASL_LIST_MECHS = 0x20,
127 PROTOCOL_BINARY_CMD_SASL_AUTH = 0x21,
128 PROTOCOL_BINARY_CMD_SASL_STEP = 0x22,
129
130 /* These commands are used for range operations and exist within
131 * this header for use in other projects. Range operations are
132 * not expected to be implemented in the memcached server itself.
133 */
134 PROTOCOL_BINARY_CMD_RGET = 0x30,
135 PROTOCOL_BINARY_CMD_RSET = 0x31,
136 PROTOCOL_BINARY_CMD_RSETQ = 0x32,
137 PROTOCOL_BINARY_CMD_RAPPEND = 0x33,
138 PROTOCOL_BINARY_CMD_RAPPENDQ = 0x34,
139 PROTOCOL_BINARY_CMD_RPREPEND = 0x35,
140 PROTOCOL_BINARY_CMD_RPREPENDQ = 0x36,
141 PROTOCOL_BINARY_CMD_RDELETE = 0x37,
142 PROTOCOL_BINARY_CMD_RDELETEQ = 0x38,
143 PROTOCOL_BINARY_CMD_RINCR = 0x39,
144 PROTOCOL_BINARY_CMD_RINCRQ = 0x3a,
145 PROTOCOL_BINARY_CMD_RDECR = 0x3b,
146 PROTOCOL_BINARY_CMD_RDECRQ = 0x3c,
147 /* End Range operations */
148
149 /* VBucket commands */
150 PROTOCOL_BINARY_CMD_SET_VBUCKET = 0x3d,
151 PROTOCOL_BINARY_CMD_GET_VBUCKET = 0x3e,
152 PROTOCOL_BINARY_CMD_DEL_VBUCKET = 0x3f,
153 /* End VBucket commands */
154
155 /* TAP commands */
156 PROTOCOL_BINARY_CMD_TAP_CONNECT = 0x40,
157 PROTOCOL_BINARY_CMD_TAP_MUTATION = 0x41,
158 PROTOCOL_BINARY_CMD_TAP_DELETE = 0x42,
159 PROTOCOL_BINARY_CMD_TAP_FLUSH = 0x43,
160 PROTOCOL_BINARY_CMD_TAP_OPAQUE = 0x44,
161 PROTOCOL_BINARY_CMD_TAP_VBUCKET_SET = 0x45,
162 PROTOCOL_BINARY_CMD_TAP_CHECKPOINT_START = 0x46,
163 PROTOCOL_BINARY_CMD_TAP_CHECKPOINT_END = 0x47,
164 /* End TAP */
165
166 PROTOCOL_BINARY_CMD_LAST_RESERVED = 0xef,
167
168 /* Scrub the data */
169 PROTOCOL_BINARY_CMD_SCRUB = 0xf0
170 } protocol_binary_command;
171
172 /**
173 * Definition of the data types in the packet
174 * See section 3.4 Data Types
175 */
176 typedef enum {
177 PROTOCOL_BINARY_RAW_BYTES = 0x00
178 } protocol_binary_datatypes;
179
180 /**
181 * Definition of the header structure for a request packet.
182 * See section 2
183 */
184 typedef union {
185 struct {
186 uint8_t magic;
187 uint8_t opcode;
188 uint16_t keylen;
189 uint8_t extlen;
190 uint8_t datatype;
191 uint16_t vbucket;
192 uint32_t bodylen;
193 uint32_t opaque;
194 uint64_t cas;
195 } request;
196 uint8_t bytes[24];
197 } protocol_binary_request_header;
198
199 /**
200 * Definition of the header structure for a response packet.
201 * See section 2
202 */
203 typedef union {
204 struct {
205 uint8_t magic;
206 uint8_t opcode;
207 uint16_t keylen;
208 uint8_t extlen;
209 uint8_t datatype;
210 uint16_t status;
211 uint32_t bodylen;
212 uint32_t opaque;
213 uint64_t cas;
214 } response;
215 uint8_t bytes[24];
216 } protocol_binary_response_header;
217
218 /**
219 * Definition of a request-packet containing no extras
220 */
221 union protocol_binary_request_no_extras {
222 struct {
223 protocol_binary_request_header header;
224 } message;
225 uint8_t bytes[sizeof(protocol_binary_request_header)];
226 };
227 typedef union protocol_binary_request_no_extras protocol_binary_request_no_extras;
228
229 /**
230 * Definition of a response-packet containing no extras
231 */
232 typedef union {
233 struct {
234 protocol_binary_response_header header;
235 } message;
236 uint8_t bytes[sizeof(protocol_binary_response_header)];
237 } protocol_binary_response_no_extras;
238
239 /**
240 * Definition of the packet used by the get, getq, getk and getkq command.
241 * See section 4
242 */
243 typedef protocol_binary_request_no_extras protocol_binary_request_get;
244 typedef protocol_binary_request_no_extras protocol_binary_request_getq;
245 typedef protocol_binary_request_no_extras protocol_binary_request_getk;
246 typedef protocol_binary_request_no_extras protocol_binary_request_getkq;
247
248 /**
249 * Definition of the packet returned from a successful get, getq, getk and
250 * getkq.
251 * See section 4
252 */
253 typedef union {
254 struct {
255 protocol_binary_response_header header;
256 struct {
257 uint32_t flags;
258 } body;
259 } message;
260 uint8_t bytes[sizeof(protocol_binary_response_header) + 4];
261 } protocol_binary_response_get;
262
263 typedef protocol_binary_response_get protocol_binary_response_getq;
264 typedef protocol_binary_response_get protocol_binary_response_getk;
265 typedef protocol_binary_response_get protocol_binary_response_getkq;
266
267 /**
268 * Definition of the packet used by the delete command
269 * See section 4
270 */
271 typedef protocol_binary_request_no_extras protocol_binary_request_delete;
272
273 /**
274 * Definition of the packet returned by the delete command
275 * See section 4
276 */
277 typedef protocol_binary_response_no_extras protocol_binary_response_delete;
278
279 /**
280 * Definition of the packet used by the flush command
281 * See section 4
282 * Please note that the expiration field is optional, so remember to see
283 * check the header.bodysize to see if it is present.
284 */
285 typedef union {
286 struct {
287 protocol_binary_request_header header;
288 struct {
289 uint32_t expiration;
290 } body;
291 } message;
292 uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
293 } protocol_binary_request_flush;
294
295 /**
296 * Definition of the packet returned by the flush command
297 * See section 4
298 */
299 typedef protocol_binary_response_no_extras protocol_binary_response_flush;
300
301 /**
302 * Definition of the packet used by set, add and replace
303 * See section 4
304 */
305 typedef union {
306 struct {
307 protocol_binary_request_header header;
308 struct {
309 uint32_t flags;
310 uint32_t expiration;
311 } body;
312 } message;
313 uint8_t bytes[sizeof(protocol_binary_request_header) + 8];
314 } protocol_binary_request_set;
315 typedef protocol_binary_request_set protocol_binary_request_add;
316 typedef protocol_binary_request_set protocol_binary_request_replace;
317
318 /**
319 * Definition of the packet returned by set, add and replace
320 * See section 4
321 */
322 typedef protocol_binary_response_no_extras protocol_binary_response_set;
323 typedef protocol_binary_response_no_extras protocol_binary_response_add;
324 typedef protocol_binary_response_no_extras protocol_binary_response_replace;
325
326 /**
327 * Definition of the noop packet
328 * See section 4
329 */
330 typedef protocol_binary_request_no_extras protocol_binary_request_noop;
331
332 /**
333 * Definition of the packet returned by the noop command
334 * See section 4
335 */
336 typedef protocol_binary_response_no_extras protocol_binary_response_noop;
337
338 /**
339 * Definition of the structure used by the increment and decrement
340 * command.
341 * See section 4
342 */
343 typedef union {
344 struct {
345 protocol_binary_request_header header;
346 struct {
347 uint64_t delta;
348 uint64_t initial;
349 uint32_t expiration;
350 } body;
351 } message;
352 uint8_t bytes[sizeof(protocol_binary_request_header) + 20];
353 } protocol_binary_request_incr;
354 typedef protocol_binary_request_incr protocol_binary_request_decr;
355
356 /**
357 * Definition of the response from an incr or decr command
358 * command.
359 * See section 4
360 */
361 typedef union {
362 struct {
363 protocol_binary_response_header header;
364 struct {
365 uint64_t value;
366 } body;
367 } message;
368 uint8_t bytes[sizeof(protocol_binary_response_header) + 8];
369 } protocol_binary_response_incr;
370 typedef protocol_binary_response_incr protocol_binary_response_decr;
371
372 /**
373 * Definition of the quit
374 * See section 4
375 */
376 typedef protocol_binary_request_no_extras protocol_binary_request_quit;
377
378 /**
379 * Definition of the packet returned by the quit command
380 * See section 4
381 */
382 typedef protocol_binary_response_no_extras protocol_binary_response_quit;
383
384 /**
385 * Definition of the packet used by append and prepend command
386 * See section 4
387 */
388 typedef protocol_binary_request_no_extras protocol_binary_request_append;
389 typedef protocol_binary_request_no_extras protocol_binary_request_prepend;
390
391 /**
392 * Definition of the packet returned from a successful append or prepend
393 * See section 4
394 */
395 typedef protocol_binary_response_no_extras protocol_binary_response_append;
396 typedef protocol_binary_response_no_extras protocol_binary_response_prepend;
397
398 /**
399 * Definition of the packet used by the version command
400 * See section 4
401 */
402 typedef protocol_binary_request_no_extras protocol_binary_request_version;
403
404 /**
405 * Definition of the packet returned from a successful version command
406 * See section 4
407 */
408 typedef protocol_binary_response_no_extras protocol_binary_response_version;
409
410
411 /**
412 * Definition of the packet used by the stats command.
413 * See section 4
414 */
415 typedef protocol_binary_request_no_extras protocol_binary_request_stats;
416
417 /**
418 * Definition of the packet returned from a successful stats command
419 * See section 4
420 */
421 typedef protocol_binary_response_no_extras protocol_binary_response_stats;
422
423 /**
424 * Definition of the packet used by the verbosity command
425 */
426 typedef union {
427 struct {
428 protocol_binary_request_header header;
429 struct {
430 uint32_t level;
431 } body;
432 } message;
433 uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
434 } protocol_binary_request_verbosity;
435
436 /**
437 * Definition of the packet returned from the verbosity command
438 */
439 typedef protocol_binary_response_no_extras protocol_binary_response_verbosity;
440
441 /**
442 * Definition of the packet used by the touch command.
443 */
444 typedef union {
445 struct {
446 protocol_binary_request_header header;
447 struct {
448 uint32_t expiration;
449 } body;
450 } message;
451 uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
452 } protocol_binary_request_touch;
453
454 /**
455 * Definition of the packet returned from the touch command
456 */
457 typedef protocol_binary_response_no_extras protocol_binary_response_touch;
458
459 /**
460 * Definition of the packet used by the GAT(Q) command.
461 */
462 typedef union {
463 struct {
464 protocol_binary_request_header header;
465 struct {
466 uint32_t expiration;
467 } body;
468 } message;
469 uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
470 } protocol_binary_request_gat;
471
472 typedef protocol_binary_request_gat protocol_binary_request_gatq;
473
474 /**
475 * Definition of the packet returned from the GAT(Q)
476 */
477 typedef protocol_binary_response_get protocol_binary_response_gat;
478 typedef protocol_binary_response_get protocol_binary_response_gatq;
479
480
481 /**
482 * Definition of a request for a range operation.
483 * See http://code.google.com/p/memcached/wiki/RangeOps
484 *
485 * These types are used for range operations and exist within
486 * this header for use in other projects. Range operations are
487 * not expected to be implemented in the memcached server itself.
488 */
489 typedef union {
490 struct {
491 protocol_binary_response_header header;
492 struct {
493 uint16_t size;
494 uint8_t reserved;
495 uint8_t flags;
496 uint32_t max_results;
497 } body;
498 } message;
499 uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
500 } protocol_binary_request_rangeop;
501
502 typedef protocol_binary_request_rangeop protocol_binary_request_rget;
503 typedef protocol_binary_request_rangeop protocol_binary_request_rset;
504 typedef protocol_binary_request_rangeop protocol_binary_request_rsetq;
505 typedef protocol_binary_request_rangeop protocol_binary_request_rappend;
506 typedef protocol_binary_request_rangeop protocol_binary_request_rappendq;
507 typedef protocol_binary_request_rangeop protocol_binary_request_rprepend;
508 typedef protocol_binary_request_rangeop protocol_binary_request_rprependq;
509 typedef protocol_binary_request_rangeop protocol_binary_request_rdelete;
510 typedef protocol_binary_request_rangeop protocol_binary_request_rdeleteq;
511 typedef protocol_binary_request_rangeop protocol_binary_request_rincr;
512 typedef protocol_binary_request_rangeop protocol_binary_request_rincrq;
513 typedef protocol_binary_request_rangeop protocol_binary_request_rdecr;
514 typedef protocol_binary_request_rangeop protocol_binary_request_rdecrq;
515
516
517 /**
518 * Definition of tap commands
519 * See To be written
520 *
521 */
522
523 typedef union {
524 struct {
525 protocol_binary_request_header header;
526 struct {
527 /**
528 * flags is a bitmask used to set properties for the
529 * the connection. Please In order to be forward compatible
530 * you should set all undefined bits to 0.
531 *
532 * If the bit require extra userdata, it will be stored
533 * in the user-data field of the body (passed to the engine
534 * as enginespeciffic). That means that when you parse the
535 * flags and the engine-specific data, you have to work your
536 * way from bit 0 and upwards to find the correct offset for
537 * the data.
538 *
539 */
540 uint32_t flags;
541
542 /**
543 * Backfill age
544 *
545 * By using this flag you can limit the amount of data being
546 * transmitted. If you don't specify a backfill age, the
547 * server will transmit everything it contains.
548 *
549 * The first 8 bytes in the engine specific data contains
550 * the oldest entry (from epoc) you're interested in.
551 * Specifying a time in the future (for the server you are
552 * connecting to), will cause it to start streaming current
553 * changes.
554 */
555 #define TAP_CONNECT_FLAG_BACKFILL 0x01
556 /**
557 * Dump will cause the server to send the data stored on the
558 * server, but disconnect when the keys stored in the server
559 * are transmitted.
560 */
561 #define TAP_CONNECT_FLAG_DUMP 0x02
562 /**
563 * The body contains a list of 16 bits words in network byte
564 * order specifying the vbucket ids to monitor. The first 16
565 * bit word contains the number of buckets. The number of 0
566 * means "all buckets"
567 */
568 #define TAP_CONNECT_FLAG_LIST_VBUCKETS 0x04
569 /**
570 * The responsibility of the vbuckets is to be transferred
571 * over to the caller when all items are transferred.
572 */
573 #define TAP_CONNECT_FLAG_TAKEOVER_VBUCKETS 0x08
574 /**
575 * The tap consumer supports ack'ing of tap messages
576 */
577 #define TAP_CONNECT_SUPPORT_ACK 0x10
578 /**
579 * The tap consumer would prefer to just get the keys
580 * back. If the engine supports this it will set
581 * the TAP_FLAG_NO_VALUE flag in each of the
582 * tap packets returned.
583 */
584 #define TAP_CONNECT_REQUEST_KEYS_ONLY 0x20
585 /**
586 * The body contains a list of (vbucket_id, last_checkpoint_id)
587 * pairs. This provides the checkpoint support in TAP streams.
588 * The last checkpoint id represents the last checkpoint that
589 * was successfully persisted.
590 */
591 #define TAP_CONNECT_CHECKPOINT 0x40
592 /**
593 * The tap consumer is a registered tap client, which means that
594 * the tap server will maintain its checkpoint cursor permanently.
595 */
596 #define TAP_CONNECT_REGISTERED_CLIENT 0x80
597 } body;
598 } message;
599 uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
600 } protocol_binary_request_tap_connect;
601
602 typedef union {
603 struct {
604 protocol_binary_request_header header;
605 struct {
606 struct {
607 uint16_t enginespecific_length;
608 /*
609 * The flag section support the following flags
610 */
611 /**
612 * Request that the consumer send a response packet
613 * for this packet. The opaque field must be preserved
614 * in the response.
615 */
616 #define TAP_FLAG_ACK 0x01
617 /**
618 * The value for the key is not included in the packet
619 */
620 #define TAP_FLAG_NO_VALUE 0x02
621 uint16_t flags;
622 uint8_t ttl;
623 uint8_t res1;
624 uint8_t res2;
625 uint8_t res3;
626 } tap;
627 struct {
628 uint32_t flags;
629 uint32_t expiration;
630 } item;
631 } body;
632 } message;
633 uint8_t bytes[sizeof(protocol_binary_request_header) + 16];
634 } protocol_binary_request_tap_mutation;
635
636 typedef union {
637 struct {
638 protocol_binary_request_header header;
639 struct {
640 struct {
641 uint16_t enginespecific_length;
642 /**
643 * See the definition of the flags for
644 * protocol_binary_request_tap_mutation for a description
645 * of the available flags.
646 */
647 uint16_t flags;
648 uint8_t ttl;
649 uint8_t res1;
650 uint8_t res2;
651 uint8_t res3;
652 } tap;
653 } body;
654 } message;
655 uint8_t bytes[sizeof(protocol_binary_request_header) + 8];
656 } protocol_binary_request_tap_no_extras;
657
658 typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_delete;
659 typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_flush;
660 typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_opaque;
661 typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_vbucket_set;
662
663
664 /**
665 * Definition of the packet used by the scrub.
666 */
667 typedef protocol_binary_request_no_extras protocol_binary_request_scrub;
668
669 /**
670 * Definition of the packet returned from scrub.
671 */
672 typedef protocol_binary_response_no_extras protocol_binary_response_scrub;
673
674
675 /**
676 * Definition of the packet used by set vbucket
677 */
678 typedef union {
679 struct {
680 protocol_binary_request_header header;
681 struct {
682 vbucket_state_t state;
683 } body;
684 } message;
685 uint8_t bytes[sizeof(protocol_binary_request_header) + sizeof(vbucket_state_t)];
686 } protocol_binary_request_set_vbucket;
687 /**
688 * Definition of the packet returned from set vbucket
689 */
690 typedef protocol_binary_response_no_extras protocol_binary_response_set_vbucket;
691 /**
692 * Definition of the packet used by del vbucket
693 */
694 typedef protocol_binary_request_no_extras protocol_binary_request_del_vbucket;
695 /**
696 * Definition of the packet returned from del vbucket
697 */
698 typedef protocol_binary_response_no_extras protocol_binary_response_del_vbucket;
699
700 /**
701 * Definition of the packet used by get vbucket
702 */
703 typedef protocol_binary_request_no_extras protocol_binary_request_get_vbucket;
704
705 /**
706 * Definition of the packet returned from get vbucket
707 */
708 typedef union {
709 struct {
710 protocol_binary_response_header header;
711 struct {
712 vbucket_state_t state;
713 } body;
714 } message;
715 uint8_t bytes[sizeof(protocol_binary_response_header) + sizeof(vbucket_state_t)];
716 } protocol_binary_response_get_vbucket;
717
718
719 /**
720 * @}
721 */
722
723 #ifdef __cplusplus
724 }
725 #endif
726 #endif /* PROTOCOL_BINARY_H */