libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/example/crypto/openssl_symmetric_provider.c

@@ -0,0 +1,281 @@
+/* -*- 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.
+ */
+
+/**
+ * This is an example of using crypto API of libcouchbase. The implementation should not be considered as production
+ * ready, because it uses hardcoded keys, insecure memory allocation, copying and comparison. Consult documentation of
+ * your crypto library on how to properly work with keys and buffers.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "openssl_symmetric_provider.h"
+
+#include <openssl/ssl.h>
+#include <openssl/conf.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>
+
+static void osp_free(lcbcrypto_PROVIDER *provider)
+{
+    free(provider);
+}
+
+static void osp_release_bytes(lcbcrypto_PROVIDER *provider, void *bytes)
+{
+    free(bytes);
+    (void)provider;
+}
+
+static lcb_error_t osp_load_key(struct lcbcrypto_PROVIDER *provider, lcbcrypto_KEYTYPE type, const char *keyid,
+                                uint8_t **key, size_t *key_len)
+{
+    *key_len = AES256_KEY_SIZE;
+    *key = malloc(*key_len);
+    memcpy(*key, common_aes256_key, *key_len);
+
+    (void)type;
+    (void)keyid;
+    (void)provider;
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t osp_generate_iv(struct lcbcrypto_PROVIDER *provider, uint8_t **iv, size_t *iv_len)
+{
+    *iv_len = AES256_IV_SIZE;
+    *iv = malloc(*iv_len);
+    memcpy(*iv, common_aes256_iv, *iv_len);
+
+    (void)provider;
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t osp_sign(struct lcbcrypto_PROVIDER *provider, const lcbcrypto_SIGV *inputs, size_t inputs_num,
+                            uint8_t **sig, size_t *sig_len)
+{
+    const EVP_MD *md;
+    uint8_t out[EVP_MAX_MD_SIZE];
+    size_t out_len = EVP_MAX_MD_SIZE;
+    int rc, key_len = strlen((const char *)common_hmac_sha256_key);
+    EVP_MD_CTX *ctx = NULL;
+    EVP_PKEY *key = NULL;
+    size_t ii;
+
+    md = EVP_get_digestbyname("SHA256");
+    if (md == NULL) {
+        return LCB_EINVAL;
+    }
+
+    key = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, common_hmac_sha256_key, key_len);
+    if (key == NULL) {
+        return LCB_EINVAL;
+    }
+
+    ctx = EVP_MD_CTX_new();
+    if (ctx == NULL) {
+        EVP_PKEY_free(key);
+        return LCB_EINVAL;
+    }
+    rc = EVP_DigestSignInit(ctx, NULL, md, NULL, key);
+    if (rc != 1) {
+        EVP_PKEY_free(key);
+        return LCB_EINVAL;
+    }
+
+    for (ii = 0; ii < inputs_num; ii++) {
+        rc = EVP_DigestSignUpdate(ctx, inputs[ii].data, inputs[ii].len);
+        if (rc != 1) {
+            EVP_PKEY_free(key);
+            EVP_MD_CTX_destroy(ctx);
+            return LCB_EINVAL;
+        }
+    }
+    rc = EVP_DigestSignFinal(ctx, out, &out_len);
+    if (rc != 1 || out_len == 0) {
+        EVP_PKEY_free(key);
+        EVP_MD_CTX_destroy(ctx);
+        return LCB_EINVAL;
+    }
+    *sig = malloc(out_len);
+    memcpy(*sig, out, out_len);
+    *sig_len = out_len;
+
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t osp_verify_signature(struct lcbcrypto_PROVIDER *provider, const lcbcrypto_SIGV *inputs,
+                                        size_t inputs_num, uint8_t *sig, size_t sig_len)
+{
+    const EVP_MD *md;
+    uint8_t actual[EVP_MAX_MD_SIZE];
+    size_t actual_len = EVP_MAX_MD_SIZE;
+    int rc, key_len = strlen((const char *)common_hmac_sha256_key);
+    EVP_MD_CTX *ctx = NULL;
+    EVP_PKEY *key = NULL;
+    size_t ii;
+
+    md = EVP_get_digestbyname("SHA256");
+    if (md == NULL) {
+        return LCB_EINVAL;
+    }
+    key = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, common_hmac_sha256_key, key_len);
+    if (key == NULL) {
+        return LCB_EINVAL;
+    }
+
+    ctx = EVP_MD_CTX_new();
+    if (ctx == NULL) {
+        EVP_PKEY_free(key);
+        return LCB_EINVAL;
+    }
+    rc = EVP_DigestSignInit(ctx, NULL, md, NULL, key);
+    if (rc != 1) {
+        EVP_PKEY_free(key);
+        return LCB_EINVAL;
+    }
+
+    for (ii = 0; ii < inputs_num; ii++) {
+        rc = EVP_DigestSignUpdate(ctx, inputs[ii].data, inputs[ii].len);
+        if (rc != 1) {
+            EVP_PKEY_free(key);
+            EVP_MD_CTX_destroy(ctx);
+            return LCB_EINVAL;
+        }
+    }
+    rc = EVP_DigestSignFinal(ctx, actual, &actual_len);
+    if (rc != 1 || actual_len == 0) {
+        EVP_PKEY_free(key);
+        EVP_MD_CTX_destroy(ctx);
+        return LCB_EINVAL;
+    }
+
+    if (memcmp(actual, sig, sig_len < actual_len ? sig_len : actual_len) == 0) {
+        return LCB_SUCCESS;
+    }
+    return LCB_EINVAL;
+}
+
+static lcb_error_t osp_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)
+{
+    EVP_CIPHER_CTX *ctx;
+    const EVP_CIPHER *cipher;
+    int rc, len, block_len, out_len;
+    uint8_t *out;
+
+    if (iv_len != 16 || key_len != 32) {
+        return LCB_EINVAL;
+    }
+
+    ctx = EVP_CIPHER_CTX_new();
+    if (!ctx) {
+        return LCB_EINVAL;
+    }
+    cipher = EVP_aes_256_cbc();
+    rc = EVP_EncryptInit_ex(ctx, cipher, NULL, key, iv);
+    if (rc != 1) {
+        EVP_CIPHER_CTX_free(ctx);
+        return LCB_EINVAL;
+    }
+    block_len = EVP_CIPHER_block_size(cipher);
+    out = calloc(input_len + block_len - 1, sizeof(uint8_t));
+    rc = EVP_EncryptUpdate(ctx, out, &len, input, input_len);
+    if (rc != 1) {
+        free(out);
+        EVP_CIPHER_CTX_free(ctx);
+        return LCB_EINVAL;
+    }
+    out_len = len;
+    rc = EVP_EncryptFinal_ex(ctx, out + len, &len);
+    if (rc != 1) {
+        free(out);
+        EVP_CIPHER_CTX_free(ctx);
+        return LCB_EINVAL;
+    }
+    out_len += len;
+    EVP_CIPHER_CTX_free(ctx);
+    *output = out;
+    *output_len = out_len;
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t osp_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)
+{
+    EVP_CIPHER_CTX *ctx;
+    const EVP_CIPHER *cipher;
+    int rc, len, out_len;
+    uint8_t *out;
+
+    if (iv_len != 16 || key_len != 32) {
+        return LCB_EINVAL;
+    }
+
+    ctx = EVP_CIPHER_CTX_new();
+    if (!ctx) {
+        return LCB_EINVAL;
+    }
+    cipher = EVP_aes_256_cbc();
+    rc = EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv);
+    if (rc != 1) {
+        EVP_CIPHER_CTX_free(ctx);
+        return LCB_EINVAL;
+    }
+    out = calloc(input_len, sizeof(uint8_t));
+    rc = EVP_DecryptUpdate(ctx, out, &len, input, input_len);
+    if (rc != 1) {
+        free(out);
+        EVP_CIPHER_CTX_free(ctx);
+        return LCB_EINVAL;
+    }
+    out_len = len;
+    rc = EVP_DecryptFinal_ex(ctx, out + len, &len);
+    if (rc != 1) {
+        free(out);
+        EVP_CIPHER_CTX_free(ctx);
+        return LCB_EINVAL;
+    }
+    out_len += len;
+    EVP_CIPHER_CTX_free(ctx);
+    *output = out;
+    *output_len = out_len;
+    return LCB_SUCCESS;
+}
+
+lcbcrypto_PROVIDER *osp_create()
+{
+    lcbcrypto_PROVIDER *provider = calloc(1, sizeof(lcbcrypto_PROVIDER));
+    provider->version = 0;
+    provider->destructor = osp_free;
+    provider->v.v0.release_bytes = osp_release_bytes;
+    provider->v.v0.load_key = osp_load_key;
+    provider->v.v0.generate_iv = osp_generate_iv;
+    provider->v.v0.sign = osp_sign;
+    provider->v.v0.verify_signature = osp_verify_signature;
+    provider->v.v0.encrypt = osp_encrypt;
+    provider->v.v0.decrypt = osp_decrypt;
+    return provider;
+}
+
+void osp_initialize()
+{
+    SSL_library_init();
+    SSL_load_error_strings();
+    EVP_add_cipher(EVP_aes_256_cbc());
+}

data/ext/libcouchbase/example/crypto/openssl_symmetric_provider.h

@@ -0,0 +1,29 @@
+/* -*- 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 _OPENSSL_SYMMETRIC_PROVIDER_H
+#define _OPENSSL_SYMMETRIC_PROVIDER_H
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/crypto.h>
+
+#include "common_provider.h"
+
+void osp_initialize();
+lcbcrypto_PROVIDER *osp_create();
+
+#endif

data/ext/libcouchbase/example/tracing/.gitignore

@@ -0,0 +1,2 @@
+tracing
+views

data/ext/libcouchbase/example/tracing/Makefile

@@ -0,0 +1,8 @@
+LDFLAGS=-lcouchbase -lm
+CFLAGS=-g
+
+all: tracing views
+
+tracing: tracing.c cJSON.c
+
+views: views.c cJSON.c

data/ext/libcouchbase/example/tracing/cJSON.c

@@ -0,0 +1 @@
+ext/libcouchbase/example/tracing/../../contrib/cJSON/cJSON.c

data/ext/libcouchbase/example/tracing/cJSON.h

@@ -0,0 +1 @@
+ext/libcouchbase/example/tracing/../../contrib/cJSON/cJSON.h

data/ext/libcouchbase/example/tracing/tracing.c

@@ -0,0 +1,439 @@
+/* -*- 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.
+ */
+
+/**
+ * @file
+ *
+ * This is a minimal example file showing how to connect to a cluster and
+ * set and retrieve a single item. This is copy of minimal.c, but with
+ * tracing enabled.
+ *
+ *   docker run -d -p 9411:9411 openzipkin/zipkin
+ *   make
+ *   ./tracing couchbase://localhost password Administrator
+ *
+ *  open browser at http://localhost:9411
+ */
+
+#include <stdio.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h> /* strlen */
+#ifdef _WIN32
+#define PRIx64 "I64x"
+#define PRId64 "I64d"
+#else
+#include <inttypes.h>
+#endif
+
+#include <netdb.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+
+#include "cJSON.h"
+
+#define COMPONENT_NAME "demo"
+
+struct zipkin_payload;
+typedef struct zipkin_payload {
+    char *data;
+    struct zipkin_payload *next;
+} zipkin_payload;
+
+typedef struct zipkin_state {
+    char *json_api_host;
+    char *json_api_port;
+    /* [0, 100], where 0 is "never", 100 is "always" */
+    int sample_rate;
+    zipkin_payload *root;
+    zipkin_payload *last;
+    size_t content_length;
+} zipkin_state;
+
+void zipkin_destructor(lcbtrace_TRACER *tracer)
+{
+    if (tracer) {
+        if (tracer->cookie) {
+            free(tracer->cookie);
+            tracer->cookie = NULL;
+        }
+        free(tracer);
+    }
+}
+
+void zipkin_report(lcbtrace_TRACER *tracer, lcbtrace_SPAN *span)
+{
+    zipkin_state *state = NULL;
+
+    if (tracer == NULL) {
+        return;
+    }
+    state = tracer->cookie;
+    if (state == NULL) {
+        return;
+    }
+    if (rand() % 100 > state->sample_rate) {
+        return;
+    }
+
+    {
+#define BUFSZ 1000
+        size_t nbuf = BUFSZ;
+        char *buf;
+        lcbtrace_SPAN *parent;
+        uint64_t start;
+        zipkin_payload *payload = calloc(1, sizeof(zipkin_payload));
+        cJSON *json = cJSON_CreateObject();
+
+        buf = calloc(nbuf, sizeof(char));
+        cJSON_AddItemToObject(json, "name", cJSON_CreateString(lcbtrace_span_get_operation(span)));
+        snprintf(buf, nbuf, "%" PRIx64, lcbtrace_span_get_span_id(span));
+        cJSON_AddItemToObject(json, "id", cJSON_CreateString(buf));
+        snprintf(buf, nbuf, "%" PRIx64, lcbtrace_span_get_trace_id(span));
+        cJSON_AddItemToObject(json, "traceId", cJSON_CreateString(buf));
+        parent = lcbtrace_span_get_parent(span);
+        if (parent) {
+            snprintf(buf, nbuf, "%" PRIx64, lcbtrace_span_get_trace_id(parent));
+            cJSON_AddItemToObject(json, "parentId", cJSON_CreateString(buf));
+        }
+        start = lcbtrace_span_get_start_ts(span);
+        cJSON_AddItemToObject(json, "timestamp", cJSON_CreateNumber(start));
+        cJSON_AddItemToObject(json, "duration", cJSON_CreateNumber(lcbtrace_span_get_finish_ts(span) - start));
+
+        {
+            cJSON *endpoint = cJSON_CreateObject();
+
+            nbuf = BUFSZ;
+            if (lcbtrace_span_get_tag_str(span, LCBTRACE_TAG_DB_TYPE, &buf, &nbuf) == LCB_SUCCESS) {
+                buf[nbuf] = '\0';
+                cJSON_AddItemToObject(endpoint, "serviceName", cJSON_CreateString(buf));
+            }
+            cJSON_AddItemToObject(json, "localEndpoint", endpoint);
+        }
+
+        {
+            cJSON *tags = cJSON_CreateObject();
+            uint64_t latency, operation_id;
+            if (lcbtrace_span_get_tag_uint64(span, LCBTRACE_TAG_PEER_LATENCY, &latency) == LCB_SUCCESS) {
+                cJSON_AddItemToObject(tags, LCBTRACE_TAG_PEER_LATENCY, cJSON_CreateNumber(latency));
+            }
+            if (lcbtrace_span_get_tag_uint64(span, LCBTRACE_TAG_OPERATION_ID, &operation_id) == LCB_SUCCESS) {
+                cJSON_AddItemToObject(tags, LCBTRACE_TAG_OPERATION_ID, cJSON_CreateNumber(operation_id));
+            }
+            nbuf = BUFSZ;
+            if (lcbtrace_span_get_tag_str(span, LCBTRACE_TAG_COMPONENT, &buf, &nbuf) == LCB_SUCCESS) {
+                buf[nbuf] = '\0';
+                cJSON_AddItemToObject(tags, LCBTRACE_TAG_COMPONENT, cJSON_CreateString(buf));
+            }
+            nbuf = BUFSZ;
+            if (lcbtrace_span_get_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, &buf, &nbuf) == LCB_SUCCESS) {
+                buf[nbuf] = '\0';
+                cJSON_AddItemToObject(tags, LCBTRACE_TAG_PEER_ADDRESS, cJSON_CreateString(buf));
+            }
+            nbuf = BUFSZ;
+            if (lcbtrace_span_get_tag_str(span, LCBTRACE_TAG_LOCAL_ADDRESS, &buf, &nbuf) == LCB_SUCCESS) {
+                buf[nbuf] = '\0';
+                cJSON_AddItemToObject(tags, LCBTRACE_TAG_LOCAL_ADDRESS, cJSON_CreateString(buf));
+            }
+            nbuf = BUFSZ;
+            if (lcbtrace_span_get_tag_str(span, LCBTRACE_TAG_DB_INSTANCE, &buf, &nbuf) == LCB_SUCCESS) {
+                buf[nbuf] = '\0';
+                cJSON_AddItemToObject(tags, LCBTRACE_TAG_DB_INSTANCE, cJSON_CreateString(buf));
+            }
+            if (cJSON_GetArraySize(tags) > 0) {
+                cJSON_AddItemToObject(json, "tags", tags);
+            } else {
+                cJSON_Delete(tags);
+            }
+        }
+        free(buf);
+
+        payload->data = cJSON_PrintUnformatted(json);
+        cJSON_Delete(json);
+        if (state->last) {
+            state->last->next = payload;
+        }
+        state->last = payload;
+        state->content_length += strlen(payload->data) + 1; /* for comma/closing bracket */
+        if (state->root == NULL) {
+            state->root = payload;
+        }
+    }
+}
+
+void loop_send(int sock, char *bytes, ssize_t nbytes)
+{
+    do {
+        ssize_t rv = send(sock, bytes, nbytes, 0);
+        if (rv < 0) {
+            perror("failed to send data to zipkin: ");
+            exit(EXIT_FAILURE);
+        } else if (rv < nbytes) {
+            nbytes -= rv;
+            bytes += rv;
+            continue;
+        }
+        break;
+    } while (1);
+}
+
+void zipkin_flush(lcbtrace_TRACER *tracer)
+{
+    zipkin_state *state = NULL;
+    int sock, rv;
+
+    if (tracer == NULL) {
+        return;
+    }
+    state = tracer->cookie;
+    if (state == NULL) {
+        return;
+    }
+    if (state->root == NULL || state->content_length == 0) {
+        return;
+    }
+    {
+        struct addrinfo hints, *addr, *a;
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        rv = getaddrinfo(state->json_api_host, state->json_api_port, &hints, &addr);
+        if (rv != 0) {
+            fprintf(stderr, "failed to resolve zipkin address getaddrinfo: %s\n", gai_strerror(rv));
+            exit(EXIT_FAILURE);
+        }
+        for (a = addr; a != NULL; a = a->ai_next) {
+            sock = socket(a->ai_family, a->ai_socktype, a->ai_protocol);
+            if (sock == -1) {
+                perror("failed to create socket for zipkin: ");
+                continue;
+            }
+            rv = connect(sock, a->ai_addr, a->ai_addrlen);
+            if (rv == -1) {
+                perror("failed to connect socket for zipkin: ");
+                continue;
+            }
+            break;
+        }
+        if (a == NULL) {
+            fprintf(stderr, "unable to connect to zipkin. terminating\n");
+            exit(EXIT_FAILURE);
+        }
+        freeaddrinfo(addr);
+    }
+    {
+        char preamble[1000] = "";
+        size_t size;
+
+        snprintf(preamble, sizeof(preamble),
+                 "POST /api/v2/spans HTTP/1.1\r\n"
+                 "Content-Type: application/json\r\n"
+                 "Accept: */*\r\n"
+                 "Connection: close\r\n"
+                 "Host: %s:%s\r\n"
+                 "Content-Length: %ld\r\n\r\n",
+                 state->json_api_host, state->json_api_port, (long)state->content_length + 1 /* for open bracket */);
+        size = strlen(preamble);
+
+        rv = send(sock, preamble, size, 0);
+        if (rv == -1) {
+            perror("failed to send HTTP headers to zipkin: ");
+            exit(EXIT_FAILURE);
+        }
+    }
+    {
+        zipkin_payload *ptr = state->root;
+        loop_send(sock, "[", 1);
+        while (ptr) {
+            zipkin_payload *tmp = ptr;
+            loop_send(sock, ptr->data, strlen(ptr->data));
+            ptr = ptr->next;
+            if (ptr) {
+                loop_send(sock, ",", 1);
+            }
+            free(tmp->data);
+            free(tmp);
+        }
+        loop_send(sock, "]", 1);
+    }
+    close(sock);
+    state->root = state->last = NULL;
+    state->content_length = 0;
+}
+
+lcbtrace_TRACER *zipkin_new()
+{
+    lcbtrace_TRACER *tracer = calloc(1, sizeof(lcbtrace_TRACER));
+    zipkin_state *zipkin = calloc(1, sizeof(zipkin_state));
+    tracer->destructor = zipkin_destructor;
+    tracer->flags = 0;
+    tracer->version = 0;
+    tracer->v.v0.report = zipkin_report;
+    zipkin->json_api_host = "localhost";
+    zipkin->json_api_port = "9411";
+    zipkin->sample_rate = 100;
+    zipkin->root = NULL;
+    zipkin->last = NULL;
+    zipkin->content_length = 0;
+    tracer->cookie = zipkin;
+    return tracer;
+}
+
+static void die(lcb_t instance, const char *msg, lcb_error_t err)
+{
+    fprintf(stderr, "%s. Received code 0x%X (%s)\n", msg, err, lcb_strerror(instance, err));
+    exit(EXIT_FAILURE);
+}
+
+static void op_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    fprintf(stderr, "=== %s ===\n", lcb_strcbtype(cbtype));
+    if (rb->rc == LCB_SUCCESS) {
+        fprintf(stderr, "KEY: %.*s\n", (int)rb->nkey, rb->key);
+        fprintf(stderr, "CAS: 0x%" PRIx64 "\n", rb->cas);
+        if (cbtype == LCB_CALLBACK_GET) {
+            const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
+            fprintf(stderr, "VALUE: %.*s\n", (int)rg->nvalue, rg->value);
+            fprintf(stderr, "FLAGS: 0x%x\n", rg->itmflags);
+        }
+    } else {
+        die(instance, lcb_strcbtype(cbtype), rb->rc);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_error_t err;
+    lcb_t instance;
+    struct lcb_create_st create_options = {0};
+    lcb_CMDSTORE scmd = {0};
+    lcb_CMDGET gcmd = {0};
+    lcbtrace_SPAN *span = NULL;
+    lcbtrace_TRACER *tracer = NULL;
+
+    create_options.version = 3;
+
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s couchbase://host/bucket [ password [ username ] ]\n", argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    create_options.v.v3.connstr = argv[1];
+    if (argc > 2) {
+        create_options.v.v3.passwd = argv[2];
+    }
+    if (argc > 3) {
+        create_options.v.v3.username = argv[3];
+    }
+
+    srand(time(NULL));
+
+    err = lcb_create(&instance, &create_options);
+    if (err != LCB_SUCCESS) {
+        die(NULL, "Couldn't create couchbase handle", err);
+    }
+
+    err = lcb_connect(instance);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't schedule connection", err);
+    }
+
+    lcb_wait(instance);
+
+    err = lcb_get_bootstrap_status(instance);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't bootstrap from cluster", err);
+    }
+
+    /* Assign the handlers to be called for the operation types */
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, op_callback);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, op_callback);
+
+    tracer = zipkin_new();
+
+    lcb_set_tracer(instance, tracer);
+
+    span = lcbtrace_span_start(tracer, "transaction", 0, NULL);
+    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_COMPONENT, COMPONENT_NAME);
+
+    {
+        int encoding_time_us = rand() % 1000;
+        lcbtrace_SPAN *encoding;
+        lcbtrace_REF ref;
+
+        ref.type = LCBTRACE_REF_CHILD_OF;
+        ref.span = span;
+
+        encoding = lcbtrace_span_start(tracer, LCBTRACE_OP_REQUEST_ENCODING, 0, &ref);
+        lcbtrace_span_add_tag_str(encoding, LCBTRACE_TAG_COMPONENT, COMPONENT_NAME);
+        usleep(encoding_time_us);
+        lcbtrace_span_finish(encoding, LCBTRACE_NOW);
+    }
+
+    LCB_CMD_SET_TRACESPAN(&scmd, span);
+    LCB_CMD_SET_KEY(&scmd, "key", strlen("key"));
+    LCB_CMD_SET_VALUE(&scmd, "value", strlen("value"));
+    scmd.operation = LCB_SET;
+    err = lcb_store3(instance, NULL, &scmd);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't schedule storage operation", err);
+    }
+
+    /* The store_callback is invoked from lcb_wait() */
+    fprintf(stderr, "Will wait for storage operation to complete..\n");
+    lcb_wait(instance);
+
+    /* Now fetch the item back */
+    LCB_CMD_SET_TRACESPAN(&gcmd, span);
+    LCB_CMD_SET_KEY(&gcmd, "key", strlen("key"));
+    err = lcb_get3(instance, NULL, &gcmd);
+    if (err != LCB_SUCCESS) {
+        die(instance, "Couldn't schedule retrieval operation", err);
+    }
+
+    /* Likewise, the get_callback is invoked from here */
+    fprintf(stderr, "Will wait to retrieve item..\n");
+    lcb_wait(instance);
+
+    {
+        int decoding_time_us = rand() % 1000;
+        lcbtrace_SPAN *decoding;
+        lcbtrace_REF ref;
+
+        ref.type = LCBTRACE_REF_CHILD_OF;
+        ref.span = span;
+
+        decoding = lcbtrace_span_start(tracer, LCBTRACE_OP_RESPONSE_DECODING, 0, &ref);
+        lcbtrace_span_add_tag_str(decoding, LCBTRACE_TAG_COMPONENT, COMPONENT_NAME);
+        usleep(decoding_time_us);
+        lcbtrace_span_finish(decoding, LCBTRACE_NOW);
+    }
+
+    lcbtrace_span_finish(span, LCBTRACE_NOW);
+
+    zipkin_flush(tracer);
+
+    /* Now that we're all done, close down the connection handle */
+    lcb_destroy(instance);
+
+    return 0;
+}