mt-libcouchbase 1.4.0

data/ext/libcouchbase/include/libcouchbase/crypto.h

@@ -0,0 +1,306 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LCB_CRYPTO_H
+#define LCB_CRYPTO_H
+
+/**
+ * @file
+ * Field encryption
+ *
+ * @uncommitted
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @ingroup lcb-public-api
+ * @defgroup lcb-crypto-api Encryption
+ * @brief Register crypto-providers and working with encrypted fields of the documents.
+ * @details
+ * These routines contain functionality to define and hook crypto providers, as well as
+ * functions which should be used for portable (cross SDK) encoding of encrypted fields.
+ */
+
+/**
+ * @addtogroup lcb-crypto-api
+ * @{
+ */
+
+/**
+ * IOV-style structure for signing functions of crypto-provider.
+ *
+ * @committed
+ */
+typedef struct lcbcrypto_SIGV {
+    const uint8_t *data; /**< pointer to data */
+    size_t len;          /**< length of the data in bytes */
+} lcbcrypto_SIGV;
+
+struct lcbcrypto_PROVIDER;
+/**
+ * Crypto-provider interface.
+ *
+ * See full example in @ref example/crypto/openssl_symmetric_provider.c
+ *
+ * @see lcbcrypto_register
+ * @see lcbcrypto_unregister
+ *
+ * @committed
+ */
+typedef struct lcbcrypto_PROVIDER {
+    uint16_t version;                                        /**< version of the structure, current value is 1 */
+    int16_t _refcnt;                                         /**< reference counter */
+    uint64_t flags;                                          /**< provider-specific flags */
+    void *cookie;                                            /**< opaque pointer (e.g. pointer to wrapper instance) */
+    void (*destructor)(struct lcbcrypto_PROVIDER *provider); /**< destructor function, or NULL */
+    union {
+        LCB_DEPRECATED2(
+            struct {
+                void (*release_bytes)(struct lcbcrypto_PROVIDER * provider, void *bytes);
+                lcb_error_t (*load_key)(struct lcbcrypto_PROVIDER * provider, lcbcrypto_KEYTYPE type, const char *keyid,
+                                        uint8_t **key, size_t *key_len);
+                lcb_error_t (*generate_iv)(struct lcbcrypto_PROVIDER * provider, uint8_t * *iv, size_t * iv_len);
+                lcb_error_t (*sign)(struct lcbcrypto_PROVIDER * provider, const lcbcrypto_SIGV *inputs,
+                                    size_t input_num, uint8_t **sig, size_t *sig_len);
+                lcb_error_t (*verify_signature)(struct lcbcrypto_PROVIDER * provider, const lcbcrypto_SIGV *inputs,
+                                                size_t input_num, uint8_t *sig, size_t sig_len);
+                lcb_error_t (*encrypt)(struct lcbcrypto_PROVIDER * provider, const uint8_t *input, size_t input_len,
+                                       const uint8_t *key, size_t key_len, const uint8_t *iv, size_t iv_len,
+                                       uint8_t **output, size_t *output_len);
+                lcb_error_t (*decrypt)(struct lcbcrypto_PROVIDER * provider, const uint8_t *input, size_t input_len,
+                                       const uint8_t *key, size_t key_len, const uint8_t *iv, size_t iv_len,
+                                       uint8_t **output, size_t *output_len);
+            } v0,
+            "v0 crypto API has been deprecated, use v1");
+        struct {
+            /** function to use when the library wants to deallocate memory, returned by provider */
+            void (*release_bytes)(struct lcbcrypto_PROVIDER *provider, void *bytes);
+            /** initialization vector (IV) generator */
+            lcb_error_t (*generate_iv)(struct lcbcrypto_PROVIDER *provider, uint8_t **iv, size_t *iv_len);
+            /** generate cryptographic signature for the data */
+            lcb_error_t (*sign)(struct lcbcrypto_PROVIDER *provider, const lcbcrypto_SIGV *inputs, size_t input_num,
+                                uint8_t **sig, size_t *sig_len);
+            /** verify signature of the data */
+            lcb_error_t (*verify_signature)(struct lcbcrypto_PROVIDER *provider, const lcbcrypto_SIGV *inputs,
+                                            size_t input_num, uint8_t *sig, size_t sig_len);
+            /** encrypt data */
+            lcb_error_t (*encrypt)(struct lcbcrypto_PROVIDER *provider, const uint8_t *input, size_t input_len,
+                                   const uint8_t *iv, size_t iv_len, uint8_t **output, size_t *output_len);
+            /** decrypt data */
+            lcb_error_t (*decrypt)(struct lcbcrypto_PROVIDER *provider, const uint8_t *input, size_t input_len,
+                                   const uint8_t *iv, size_t iv_len, uint8_t **output, size_t *output_len);
+            /** returns key identifier, associated with the crypto-provider */
+            const char *(*get_key_id)(struct lcbcrypto_PROVIDER *provider);
+        } v1;
+    } v;
+} lcbcrypto_PROVIDER;
+
+/**
+ * Structure for JSON field specification for encrypt/decrypt API.
+ *
+ * @see lcbcrypto_encrypt_fields
+ * @see lcbcrypto_decrypt_fields
+ *
+ * @committed
+ */
+typedef struct lcbcrypto_FIELDSPEC {
+    const char *name; /**< field name (NUL-terminated) */
+    const char *alg;  /**< crypto provider alias (NUL-terminated) */
+    LCB_DEPRECATED2(const char *kid,
+                    "Do not use kid field. Encryption keys have to be part of the provider implementation");
+} lcbcrypto_FIELDSPEC;
+
+/**
+ * Command to encrypt JSON fields.
+ *
+ * @see lcbcrypto_encrypt_fields
+ * @committed
+ */
+typedef struct lcbcrypto_CMDENCRYPT {
+    uint16_t version;   /**< version of the structure, currently valid value is 0 */
+    const char *prefix; /**< prefix to encrypted field. When NULL, it will use @ref LCBCRYPTO_DEFAULT_FIELD_PREFIX */
+    const char *doc;    /**< pointer to the input JSON document */
+    size_t ndoc;        /**< size of the input JSON document */
+    char *out;   /**< pointer to output JSON document. When no changes were applied, this field will be set to NULL */
+    size_t nout; /**< size of the output JSON document */
+    lcbcrypto_FIELDSPEC *fields; /**< list of field specs */
+    size_t nfields;              /**< number of field specs */
+} lcbcrypto_CMDENCRYPT;
+
+/**
+ * Command to decrypt JSON fields.
+ *
+ * @see lcbcrypto_decrypt_fields
+ * @committed
+ */
+typedef struct lcbcrypto_CMDDECRYPT {
+    uint16_t version;   /**< version of the structure, currently valid value is 0 */
+    const char *prefix; /**< prefix to encrypted field. When NULL, it will use @ref LCBCRYPTO_DEFAULT_FIELD_PREFIX */
+    const char *doc;    /**< pointer to the input JSON document */
+    size_t ndoc;        /**< size of the input JSON document */
+    char *out;   /**< pointer to output JSON document. When no changes were applied, this field will be set to NULL */
+    size_t nout; /**< size of the output JSON document */
+    lcbcrypto_FIELDSPEC *fields; /**< list of field specs */
+    size_t nfields;              /**< number of field specs */
+} lcbcrypto_CMDDECRYPT;
+
+/**
+ * Register crypto-provider for specified alias.
+ *
+ * See full example in @ref example/crypto/openssl_symmetric_provider.c
+ *
+ * @param instance the handle
+ * @param name provider alias, this will be recorded in JSON.
+ * @param provider implementation of the crypto-provider
+ *
+ * @par Register provider as "AES-256-HMAC-SHA256".
+ * @code{.c}
+ * lcbcrypto_PROVIDER *provider = calloc(1, sizeof(lcbcrypto_PROVIDER));
+ * provider->version = 1;
+ * provider->destructor = osp_free;
+ * provider->v.v1.release_bytes = osp_release_bytes;
+ * provider->v.v1.generate_iv = osp_generate_iv;
+ * provider->v.v1.sign = osp_sign;
+ * provider->v.v1.verify_signature = osp_verify_signature;
+ * provider->v.v1.encrypt = osp_encrypt;
+ * provider->v.v1.decrypt = osp_decrypt;
+ * provider->v.v1.get_key_id = osp_get_key_id;
+ * lcbcrypto_register(instance, "AES-256-HMAC-SHA256", provider);
+ * @endcode
+ */
+LIBCOUCHBASE_API void lcbcrypto_register(lcb_t instance, const char *name, lcbcrypto_PROVIDER *provider);
+
+/**
+ * Unregister crypto-provider for specified alias.
+ *
+ * See full example in @ref example/crypto/openssl_symmetric_provider.c
+ *
+ * @param instance the handle
+ * @param name provider alias.
+ */
+LIBCOUCHBASE_API void lcbcrypto_unregister(lcb_t instance, const char *name);
+
+/**
+ * Increment reference counter for crypto-provider.
+ *
+ * @param provider provider instance
+ */
+LIBCOUCHBASE_API void lcbcrypto_ref(lcbcrypto_PROVIDER *provider);
+
+/**
+ * Decrement reference counter for crypto-provider.
+ *
+ * It calls destructor once counter reaches zero. The provider instance should not be used after calling this function.
+ *
+ * @param provider provider instance
+ */
+LIBCOUCHBASE_API void lcbcrypto_unref(lcbcrypto_PROVIDER *provider);
+
+/**
+ * Default prefix for encrypted JSON fields.
+ */
+#define LCBCRYPTO_DEFAULT_FIELD_PREFIX "__crypt_"
+
+/**
+ * Encrypt all specified fields in the JSON encoded object.
+ *
+ * The function will remove original content of the field, and rename it using @ref LCBCRYPTO_DEFAULT_FIELD_PREFIX, or
+ * custom prefix, specified in the command.
+ *
+ * See full example in @ref example/crypto/openssl_symmetric_encrypt.c
+ *
+ * @param instance the handle
+ * @param cmd the command structure
+ * @return LCB_SUCCESS if successful, an error code otherwise
+ *
+ * @par Encrypt field "message" in the document using provider registered as "AES-256-HMAC-SHA256"
+ * @code{.c}
+ * lcbcrypto_CMDENCRYPT cmd = {};
+ * lcbcrypto_FIELDSPEC field = {};
+ * lcb_error_t err;
+ *
+ * cmd.version = 0;
+ * cmd.prefix = NULL;
+ * cmd.doc = "{\"message\":\"hello world\"}";
+ * cmd.ndoc = strlen(cmd.doc);
+ * cmd.nfields = 1;
+ * cmd.fields = &field;
+ * field.name = "message";
+ * field.alg = "AES-256-HMAC-SHA256";
+ *
+ * err = lcbcrypto_encrypt_fields(instance, &cmd);
+ * @endcode
+ *
+ * @committed
+ */
+LIBCOUCHBASE_API lcb_error_t lcbcrypto_encrypt_fields(lcb_t instance, lcbcrypto_CMDENCRYPT *cmd);
+
+/**
+ * Decrypt all specified fields in the JSON encoded object.
+ *
+ * The function will remove original content of the field, and rename it using @ref LCBCRYPTO_DEFAULT_FIELD_PREFIX, or
+ * custom prefix, specified in the command.
+ *
+ * See full example in @ref example/crypto/openssl_symmetric_decrypt.c
+ *
+ * @param instance the handle
+ * @param cmd the command structure
+ * @return LCB_SUCCESS if successful, an error code otherwise
+ *
+ * @par Decrypt field "message" in the document using provider registered as "AES-256-HMAC-SHA256"
+ * @code{.c}
+ * lcbcrypto_CMDDECRYPT cmd = {};
+ * lcbcrypto_FIELDSPEC field = {};
+ * lcb_error_t err;
+ *
+ * cmd.version = 0;
+ * cmd.prefix = NULL;
+ * cmd.doc = "{\"__crypt_message\":{" \
+ *               "\"alg\":\"AES-256-HMAC-SHA256\"," \
+ *               "\"ciphertext\":\"gYuyEhf6S0AiMGZJZZV35Q==\"," \
+ *               "\"iv\":\"ZedmvjWy0lIrLn6OmQmNqQ==\"," \
+ *               "\"kid\":\"mykeyid\"," \
+ *               "\"sig\":\"FgleInW3Iia04XqLbm5Hd3qVoa77Ocs7g2x4pOutEtY=\"}" \
+ *           "}";
+ * cmd.ndoc = strlen(cmd.doc);
+ * cmd.nfields = 1;
+ * cmd.fields = &field;
+ * field.name = "message";
+ * field.alg = "AES-256-HMAC-SHA256";
+ *
+ * err = lcbcrypto_decrypt_fields(instance, &cmd);
+ * @endcode
+ *
+ * @committed
+ */
+LIBCOUCHBASE_API lcb_error_t lcbcrypto_decrypt_fields(lcb_t instance, lcbcrypto_CMDDECRYPT *cmd);
+/**@}*/
+
+/** @deprecated Use @ref lcbcrypto_encrypt_fields() */
+LCB_DEPR_API2(lcb_error_t lcbcrypto_encrypt_document(lcb_t instance, lcbcrypto_CMDENCRYPT *cmd),
+              "Use lcbcrypto_encrypt_fields");
+/** @deprecated Use @ref lcbcrypto_decrypt_fields() */
+LCB_DEPR_API2(lcb_error_t lcbcrypto_decrypt_document(lcb_t instance, lcbcrypto_CMDDECRYPT *cmd),
+              "Use lcbcrypto_decrypt_fields");
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* LCB_CRYPTO_H */

