git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/memcached/protocol_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         PROTOCOL_BINARY_CMD_GATK = 0x23,
 126         PROTOCOL_BINARY_CMD_GATKQ = 0x24,
 127
 128         PROTOCOL_BINARY_CMD_SASL_LIST_MECHS = 0x20,
 129         PROTOCOL_BINARY_CMD_SASL_AUTH = 0x21,
 130         PROTOCOL_BINARY_CMD_SASL_STEP = 0x22,
 131
 132         /* These commands are used for range operations and exist within
 133          * this header for use in other projects.  Range operations are
 134          * not expected to be implemented in the memcached server itself.
 135          */
 136         PROTOCOL_BINARY_CMD_RGET      = 0x30,
 137         PROTOCOL_BINARY_CMD_RSET      = 0x31,
 138         PROTOCOL_BINARY_CMD_RSETQ     = 0x32,
 139         PROTOCOL_BINARY_CMD_RAPPEND   = 0x33,
 140         PROTOCOL_BINARY_CMD_RAPPENDQ  = 0x34,
 141         PROTOCOL_BINARY_CMD_RPREPEND  = 0x35,
 142         PROTOCOL_BINARY_CMD_RPREPENDQ = 0x36,
 143         PROTOCOL_BINARY_CMD_RDELETE   = 0x37,
 144         PROTOCOL_BINARY_CMD_RDELETEQ  = 0x38,
 145         PROTOCOL_BINARY_CMD_RINCR     = 0x39,
 146         PROTOCOL_BINARY_CMD_RINCRQ    = 0x3a,
 147         PROTOCOL_BINARY_CMD_RDECR     = 0x3b,
 148         PROTOCOL_BINARY_CMD_RDECRQ    = 0x3c,
 149         /* End Range operations */
 150
 151         /* VBucket commands */
 152         PROTOCOL_BINARY_CMD_SET_VBUCKET = 0x3d,
 153         PROTOCOL_BINARY_CMD_GET_VBUCKET = 0x3e,
 154         PROTOCOL_BINARY_CMD_DEL_VBUCKET = 0x3f,
 155         /* End VBucket commands */
 156
 157         /* TAP commands */
 158         PROTOCOL_BINARY_CMD_TAP_CONNECT = 0x40,
 159         PROTOCOL_BINARY_CMD_TAP_MUTATION = 0x41,
 160         PROTOCOL_BINARY_CMD_TAP_DELETE = 0x42,
 161         PROTOCOL_BINARY_CMD_TAP_FLUSH = 0x43,
 162         PROTOCOL_BINARY_CMD_TAP_OPAQUE = 0x44,
 163         PROTOCOL_BINARY_CMD_TAP_VBUCKET_SET = 0x45,
 164         PROTOCOL_BINARY_CMD_TAP_CHECKPOINT_START = 0x46,
 165         PROTOCOL_BINARY_CMD_TAP_CHECKPOINT_END = 0x47,
 166         /* End TAP */
 167
 168         PROTOCOL_BINARY_CMD_LAST_RESERVED = 0xef,
 169
 170         /* Scrub the data */
 171         PROTOCOL_BINARY_CMD_SCRUB = 0xf0
 172     } protocol_binary_command;
 173
 174     /**
 175      * Definition of the data types in the packet
 176      * See section 3.4 Data Types
 177      */
 178     typedef enum {
 179         PROTOCOL_BINARY_RAW_BYTES = 0x00
 180     } protocol_binary_datatypes;
 181
 182     /**
 183      * Definition of the header structure for a request packet.
 184      * See section 2
 185      */
 186     typedef union {
 187         struct {
 188             uint8_t magic;
 189             uint8_t opcode;
 190             uint16_t keylen;
 191             uint8_t extlen;
 192             uint8_t datatype;
 193             uint16_t vbucket;
 194             uint32_t bodylen;
 195             uint32_t opaque;
 196             uint64_t cas;
 197         } request;
 198         uint8_t bytes[24];
 199     } protocol_binary_request_header;
 200
 201     /**
 202      * Definition of the header structure for a response packet.
 203      * See section 2
 204      */
 205     typedef union {
 206         struct {
 207             uint8_t magic;
 208             uint8_t opcode;
 209             uint16_t keylen;
 210             uint8_t extlen;
 211             uint8_t datatype;
 212             uint16_t status;
 213             uint32_t bodylen;
 214             uint32_t opaque;
 215             uint64_t cas;
 216         } response;
 217         uint8_t bytes[24];
 218     } protocol_binary_response_header;
 219
 220     /**
 221      * Definition of a request-packet containing no extras
 222      */
 223     union protocol_binary_request_no_extras {
 224         struct {
 225             protocol_binary_request_header header;
 226         } message;
 227         uint8_t bytes[sizeof(protocol_binary_request_header)];
 228     };
 229     typedef union protocol_binary_request_no_extras protocol_binary_request_no_extras;
 230
 231     /**
 232      * Definition of a response-packet containing no extras
 233      */
 234     typedef union {
 235         struct {
 236             protocol_binary_response_header header;
 237         } message;
 238         uint8_t bytes[sizeof(protocol_binary_response_header)];
 239     } protocol_binary_response_no_extras;
 240
 241     /**
 242      * Definition of the packet used by the get, getq, getk and getkq command.
 243      * See section 4
 244      */
 245     typedef protocol_binary_request_no_extras protocol_binary_request_get;
 246     typedef protocol_binary_request_no_extras protocol_binary_request_getq;
 247     typedef protocol_binary_request_no_extras protocol_binary_request_getk;
 248     typedef protocol_binary_request_no_extras protocol_binary_request_getkq;
 249
 250     /**
 251      * Definition of the packet returned from a successful get, getq, getk and
 252      * getkq.
 253      * See section 4
 254      */
 255     typedef union {
 256         struct {
 257             protocol_binary_response_header header;
 258             struct {
 259                 uint32_t flags;
 260             } body;
 261         } message;
 262         uint8_t bytes[sizeof(protocol_binary_response_header) + 4];
 263     } protocol_binary_response_get;
 264
 265     typedef protocol_binary_response_get protocol_binary_response_getq;
 266     typedef protocol_binary_response_get protocol_binary_response_getk;
 267     typedef protocol_binary_response_get protocol_binary_response_getkq;
 268
 269     /**
 270      * Definition of the packet used by the delete command
 271      * See section 4
 272      */
 273     typedef protocol_binary_request_no_extras protocol_binary_request_delete;
 274
 275     /**
 276      * Definition of the packet returned by the delete command
 277      * See section 4
 278      */
 279     typedef protocol_binary_response_no_extras protocol_binary_response_delete;
 280
 281     /**
 282      * Definition of the packet used by the flush command
 283      * See section 4
 284      * Please note that the expiration field is optional, so remember to see
 285      * check the header.bodysize to see if it is present.
 286      */
 287     typedef union {
 288         struct {
 289             protocol_binary_request_header header;
 290             struct {
 291                 uint32_t expiration;
 292             } body;
 293         } message;
 294         uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
 295     } protocol_binary_request_flush;
 296
 297     /**
 298      * Definition of the packet returned by the flush command
 299      * See section 4
 300      */
 301     typedef protocol_binary_response_no_extras protocol_binary_response_flush;
 302
 303     /**
 304      * Definition of the packet used by set, add and replace
 305      * See section 4
 306      */
 307     typedef union {
 308         struct {
 309             protocol_binary_request_header header;
 310             struct {
 311                 uint32_t flags;
 312                 uint32_t expiration;
 313             } body;
 314         } message;
 315         uint8_t bytes[sizeof(protocol_binary_request_header) + 8];
 316     } protocol_binary_request_set;
 317     typedef protocol_binary_request_set protocol_binary_request_add;
 318     typedef protocol_binary_request_set protocol_binary_request_replace;
 319
 320     /**
 321      * Definition of the packet returned by set, add and replace
 322      * See section 4
 323      */
 324     typedef protocol_binary_response_no_extras protocol_binary_response_set;
 325     typedef protocol_binary_response_no_extras protocol_binary_response_add;
 326     typedef protocol_binary_response_no_extras protocol_binary_response_replace;
 327
 328     /**
 329      * Definition of the noop packet
 330      * See section 4
 331      */
 332     typedef protocol_binary_request_no_extras protocol_binary_request_noop;
 333
 334     /**
 335      * Definition of the packet returned by the noop command
 336      * See section 4
 337      */
 338     typedef protocol_binary_response_no_extras protocol_binary_response_noop;
 339
 340     /**
 341      * Definition of the structure used by the increment and decrement
 342      * command.
 343      * See section 4
 344      */
 345     typedef union {
 346         struct {
 347             protocol_binary_request_header header;
 348             struct {
 349                 uint64_t delta;
 350                 uint64_t initial;
 351                 uint32_t expiration;
 352             } body;
 353         } message;
 354         uint8_t bytes[sizeof(protocol_binary_request_header) + 20];
 355     } protocol_binary_request_incr;
 356     typedef protocol_binary_request_incr protocol_binary_request_decr;
 357
 358     /**
 359      * Definition of the response from an incr or decr command
 360      * command.
 361      * See section 4
 362      */
 363     typedef union {
 364         struct {
 365             protocol_binary_response_header header;
 366             struct {
 367                 uint64_t value;
 368             } body;
 369         } message;
 370         uint8_t bytes[sizeof(protocol_binary_response_header) + 8];
 371     } protocol_binary_response_incr;
 372     typedef protocol_binary_response_incr protocol_binary_response_decr;
 373
 374     /**
 375      * Definition of the quit
 376      * See section 4
 377      */
 378     typedef protocol_binary_request_no_extras protocol_binary_request_quit;
 379
 380     /**
 381      * Definition of the packet returned by the quit command
 382      * See section 4
 383      */
 384     typedef protocol_binary_response_no_extras protocol_binary_response_quit;
 385
 386     /**
 387      * Definition of the packet used by append and prepend command
 388      * See section 4
 389      */
 390     typedef protocol_binary_request_no_extras protocol_binary_request_append;
 391     typedef protocol_binary_request_no_extras protocol_binary_request_prepend;
 392
 393     /**
 394      * Definition of the packet returned from a successful append or prepend
 395      * See section 4
 396      */
 397     typedef protocol_binary_response_no_extras protocol_binary_response_append;
 398     typedef protocol_binary_response_no_extras protocol_binary_response_prepend;
 399
 400     /**
 401      * Definition of the packet used by the version command
 402      * See section 4
 403      */
 404     typedef protocol_binary_request_no_extras protocol_binary_request_version;
 405
 406     /**
 407      * Definition of the packet returned from a successful version command
 408      * See section 4
 409      */
 410     typedef protocol_binary_response_no_extras protocol_binary_response_version;
 411
 412
 413     /**
 414      * Definition of the packet used by the stats command.
 415      * See section 4
 416      */
 417     typedef protocol_binary_request_no_extras protocol_binary_request_stats;
 418
 419     /**
 420      * Definition of the packet returned from a successful stats command
 421      * See section 4
 422      */
 423     typedef protocol_binary_response_no_extras protocol_binary_response_stats;
 424
 425     /**
 426      * Definition of the packet used by the verbosity command
 427      */
 428     typedef union {
 429         struct {
 430             protocol_binary_request_header header;
 431             struct {
 432                 uint32_t level;
 433             } body;
 434         } message;
 435         uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
 436     } protocol_binary_request_verbosity;
 437
 438     /**
 439      * Definition of the packet returned from the verbosity command
 440      */
 441     typedef protocol_binary_response_no_extras protocol_binary_response_verbosity;
 442
 443     /**
 444      * Definition of the packet used by the touch command.
 445      */
 446     typedef union {
 447         struct {
 448             protocol_binary_request_header header;
 449             struct {
 450                 uint32_t expiration;
 451             } body;
 452         } message;
 453         uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
 454     } protocol_binary_request_touch;
 455
 456     /**
 457      * Definition of the packet returned from the touch command
 458      */
 459     typedef protocol_binary_response_no_extras protocol_binary_response_touch;
 460
 461     /**
 462      * Definition of the packet used by the GAT(Q) command.
 463      */
 464     typedef union {
 465         struct {
 466             protocol_binary_request_header header;
 467             struct {
 468                 uint32_t expiration;
 469             } body;
 470         } message;
 471         uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
 472     } protocol_binary_request_gat;
 473
 474     typedef protocol_binary_request_gat protocol_binary_request_gatq;
 475
 476     /**
 477      * Definition of the packet returned from the GAT(Q)
 478      */
 479     typedef protocol_binary_response_get protocol_binary_response_gat;
 480     typedef protocol_binary_response_get protocol_binary_response_gatq;
 481
 482
 483     /**
 484      * Definition of a request for a range operation.
 485      * See http://code.google.com/p/memcached/wiki/RangeOps
 486      *
 487      * These types are used for range operations and exist within
 488      * this header for use in other projects.  Range operations are
 489      * not expected to be implemented in the memcached server itself.
 490      */
 491     typedef union {
 492         struct {
 493             protocol_binary_response_header header;
 494             struct {
 495                 uint16_t size;
 496                 uint8_t  reserved;
 497                 uint8_t  flags;
 498                 uint32_t max_results;
 499             } body;
 500         } message;
 501         uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
 502     } protocol_binary_request_rangeop;
 503
 504     typedef protocol_binary_request_rangeop protocol_binary_request_rget;
 505     typedef protocol_binary_request_rangeop protocol_binary_request_rset;
 506     typedef protocol_binary_request_rangeop protocol_binary_request_rsetq;
 507     typedef protocol_binary_request_rangeop protocol_binary_request_rappend;
 508     typedef protocol_binary_request_rangeop protocol_binary_request_rappendq;
 509     typedef protocol_binary_request_rangeop protocol_binary_request_rprepend;
 510     typedef protocol_binary_request_rangeop protocol_binary_request_rprependq;
 511     typedef protocol_binary_request_rangeop protocol_binary_request_rdelete;
 512     typedef protocol_binary_request_rangeop protocol_binary_request_rdeleteq;
 513     typedef protocol_binary_request_rangeop protocol_binary_request_rincr;
 514     typedef protocol_binary_request_rangeop protocol_binary_request_rincrq;
 515     typedef protocol_binary_request_rangeop protocol_binary_request_rdecr;
 516     typedef protocol_binary_request_rangeop protocol_binary_request_rdecrq;
 517
 518
 519     /**
 520      * Definition of tap commands
 521      * See To be written
 522      *
 523      */
 524
 525     typedef union {
 526         struct {
 527             protocol_binary_request_header header;
 528             struct {
 529                 /**
 530                  * flags is a bitmask used to set properties for the
 531                  * the connection. Please In order to be forward compatible
 532                  * you should set all undefined bits to 0.
 533                  *
 534                  * If the bit require extra userdata, it will be stored
 535                  * in the user-data field of the body (passed to the engine
 536                  * as enginespeciffic). That means that when you parse the
 537                  * flags and the engine-specific data, you have to work your
 538                  * way from bit 0 and upwards to find the correct offset for
 539                  * the data.
 540                  *
 541                  */
 542                 uint32_t flags;
 543
 544                 /**
 545                  * Backfill age
 546                  *
 547                  * By using this flag you can limit the amount of data being
 548                  * transmitted. If you don't specify a backfill age, the
 549                  * server will transmit everything it contains.
 550                  *
 551                  * The first 8 bytes in the engine specific data contains
 552                  * the oldest entry (from epoc) you're interested in.
 553                  * Specifying a time in the future (for the server you are
 554                  * connecting to), will cause it to start streaming current
 555                  * changes.
 556                  */
 557 #define TAP_CONNECT_FLAG_BACKFILL 0x01
 558                 /**
 559                  * Dump will cause the server to send the data stored on the
 560                  * server, but disconnect when the keys stored in the server
 561                  * are transmitted.
 562                  */
 563 #define TAP_CONNECT_FLAG_DUMP 0x02
 564                 /**
 565                  * The body contains a list of 16 bits words in network byte
 566                  * order specifying the vbucket ids to monitor. The first 16
 567                  * bit word contains the number of buckets. The number of 0
 568                  * means "all buckets"
 569                  */
 570 #define TAP_CONNECT_FLAG_LIST_VBUCKETS 0x04
 571                 /**
 572                  * The responsibility of the vbuckets is to be transferred
 573                  * over to the caller when all items are transferred.
 574                  */
 575 #define TAP_CONNECT_FLAG_TAKEOVER_VBUCKETS 0x08
 576                 /**
 577                  * The tap consumer supports ack'ing of tap messages
 578                  */
 579 #define TAP_CONNECT_SUPPORT_ACK 0x10
 580                 /**
 581                  * The tap consumer would prefer to just get the keys
 582                  * back. If the engine supports this it will set
 583                  * the TAP_FLAG_NO_VALUE flag in each of the
 584                  * tap packets returned.
 585                  */
 586 #define TAP_CONNECT_REQUEST_KEYS_ONLY 0x20
 587                 /**
 588                  * The body contains a list of (vbucket_id, last_checkpoint_id)
 589                  * pairs. This provides the checkpoint support in TAP streams.
 590                  * The last checkpoint id represents the last checkpoint that
 591                  * was successfully persisted.
 592                  */
 593 #define TAP_CONNECT_CHECKPOINT 0x40
 594                 /**
 595                  * The tap consumer is a registered tap client, which means that
 596                  * the tap server will maintain its checkpoint cursor permanently.
 597                  */
 598 #define TAP_CONNECT_REGISTERED_CLIENT 0x80
 599             } body;
 600         } message;
 601         uint8_t bytes[sizeof(protocol_binary_request_header) + 4];
 602     } protocol_binary_request_tap_connect;
 603
 604     typedef union {
 605         struct {
 606             protocol_binary_request_header header;
 607             struct {
 608                 struct {
 609                     uint16_t enginespecific_length;
 610                     /*
 611                      * The flag section support the following flags
 612                      */
 613                     /**
 614                      * Request that the consumer send a response packet
 615                      * for this packet. The opaque field must be preserved
 616                      * in the response.
 617                      */
 618 #define TAP_FLAG_ACK 0x01
 619                     /**
 620                      * The value for the key is not included in the packet
 621                      */
 622 #define TAP_FLAG_NO_VALUE 0x02
 623                     uint16_t flags;
 624                     uint8_t  ttl;
 625                     uint8_t  res1;
 626                     uint8_t  res2;
 627                     uint8_t  res3;
 628                 } tap;
 629                 struct {
 630                     uint32_t flags;
 631                     uint32_t expiration;
 632                 } item;
 633             } body;
 634         } message;
 635         uint8_t bytes[sizeof(protocol_binary_request_header) + 16];
 636     } protocol_binary_request_tap_mutation;
 637
 638     typedef union {
 639         struct {
 640             protocol_binary_request_header header;
 641             struct {
 642                 struct {
 643                     uint16_t enginespecific_length;
 644                     /**
 645                      * See the definition of the flags for
 646                      * protocol_binary_request_tap_mutation for a description
 647                      * of the available flags.
 648                      */
 649                     uint16_t flags;
 650                     uint8_t  ttl;
 651                     uint8_t  res1;
 652                     uint8_t  res2;
 653                     uint8_t  res3;
 654                 } tap;
 655             } body;
 656         } message;
 657         uint8_t bytes[sizeof(protocol_binary_request_header) + 8];
 658     } protocol_binary_request_tap_no_extras;
 659
 660     typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_delete;
 661     typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_flush;
 662     typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_opaque;
 663     typedef protocol_binary_request_tap_no_extras protocol_binary_request_tap_vbucket_set;
 664
 665
 666     /**
 667      * Definition of the packet used by the scrub.
 668      */
 669     typedef protocol_binary_request_no_extras protocol_binary_request_scrub;
 670
 671     /**
 672      * Definition of the packet returned from scrub.
 673      */
 674     typedef protocol_binary_response_no_extras protocol_binary_response_scrub;
 675
 676
 677     /**
 678      * Definition of the packet used by set vbucket
 679      */
 680     typedef union {
 681         struct {
 682             protocol_binary_request_header header;
 683             struct {
 684                 vbucket_state_t state;
 685             } body;
 686         } message;
 687         uint8_t bytes[sizeof(protocol_binary_request_header) + sizeof(vbucket_state_t)];
 688     } protocol_binary_request_set_vbucket;
 689     /**
 690      * Definition of the packet returned from set vbucket
 691      */
 692     typedef protocol_binary_response_no_extras protocol_binary_response_set_vbucket;
 693     /**
 694      * Definition of the packet used by del vbucket
 695      */
 696     typedef protocol_binary_request_no_extras protocol_binary_request_del_vbucket;
 697     /**
 698      * Definition of the packet returned from del vbucket
 699      */
 700     typedef protocol_binary_response_no_extras protocol_binary_response_del_vbucket;
 701
 702     /**
 703      * Definition of the packet used by get vbucket
 704      */
 705     typedef protocol_binary_request_no_extras protocol_binary_request_get_vbucket;
 706
 707     /**
 708      * Definition of the packet returned from get vbucket
 709      */
 710     typedef union {
 711         struct {
 712             protocol_binary_response_header header;
 713             struct {
 714                 vbucket_state_t state;
 715             } body;
 716         } message;
 717         uint8_t bytes[sizeof(protocol_binary_response_header) + sizeof(vbucket_state_t)];
 718     } protocol_binary_response_get_vbucket;
 719
 720
 721     /**
 722      * @}
 723      */
 724
 725 #ifdef __cplusplus
 726 }
 727 #endif
 728 #endif /* PROTOCOL_BINARY_H */