libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/include/libcouchbase/cbft.h

@@ -100,6 +100,14 @@ LIBCOUCHBASE_API
 void
 lcb_fts_cancel(lcb_t, lcb_FTSHANDLE);
 
+#ifdef LCB_TRACING
+/**
+ * @uncommitted
+ */
+LIBCOUCHBASE_API
+void lcb_fts_set_parent_span(lcb_t instance, lcb_FTSHANDLE handle, lcbtrace_SPAN *span);
+#endif
+
 /**
  * @}
  */

data/ext/libcouchbase/include/libcouchbase/cntl-private.h

@@ -181,7 +181,7 @@ struct lcb_cntl_iops_info_st {
  * Similar to @ref LCB_CNTL_CONFIG_HTTP_NODES, but affects the CCCP provider
  * instead. Ports should specify the _memcached_ port
  * @cntl_arg_setonly{char** (Array of strings)}
- * @uncomitted
+ * @uncommitted
  */
 #define LCB_CNTL_CONFIG_CCCP_NODES 0x1E
 
@@ -351,4 +351,58 @@ typedef enum {
  */
 #define LCB_CNTL_KVTIMINGS 0x3C
 
+/**
+ * @volatile
+ * Activate/Get library metrics per-server
+ *
+ * If using @ref LCB_CNTL_SET, then this will activate the metrics, and should
+ * be called immediately after lcb_create. The `arg` parameter should be a pointer
+ * to an integer with the activation value (any non-zero value to activate).
+ *
+ * If using @ref LCB_CNTL_GET, the `arg` parameter should be a @ref `lcb_METRICS**`
+ * variable, which will contain the pointer to the metrics upon completion.
+ */
+#define LCB_CNTL_METRICS 0x49
+
+/**
+ *
+ * @cntl_arg_both{int (as boolean)}
+ * @volatile
+ */
+#define LCB_CNTL_USE_COLLECTIONS 0x4a
+
+/**
+ * Activate end-to-end tracing.
+ *
+ * Use `enable_tracing` in the connection string
+ *
+ * @cntl_arg_both{int* (as boolean)}
+ * @uncommitted
+ */
+#define LCB_CNTL_ENABLE_TRACING 0x4e
+
+#define LCB_CNTL_TRACING_ORPHANED_QUEUE_FLUSH_INTERVAL 0x4f
+#define LCB_CNTL_TRACING_ORPHANED_QUEUE_SIZE 0x50
+#define LCB_CNTL_TRACING_THRESHOLD_QUEUE_FLUSH_INTERVAL 0x51
+#define LCB_CNTL_TRACING_THRESHOLD_QUEUE_SIZE 0x52
+#define LCB_CNTL_TRACING_THRESHOLD_KV 0x53
+#define LCB_CNTL_TRACING_THRESHOLD_N1QL 0x54
+#define LCB_CNTL_TRACING_THRESHOLD_VIEW 0x55
+#define LCB_CNTL_TRACING_THRESHOLD_FTS 0x56
+#define LCB_CNTL_TRACING_THRESHOLD_ANALYTICS 0x57
+
+#define LCB_CNTL_COMPRESSION_MIN_SIZE 0x58
+#define LCB_CNTL_COMPRESSION_MIN_RATIO 0x59
+
+/**
+ * Do not use fast-forward map from cluster configuration.
+ *
+ * Use `vb_noremap` in the connection string
+ *
+ * @cntl_arg_both{int* (as boolean)}
+ * @uncommitted
+ */
+#define LCB_CNTL_VB_NOREMAP 0x5a
+
+
 /**@}*/

data/ext/libcouchbase/include/libcouchbase/cntl.h

@@ -425,6 +425,60 @@ typedef struct lcb_logprocs_st {
  *
  * @cntl_arg_get_and_set{lcb_logprocs**,lcb_logprocs*}*/
 #define LCB_CNTL_LOGGER 0x18
+
+/**
+ * Helper to express printf spec for sensitive data. Usage:
+ *
+ *   printf("Logged as " LCB_LOG_SPEC("%s") " user", LCB_LOG_UD(instance, doc->username));
+ */
+#define LCB_LOG_SPEC(fmt) "%s" fmt "%s"
+
+#define LCB_LOG_UD_OTAG "<ud>"
+#define LCB_LOG_UD_CTAG "</ud>"
+/**
+ * User data is data that is stored into Couchbase by the application user account.
+ *
+ * - Key and value pairs in JSON documents, or the key exclusively
+ * - Application/Admin usernames that identify the human person
+ * - Names and email addresses asked during product registration and alerting
+ * - Usernames
+ * - Document xattrs
+ * - Query statements included in the log file collected by support that leak
+ *   the document fields (Select floor_price from stock).
+ */
+#define LCB_LOG_UD(instance, val)                                                                                      \
+    lcb_is_redacting_logs(instance) ? LCB_LOG_UD_OTAG : "", val, lcb_is_redacting_logs(instance) ? LCB_LOG_UD_CTAG : ""
+
+#define LCB_LOG_MD_OTAG "<md>"
+#define LCB_LOG_MD_CTAG "</md>"
+/**
+ * Metadata is logical data needed by Couchbase to store and process user data.
+ *
+ * - Cluster name
+ * - Bucket names
+ * - DDoc/view names
+ * - View code
+ * - Index names
+ * - Mapreduce Design Doc Name and Definition (IP)
+ * - XDCR Replication Stream Names
+ * - And other couchbase resource specific meta data
+ */
+#define LCB_LOG_MD(instance, val)                                                                                      \
+    lcb_is_redacting_logs(instance) ? LCB_LOG_MD_OTAG : "", val, lcb_is_redacting_logs(instance) ? LCB_LOG_MD_CTAG : ""
+
+#define LCB_LOG_SD_OTAG "<sd>"
+#define LCB_LOG_SD_CTAG "</sd>"
+/**
+ * System data is data from other parts of the system Couchbase interacts with over the network.
+ *
+ * - IP addresses
+ * - IP tables
+ * - Hosts names
+ * - Ports
+ * - DNS topology
+ */
+#define LCB_LOG_SD(instance, val)                                                                                      \
+    lcb_is_redacting_logs(instance) ? LCB_LOG_SD_OTAG : "", val, lcb_is_redacting_logs(instance) ? LCB_LOG_SD_CTAG : ""
 /**@}*/
 
 
@@ -559,6 +613,31 @@ typedef enum {
  * @see LCB_CNTL_SSL_MODE
  */
 #define LCB_CNTL_SSL_CERT 0x23
+
+/**
+ * @brief Get SSL private key path
+ *
+ * Retrieve the path to the private key (if any) being used.
+ * When key specified, the library will use it to authenticate on the services,
+ * skipping all other authentication mechanisms (SASL, HTTP Basic auth, etc)
+ *
+ * @cntl_arg_getonly{`char**`}
+ * @see LCB_CNTL_SSL_MODE
+ * @see https://developer.couchbase.com/documentation/server/5.0/security/security-certs-auth.html
+ */
+#define LCB_CNTL_SSL_KEY 0x4b
+
+/**
+ * @brief Get SSL trust store path
+ *
+ * Trust store might be NULL, in this case the library expects it to be concatenated with certificate.
+ *
+ * @cntl_arg_getonly{`char**`}
+ * @see LCB_CNTL_SSL_MODE
+ * @see https://developer.couchbase.com/documentation/server/5.0/security/security-certs-auth.html
+ */
+#define LCB_CNTL_SSL_TRUSTSTORE 0x4d
+
 /**
  * Alias for @ref LCB_CNTL_SSL_CERT for backward compatibility.
  * @deprecated
@@ -1022,11 +1101,32 @@ typedef const char *lcb_BUCKETCRED[2];
  */
 #define LCB_CNTL_SEND_HELLO 0x47
 
+/**
+ * Once redaction is enabled, anything at ERROR, WARN and INFO will wrap
+ * sensitive information with special tags, for further processing with the goal
+ * to remove or encrypt that information.  DEBUG or TRACE level logging are
+ * expected to have specific info.
+ *
+ * Use `log_redaction` in the connection string
+
+ * @cntl_arg_both{int* (as boolean)}
+ */
+#define LCB_CNTL_LOG_REDACTION 0x4c
+
+typedef enum {
+    LCBTRACE_THRESHOLD_KV = 0,
+    LCBTRACE_THRESHOLD_N1QL,
+    LCBTRACE_THRESHOLD_VIEW,
+    LCBTRACE_THRESHOLD_FTS,
+    LCBTRACE_THRESHOLD_ANALYTICS,
+    LCBTRACE_THRESHOLD__MAX
+} lcbtrace_THRESHOLDOPTS;
+
 /**
  * This is not a command, but rather an indicator of the last item.
  * @internal
  */
-#define LCB_CNTL__MAX                    0x49
+#define LCB_CNTL__MAX                    0x5b
 /**@}*/
 
 #ifdef __cplusplus

data/ext/libcouchbase/include/libcouchbase/configuration.h.in

@@ -20,4 +20,10 @@
 #define LCB_VERSION_STRING "@LCB_VERSION@"
 #define LCB_VERSION @LCB_VERSION_HEX@
 #define LCB_VERSION_CHANGESET "@LCB_VERSION_CHANGESET@"
+
+/*
+ * NOTE:
+ * This symbol might be removed in future releases once tracing will reach GA status.
+ */
+#cmakedefine LCB_TRACING
 #endif

data/ext/libcouchbase/include/libcouchbase/couchbase.h

@@ -55,6 +55,7 @@ typedef struct lcb_http_request_st *lcb_http_request_t;
 #include <libcouchbase/configuration.h>
 #include <libcouchbase/kvbuf.h>
 #include <libcouchbase/auth.h>
+#include <libcouchbase/tracing.h>
 #include <libcouchbase/_cxxwrap.h>
 
 #ifdef __cplusplus
@@ -170,10 +171,22 @@ typedef lcb_U32 lcb_USECS;
  *   over the memcached port (For clusters 2.5 and above), or `all` to try with
  *   _cccp_ and revert to _http_
  *
+ * * `truststorepath` - Specify the path (on the local filesystem) to the server's
+ *   SSL certificate truststore. Only applicable if SSL is being used (i.e. the
+ *   scheme is `couchbases`). The trust store is optional, and when missing,
+ *   the library will use `certpath` as location for verification, and expect
+ *   any extra certificates to be concatenated in there.
+ *
  * * `certpath` - Specify the path (on the local filesystem) to the server's
  *   SSL certificate. Only applicable if SSL is being used (i.e. the scheme is
  *   `couchbases`)
  *
+ * * `keypath` - Specify the path (on the local filesystem) to the client
+ *   SSL private key. Only applicable if SSL client certificate authentication
+ *   is being used (i.e. the scheme is `couchbases` and `certpath` contains
+ *   client certificate). Read more in the server documentation:
+ *   https://developer.couchbase.com/documentation/server/5.0/security/security-certs-auth.html
+ *
  * ### Bucket Identification and Credentials
  *
  * The most common settings you will wish to modify are the bucket name
@@ -692,6 +705,7 @@ typedef enum {
     LCB_CALLBACK_SDMUTATE,
     LCB_CALLBACK_NOOP, /**< lcb_noop3() */
     LCB_CALLBACK_PING, /**< lcb_ping3() */
+    LCB_CALLBACK_DIAG, /**< lcb_diag() */
     LCB_CALLBACK__MAX /* Number of callbacks */
 } lcb_CALLBACKTYPE;
 
@@ -1329,6 +1343,16 @@ typedef struct lcb_MULTICMD_CTX_st {
      * @param ctx
      */
     void (*fail)(struct lcb_MULTICMD_CTX_st *ctx);
+
+#ifdef LCB_TRACING
+    /**
+     * Associate parent tracing span with the group operation
+     *
+     * @param ctx The multi context
+     * @param span Parent span
+     */
+    void (*setspan)(struct lcb_MULTICMD_CTX_st *ctx, lcbtrace_SPAN *span);
+#endif
 } lcb_MULTICMD_CTX;
 /**@}*/
 
@@ -2323,7 +2347,7 @@ typedef lcb_CMDBASE lcb_CMDCBFLUSH;
 typedef lcb_RESPBASE lcb_RESPCBFLUSH;
 
 /**
- * @uncomitted
+ * @uncommitted
  *
  * Flush a bucket
  * This function will properly flush any type of bucket using the REST API
@@ -2449,6 +2473,7 @@ typedef struct {
     LCB_CMD_BASE;
     int services; /**< bitmap for services to ping */
     int options; /**< extra options, e.g. for result representation */
+    const char *id; /**< optional, zero-terminated string to identify the report */
 } lcb_CMDPING;
 
 /**
@@ -2464,6 +2489,18 @@ typedef enum {
     LCB_PINGSVC__MAX
 } lcb_PINGSVCTYPE;
 
+/**
+ * Status of the service
+ *
+ * @uncommitted
+ */
+typedef enum {
+    LCB_PINGSTATUS_OK = 0,
+    LCB_PINGSTATUS_TIMEOUT,
+    LCB_PINGSTATUS_ERROR,
+    LCB_PINGSTATUS__MAX
+} lcb_PINGSTATUS;
+
 /**
  * Entry describing the status of the service in the cluster.
  * It is part of lcb_RESPING structure.
@@ -2472,9 +2509,14 @@ typedef enum {
  */
 typedef struct {
     lcb_PINGSVCTYPE type; /**< type of the service */
-    char *server; /**< server host:port */
+    /* TODO: rename to "remote" */
+    const char *server; /**< server host:port */
     lcb_U64 latency; /**< latency in nanoseconds */
-    lcb_error_t status; /**< status of the operation */
+    lcb_error_t rc; /**< raw return code of the operation */
+    const char *local; /**< server host:port */
+    const char *id; /**< service identifier (unique in scope of lcb_t connection instance) */
+    const char *scope; /**< optional scope name (typically equals to the bucket name) */
+    lcb_PINGSTATUS status; /**< status of the operation */
 } lcb_PINGSVC;
 
 /**
@@ -2532,6 +2574,54 @@ typedef struct {
 LIBCOUCHBASE_API
 lcb_error_t
 lcb_ping3(lcb_t instance, const void *cookie, const lcb_CMDPING *cmd);
+
+typedef struct {
+    LCB_CMD_BASE;
+    int options;  /**< extra options, e.g. for result representation */
+    const char *id; /**< optional, zero-terminated string to identify the report */
+} lcb_CMDDIAG;
+
+typedef struct {
+    LCB_RESP_BASE
+    lcb_SIZE njson;   /**< length of JSON string (when #LCB_PINGOPT_F_JSON was specified) */
+    const char *json; /**< pointer to JSON string */
+} lcb_RESPDIAG;
+
+/**
+ * @brief Returns diagnostics report about network connections.
+ *
+ * @uncommitted
+ *
+ * @par Request
+ * @code{.c}
+ * lcb_CMDDIAG cmd = { 0 };
+ * lcb_diag(instance, fp, &cmd);
+ * lcb_wait(instance);
+ * @endcode
+ *
+ * @par Response
+ * @code{.c}
+ * lcb_install_callback3(instance, LCB_CALLBACK_DIAG, diag_callback);
+ * void diag_callback(lcb_t, int, const lcb_RESPBASE *rb)
+ * {
+ *     const lcb_RESPDIAG *resp = (const lcb_RESPDIAG *)rb;
+ *     if (resp->rc != LCB_SUCCESS) {
+ *         fprintf(stderr, "failed: %s\n", lcb_strerror(NULL, resp->rc));
+ *     } else {
+ *         if (resp->njson) {
+ *             fprintf(stderr, "\n%.*s", (int)resp->njson, resp->json);
+ *         }
+ *     }
+ * }
+ * @endcode
+ *
+ * @param instance the library handle
+ * @param cookie the cookie passed in the callback
+ * @param cmd command structure.
+ * @return status code for scheduling.
+ */
+LIBCOUCHBASE_API
+lcb_error_t lcb_diag(lcb_t instance, const void *cookie, const lcb_CMDDIAG *cmd);
 /**@} (Group: PING) */
 
 /**@ingroup lcb-public-api
@@ -2955,7 +3045,7 @@ void lcb_breakout(lcb_t instance);
  * @brief Check if instance is blocked in the event loop
  * @param instance the instance to run the event loop for.
  * @return non-zero if nobody is waiting for IO interaction
- * @uncomitted
+ * @uncommitted
  */
 LIBCOUCHBASE_API
 int lcb_is_waiting(lcb_t instance);
@@ -3240,7 +3330,7 @@ void lcb_destroy_async(lcb_t instance, const void *arg);
 #define LCB_DATATYPE_JSON 0x01
 
 /** @internal */
-typedef enum { LCB_VALUE_RAW = 0x00, LCB_VALUE_F_JSON = 0x01, LCB_VALUE_F_SNAPPYCOMP } lcb_VALUEFLAGS;
+typedef enum { LCB_VALUE_RAW = 0x00, LCB_VALUE_F_JSON = 0x01, LCB_VALUE_F_SNAPPYCOMP = 0x02 } lcb_VALUEFLAGS;
 
 
 /**
@@ -3477,7 +3567,6 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags);
 LIBCOUCHBASE_API
 lcb_error_t lcb_cntl(lcb_t instance, int mode, int cmd, void *arg);
 
-
 /**
  * Alternatively one may change configuration settings by passing a string key
  * and value. This may be used to provide a simple interface from a command
@@ -3532,6 +3621,7 @@ lcb_error_t lcb_cntl(lcb_t instance, int mode, int cmd, void *arg);
  * |@ref LCB_CNTL_CLIENT_STRING              | `"client_string"`         | String            |
  * |@ref LCB_CNTL_TCP_KEEPALIVE              | `"tcp_keepalive"`         | Boolean           |
  * |@ref LCB_CNTL_CONFIG_POLL_INTERVAL       | `"config_poll_interval"`  | Timeval           |
+ * |@ref LCB_CNTL_IP6POLICY                  | `"ipv6"`                  | String ("disabled", "only", "allow") |
  *
  * @committed - Note, the actual API call is considered committed and will
  * not disappear, however the existence of the various string settings are
@@ -3791,6 +3881,8 @@ const lcb_U32 lcb_version_g;
 #define LCB_SUPPORTS_SSL 1
 /**@brief Whether the library has experimental compression support */
 #define LCB_SUPPORTS_SNAPPY 2
+/**@brief Whether the library has experimental tracing support */
+#define LCB_SUPPORTS_TRACING 3
 
 /**
  * @committed
@@ -3845,6 +3937,8 @@ typedef enum {
     LCB_DUMP_PKTINFO = 0x02,
     /** Dump memory usage/reservation information about buffers */
     LCB_DUMP_BUFINFO = 0x04,
+    /** Dump various metrics information */
+    LCB_DUMP_METRICS = 0x08,
     /** Dump everything */
     LCB_DUMP_ALL = 0xff
 } lcb_DUMPFLAGS;
@@ -3938,6 +4032,15 @@ LIBCOUCHBASE_API
 const char *
 lcb_resp_get_error_ref(int cbtype, const lcb_RESPBASE *rb);
 
+/**
+ * @volatile
+ * Returns whether the library redacting logs for this connection instance.
+ *
+ * @return non-zero if the logs are being redacted for this instance.
+ */
+LIBCOUCHBASE_API
+int lcb_is_redacting_logs(lcb_t instance);
+
 /* Post-include some other headers */
 #ifdef __cplusplus
 }

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

@@ -0,0 +1,140 @@
+/* -*- 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
+
+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;
+
+typedef struct lcbcrypto_SIGV {
+    const uint8_t *data;
+    size_t len;
+} lcbcrypto_SIGV;
+
+struct lcbcrypto_PROVIDER;
+typedef struct lcbcrypto_PROVIDER {
+    uint16_t version;
+    int16_t _refcnt;
+    uint64_t flags;
+    void *cookie;
+    void (*destructor)(struct lcbcrypto_PROVIDER *provider);
+    union {
+        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;
+    } v;
+} lcbcrypto_PROVIDER;
+
+typedef struct lcbcrypto_FIELDSPEC {
+    const char *name;
+    const char *alg;
+    const char *kid;
+} lcbcrypto_FIELDSPEC;
+
+typedef struct lcbcrypto_CMDENCRYPT {
+    uint16_t version;
+    const char *prefix;
+    const char *doc;
+    size_t ndoc;
+    char *out;
+    size_t nout;
+    lcbcrypto_FIELDSPEC *fields;
+    size_t nfields;
+} lcbcrypto_CMDENCRYPT;
+
+typedef struct lcbcrypto_CMDDECRYPT {
+    uint16_t version;
+    const char *prefix;
+    const char *doc;
+    size_t ndoc;
+    char *out;
+    size_t nout;
+} lcbcrypto_CMDDECRYPT;
+
+/**
+ * @uncommitted
+ */
+LIBCOUCHBASE_API void lcbcrypto_register(lcb_t instance, const char *name, lcbcrypto_PROVIDER *provider);
+
+/**
+ * @uncommitted
+ */
+LIBCOUCHBASE_API void lcbcrypto_unregister(lcb_t instance, const char *name);
+
+/**
+ * @uncommitted
+ */
+LIBCOUCHBASE_API void lcbcrypto_ref(lcbcrypto_PROVIDER *provider);
+
+/**
+ * @uncommitted
+ */
+LIBCOUCHBASE_API void lcbcrypto_unref(lcbcrypto_PROVIDER *provider);
+
+/**
+ * @uncommitted
+ *
+ * encrypt and replace fields specified by JSON paths (zero-terminated) with encrypted contents
+ */
+LIBCOUCHBASE_API lcb_error_t lcbcrypto_encrypt_fields(lcb_t instance, lcbcrypto_CMDENCRYPT *cmd);
+
+/**
+ * @uncommitted
+ *
+ * find and decrypt all fields in the JSON encoded object
+ */
+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 */