data/ext/libcouchbase/include/libcouchbase/deprecated.h

@@ -0,0 +1,312 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LCB_DEPRECATED_H
+#define LCB_DEPRECATED_H
+#ifndef LIBCOUCHBASE_COUCHBASE_H
+#error "include <libcouchbase/couchbase.h> first"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@file
+ * Deprecated APIs
+ */
+
+#define LCB_DEPR_API(X) LIBCOUCHBASE_API LCB_DEPRECATED(X)
+#define LCB_DEPR_API2(X, reason) LIBCOUCHBASE_API LCB_DEPRECATED2(X, reason)
+
+/** @deprecated Use @ref LCB_CNTL_IP6POLICY via lcb_cntl() */
+LCB_DEPR_API2(void lcb_behavior_set_ipv6(lcb_t instance, lcb_ipv6_t mode), "Use LCB_CNTL_IP6POLICY");
+/** @deprecated Use @ref LCB_CNTL_IP6POLICY via lcb_cntl() */
+LCB_DEPR_API2(lcb_ipv6_t lcb_behavior_get_ipv6(lcb_t instance), "Use LCB_CNTL_IP6POLICY");
+/** @deprecated Use @ref LCB_CNTL_CONFERRTHRESH via lcb_cntl() */
+LCB_DEPR_API2(void lcb_behavior_set_config_errors_threshold(lcb_t instance, lcb_size_t num_events),
+    "Use LCB_CNTL_CONFERRTHRESH");
+/** @deprecated Use @ref LCB_CNTL_CONFERRTHRESH via lcb_cntl() */
+LCB_DEPR_API2(lcb_size_t lcb_behavior_get_config_errors_threshold(lcb_t instance),
+    "Use LCB_CNTL_CONFERRTHRESH");
+/** @deprecated Use @ref LCB_CNTL_OP_TIMEOUT via lcb_cntl() */
+LCB_DEPR_API2(void lcb_set_timeout(lcb_t instance, lcb_uint32_t usec),
+    "Use LCB_CNTL_OP_TIMEOUT");
+/** @deprecated Use @ref LCB_CNTL_OP_TIMEOUT via lcb_cntl() */
+LCB_DEPR_API2(lcb_uint32_t lcb_get_timeout(lcb_t instance),
+    "Use LCB_CNTL_OP_TIMEOUT");
+/** @deprecated Use @ref LCB_CNTL_VIEW_TIMEOUT via lcb_cntl() */
+LCB_DEPR_API2(void lcb_set_view_timeout(lcb_t instance, lcb_uint32_t usec),
+    "Use LCB_CNTL_VIEW_TIMEOUT");
+/** @deprecated Use @ref LCB_CNTL_VIEW_TIMEOUT via lcb_cntl() */
+LCB_DEPR_API2(lcb_uint32_t lcb_get_view_timeout(lcb_t instance),
+    "Use LCB_CNTL_VIEW_TIMEOUT");
+
+/**
+ * @deprecated Do not use this function. Check the error code of the specific operation
+ * to determine if something succeeded or not. Because the library has many
+ * asynchronous "flows" of control, determining the "last error" is not very
+ * fruitful. Since most API calls are themselves only schedule-related, they cannot
+ * possibly derive a "Real" error either
+ */
+LCB_DEPR_API2(lcb_error_t lcb_get_last_error(lcb_t instance),
+    "This function does not returning meaningful information. Use the operation callbacks "
+    "and/or bootstrap callbacks");
+
+/** @deprecated This function does nothing */
+LCB_DEPR_API2(void lcb_flush_buffers(lcb_t instance, const void *cookie),
+    "This function does nothing");
+
+/** I'm not sure what uses this anymore */
+typedef enum {
+    LCB_VBUCKET_STATE_ACTIVE = 1,   /* Actively servicing a vbucket. */
+    LCB_VBUCKET_STATE_REPLICA = 2,  /* Servicing a vbucket as a replica only. */
+    LCB_VBUCKET_STATE_PENDING = 3,  /* Pending active. */
+    LCB_VBUCKET_STATE_DEAD = 4      /* Not in use, pending deletion. */
+} lcb_vbucket_state_t;
+
+typedef void (*lcb_error_callback)(lcb_t instance, lcb_error_t error, const char *errinfo);
+
+/**
+ * @deprecated Use the logging API (@ref LCB_CNTL_LOGGER) instead to receive error
+ * information. For programmatic errors, use the operations interface. For bootstrap
+ * status, use lcb_get_bootstrap_status() and lcb_set_bootstrap_callback()
+ */
+LCB_DEPR_API2(lcb_error_callback lcb_set_error_callback(lcb_t, lcb_error_callback),
+    "This function only reports bootstrap errors. Use lcb_set_bootstrap_callback instead");
+
+
+
+/**
+ * Timer stuff is deprecated. It should not be used externally, and internal
+ * code should use the new lcbio_timer_ functions
+ */
+struct lcb_timer_st;
+typedef struct lcb_timer_st *lcb_timer_t;
+typedef void (*lcb_timer_callback)(lcb_timer_t timer, lcb_t instance, const void *cookie);
+LCB_DEPR_API(lcb_timer_t lcb_timer_create(lcb_t instance, const void *command_cookie, lcb_uint32_t usec, int periodic, lcb_timer_callback callback, lcb_error_t *error));
+LCB_DEPR_API(lcb_error_t lcb_timer_destroy(lcb_t instance, lcb_timer_t timer));
+
+typedef enum lcb_compat_t { LCB_MEMCACHED_CLUSTER = 0x00, LCB_CACHED_CONFIG = 0x01 } lcb_compat_t;
+typedef lcb_compat_t lcb_cluster_t;
+struct lcb_memcached_st { const char *serverlist; const char *username; const char *password; };
+struct lcb_cached_config_st {
+    const char *cachefile;
+    struct lcb_create_st createopt;
+};
+
+/**
+ * @deprecated
+ * Use @ref LCB_CNTL_CONFIGCACHE for configuration cache options
+ */
+#define lcb_create_compat lcb__create_compat_230
+LCB_DEPR_API2(lcb_error_t lcb_create_compat(lcb_compat_t type, const void *specific, lcb_t *instance, struct lcb_io_opt_st *io),
+    "Use memcached:// for legacy memcached. For config cache, use LCB_CNTL_CONFIGCACHE");
+
+typedef enum {
+    LCB_ASYNCHRONOUS = 0x00,
+    LCB_SYNCHRONOUS = 0xff
+} lcb_syncmode_t;
+LCB_DEPR_API2(void lcb_behavior_set_syncmode(lcb_t, lcb_syncmode_t),
+    "Syncmode will be removed in future versions. Use lcb_wait() instead");
+LCB_DEPR_API2(lcb_syncmode_t lcb_behavior_get_syncmode(lcb_t),
+    "Syncmode will be removed in future versions. Use lcb_wait() instead");
+
+LCB_DEPR_API2(const char *lcb_get_host(lcb_t),
+    "Use lcb_get_node(instance, LCB_NODE_HTCONFIG, 0)");
+LCB_DEPR_API2(const char *lcb_get_port(lcb_t),
+    "Use lcb_get_node(instance, LCB_NODE_HTCONFIG, 0)");
+
+/*  STRUCTURE                           ABBREV      ID MAXVER */
+#define LCB_XSSIZES(X) \
+    X(struct lcb_create_st,             C_ST,       0, 3) \
+    X(struct lcb_create_io_ops_st,      C_I_O_ST,   1, 1) \
+    \
+    X(struct lcb_get_cmd_st,            G_C_ST,     2, 0) \
+    X(struct lcb_get_replica_cmd_st,    G_R_C_ST,   3, 1) \
+    X(struct lcb_unlock_cmd_st,         U_C_ST,     4, 0) \
+    X(lcb_touch_cmd_t,                  T_C_ST,     5, 0) \
+    X(struct lcb_store_cmd_st,          S_C_ST,     6, 0) \
+    X(struct lcb_arithmetic_cmd_st,     A_C_ST,     7, 0) \
+    X(struct lcb_observe_cmd_st,        O_C_ST,     8, 0) \
+    X(struct lcb_remove_cmd_st,         R_C_ST,     9, 0) \
+    X(struct lcb_http_cmd_st,           H_C_ST,     10, 1) \
+    X(struct lcb_server_stats_cmd_st,   S_S_C_ST,   11, 0) \
+    X(struct lcb_server_version_cmd_st, S_V_C_ST,   12, 0) \
+    X(struct lcb_verbosity_cmd_st,      V_C_ST,     13, 0) \
+    X(struct lcb_flush_cmd_st,          F_C_ST,     14, 0) \
+    \
+    X(lcb_get_resp_t,                   G_R_ST,     15, 0) \
+    X(lcb_store_resp_t,                 S_R_ST,     16, 0) \
+    X(lcb_remove_resp_t,                R_R_ST,     17, 0) \
+    X(lcb_touch_resp_t,                 T_R_ST,     18, 0) \
+    X(lcb_unlock_resp_t,                U_R_ST,     19, 0) \
+    X(lcb_arithmetic_resp_t,            A_R_ST,     20, 0) \
+    X(lcb_observe_resp_t,               O_R_ST,     21, 0) \
+    X(lcb_http_resp_t,                  H_R_ST,     22, 0) \
+    X(lcb_server_stat_resp_t,           S_S_R_ST,   23, 0) \
+    X(lcb_server_version_resp_t,        S_V_R_ST,   24, 0) \
+    X(lcb_verbosity_resp_t,             V_R_ST,     25, 0) \
+    X(lcb_flush_resp_t,                 F_R_ST,     26, 0)
+
+typedef enum {
+#define X(sname, sabbrev, idval, vernum) \
+    LCB_##sabbrev##_ID = idval, LCB_##sabbrev##_V = vernum,
+    LCB_XSSIZES(X)
+    LCB_ST_M = 26
+#undef X
+} lcb__STRUCTSIZES;
+
+#define lcb_verify_compiler_setup() ( \
+    lcb_verify_struct_size(LCB_C_ST_ID, LCB_C_ST_V, sizeof(struct lcb_create_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_C_I_O_ST_ID, LCB_C_I_O_ST_V, sizeof(struct lcb_create_io_ops_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_G_C_ST_ID, LCB_G_C_ST_V, sizeof(struct lcb_get_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_G_R_C_ST_ID, LCB_G_R_C_ST_V, sizeof(struct lcb_get_replica_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_U_C_ST_ID, LCB_U_C_ST_V, sizeof(struct lcb_unlock_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_T_C_ST_ID, LCB_T_C_ST_V, sizeof(lcb_touch_cmd_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_S_C_ST_ID, LCB_S_C_ST_V, sizeof(struct lcb_store_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_A_C_ST_ID, LCB_A_C_ST_V, sizeof(struct lcb_arithmetic_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_O_C_ST_ID, LCB_O_C_ST_V, sizeof(struct lcb_observe_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_R_C_ST_ID, LCB_R_C_ST_V, sizeof(struct lcb_remove_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_H_C_ST_ID, LCB_H_C_ST_V, sizeof(struct lcb_http_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_S_S_C_ST_ID, LCB_S_S_C_ST_V, sizeof(struct lcb_server_stats_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_S_V_C_ST_ID, LCB_S_V_C_ST_V, sizeof(struct lcb_server_version_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_V_C_ST_ID, LCB_V_C_ST_V, sizeof(struct lcb_verbosity_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_F_C_ST_ID, LCB_F_C_ST_V, sizeof(struct lcb_flush_cmd_st)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_G_R_ST_ID, LCB_G_R_ST_V, sizeof(lcb_get_resp_t)) == LCB_SUCCESS &&\
+    lcb_verify_struct_size(LCB_S_R_ST_ID, LCB_S_R_ST_V, sizeof(lcb_store_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_R_R_ST_ID, LCB_R_R_ST_V, sizeof(lcb_remove_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_T_R_ST_ID, LCB_T_R_ST_V, sizeof(lcb_touch_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_U_R_ST_ID, LCB_U_R_ST_V, sizeof(lcb_unlock_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_A_R_ST_ID, LCB_A_R_ST_V, sizeof(lcb_arithmetic_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_O_R_ST_ID, LCB_O_R_ST_V, sizeof(lcb_observe_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_H_R_ST_ID, LCB_H_R_ST_V, sizeof(lcb_http_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_S_S_R_ST_ID, LCB_S_S_R_ST_V, sizeof(lcb_server_stat_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_S_V_R_ST_ID, LCB_S_V_R_ST_V, sizeof(lcb_server_version_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_V_R_ST_ID, LCB_V_R_ST_V, sizeof(lcb_verbosity_resp_t)) == LCB_SUCCESS && \
+    lcb_verify_struct_size(LCB_F_R_ST_ID, LCB_F_R_ST_V, sizeof(lcb_flush_resp_t)) == LCB_SUCCESS \
+)
+
+/**
+ * Verify that libcouchbase and yourself have the same size for a
+ * certain version of a struct. Using different alignment / struct
+ * packing will give you strange results..
+ *
+ * @param id the id of the structure to check
+ * @param version the version of the structure to check
+ * @param size the expected size of the structure
+ * @return LCB_SUCCESS on success
+ */
+LIBCOUCHBASE_API
+lcb_error_t lcb_verify_struct_size(lcb_uint32_t id, lcb_uint32_t version,
+                                   lcb_size_t size);
+
+/** Deprecated cntls */
+
+/**@deprecated It is currently not possible to adjust buffer sizes */
+#define LCB_CNTL_RBUFSIZE               0x02
+/**@deprecated It is currently not possible to adjust buffer sizes */
+#define LCB_CNTL_WBUFSIZE               0x03
+/** @deprecated */
+#define LCB_CNTL_SYNCMODE               0x0a
+/**@deprecated Initial connections are always attempted */
+#define LCB_CNTL_SKIP_CONFIGURATION_ERRORS_ON_CONNECT 0x13
+
+/**@deprecated Use error classifiers */
+#define lcb_is_error_enomem(a) ((a == LCB_CLIENT_ENOMEM) || (a == LCB_ENOMEM))
+/**@deprecated Use error classifiers */
+#define lcb_is_error_etmpfail(a) ((a == LCB_CLIENT_ETMPFAIL) || (a == LCB_ETMPFAIL))
+
+typedef enum {
+    LCB_CONFIGURATION_NEW = 0x00,
+    LCB_CONFIGURATION_CHANGED = 0x01,
+    LCB_CONFIGURATION_UNCHANGED = 0x02
+} lcb_configuration_t;
+
+typedef void (*lcb_configuration_callback)(lcb_t instance, lcb_configuration_t config);
+
+/**@deprecated - Use lcb_set_bootstrap_callback() */
+LCB_DEPR_API2(
+    lcb_configuration_callback lcb_set_configuration_callback(lcb_t, lcb_configuration_callback),
+    "use lcb_set_bootstrap_callback() to determine when client is ready");
+
+/* Deprecated HTTP "Status Aliases" */
+typedef enum {
+    LCB_HTTP_STATUS_CONTINUE = 100,
+    LCB_HTTP_STATUS_SWITCHING_PROTOCOLS = 101,
+    LCB_HTTP_STATUS_PROCESSING = 102,
+    LCB_HTTP_STATUS_OK = 200,
+    LCB_HTTP_STATUS_CREATED = 201,
+    LCB_HTTP_STATUS_ACCEPTED = 202,
+    LCB_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,
+    LCB_HTTP_STATUS_NO_CONTENT = 204,
+    LCB_HTTP_STATUS_RESET_CONTENT = 205,
+    LCB_HTTP_STATUS_PARTIAL_CONTENT = 206,
+    LCB_HTTP_STATUS_MULTI_STATUS = 207,
+    LCB_HTTP_STATUS_MULTIPLE_CHOICES = 300,
+    LCB_HTTP_STATUS_MOVED_PERMANENTLY = 301,
+    LCB_HTTP_STATUS_FOUND = 302,
+    LCB_HTTP_STATUS_SEE_OTHER = 303,
+    LCB_HTTP_STATUS_NOT_MODIFIED = 304,
+    LCB_HTTP_STATUS_USE_PROXY = 305,
+    LCB_HTTP_STATUS_UNUSED = 306,
+    LCB_HTTP_STATUS_TEMPORARY_REDIRECT = 307,
+    LCB_HTTP_STATUS_BAD_REQUEST = 400,
+    LCB_HTTP_STATUS_UNAUTHORIZED = 401,
+    LCB_HTTP_STATUS_PAYMENT_REQUIRED = 402,
+    LCB_HTTP_STATUS_FORBIDDEN = 403,
+    LCB_HTTP_STATUS_NOT_FOUND = 404,
+    LCB_HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
+    LCB_HTTP_STATUS_NOT_ACCEPTABLE = 406,
+    LCB_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,
+    LCB_HTTP_STATUS_REQUEST_TIMEOUT = 408,
+    LCB_HTTP_STATUS_CONFLICT = 409,
+    LCB_HTTP_STATUS_GONE = 410,
+    LCB_HTTP_STATUS_LENGTH_REQUIRED = 411,
+    LCB_HTTP_STATUS_PRECONDITION_FAILED = 412,
+    LCB_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE = 413,
+    LCB_HTTP_STATUS_REQUEST_URI_TOO_LONG = 414,
+    LCB_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,
+    LCB_HTTP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    LCB_HTTP_STATUS_EXPECTATION_FAILED = 417,
+    LCB_HTTP_STATUS_UNPROCESSABLE_ENTITY = 422,
+    LCB_HTTP_STATUS_LOCKED = 423,
+    LCB_HTTP_STATUS_FAILED_DEPENDENCY = 424,
+    LCB_HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,
+    LCB_HTTP_STATUS_NOT_IMPLEMENTED = 501,
+    LCB_HTTP_STATUS_BAD_GATEWAY = 502,
+    LCB_HTTP_STATUS_SERVICE_UNAVAILABLE = 503,
+    LCB_HTTP_STATUS_GATEWAY_TIMEOUT = 504,
+    LCB_HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED = 505,
+    LCB_HTTP_STATUS_INSUFFICIENT_STORAGE = 507
+} lcb_http_status_t;
+
+/**
+ * @deprecated
+ */
+typedef enum {
+    /* encryption (e.g. private key for assymetric ciphers) */
+    LCBCRYPTO_KEY_ENCRYPT = 0,
+    /* decryption (e.g. private key for assymetric ciphers) */
+    LCBCRYPTO_KEY_DECRYPT = 1,
+    LCBCRYPTO_KEY__MAX
+} lcbcrypto_KEYTYPE;
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif