libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/src/rdb/bigalloc.c

@@ -212,7 +212,7 @@ rdb_bigalloc_dump(rdb_BIGALLOC *alloc, FILE *fp)
 {
     static const char *indent = "  ";
     fprintf(fp, "BIGALLOC @%p\n", (void *)alloc);
-    fprintf(fp, "%sPooled Blocks: %lu\n", indent, LCB_CLIST_SIZE(&alloc->bufs));
+    fprintf(fp, "%sPooled Blocks: %lu\n", indent, (unsigned long int)LCB_CLIST_SIZE(&alloc->bufs));
     fprintf(fp, "%sMinAlloc: %u\n", indent, alloc->min_blk_alloc);
     fprintf(fp, "%sMaxAlloc: %u\n", indent, alloc->max_blk_alloc);
     fprintf(fp, "%sMaxBlocks: %u\n", indent, alloc->max_blk_count);

data/ext/libcouchbase/src/retryq.cc

@@ -195,8 +195,8 @@ RetryQueue::schedule(hrtime_t now)
         diff = selected - now;
     }
 
-    uint32_t us_interval = LCB_NS2US(diff);
-    lcb_log(LOGARGS(this, TRACE), "Next tick in %u ms", (unsigned)us_interval/1000);
+    uint64_t us_interval = LCB_NS2US(diff);
+    lcb_log(LOGARGS(this, TRACE), "Next tick in %" PRIu64 " ms", us_interval/1000);
     lcbio_timer_rearm(timer, us_interval);
 }
 
@@ -349,6 +349,10 @@ RetryQueue::add(mc_EXPACKET *pkt, const lcb_error_t err,
 
     lcb_log(LOGARGS(this, DEBUG), "Adding PKT=%p to retry queue. Try count=%u", (void*)pkt, pkt->base.retries);
     schedule();
+
+    if (settings->metrics) {
+        settings->metrics->packets_retried++;
+    }
 }
 
 void

data/ext/libcouchbase/src/rnd.cc

@@ -0,0 +1,68 @@
+/* -*- 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.
+ */
+
+#include "rnd.h"
+#include "internal.h"
+
+#if !defined(COMPILER_SUPPORTS_CXX11) || (defined(_MSC_VER) && _MSC_VER < 1600)
+static volatile int rnd_initialized = 0;
+LCB_INTERNAL_API
+void lcb_rnd_global_init(void)
+{
+    if (rnd_initialized) {
+        return;
+    }
+    rnd_initialized = 1;
+    if (lcb_getenv_boolean("LCB_NO_SRAND")) {
+        return;
+    }
+    srand(time(NULL));
+}
+
+LCB_INTERNAL_API
+lcb_U32 lcb_next_rand32(void)
+{
+    return (lcb_U32)rand();
+}
+
+LCB_INTERNAL_API
+lcb_U64 lcb_next_rand64(void)
+{
+    return (lcb_U64)rand();
+}
+#else
+
+#include <random>
+
+LCB_INTERNAL_API
+lcb_U32 lcb_next_rand32(void)
+{
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
+    static std::uniform_int_distribution< lcb_U32 > dis;
+    return dis(gen);
+}
+
+LCB_INTERNAL_API
+lcb_U64 lcb_next_rand64(void)
+{
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
+    static std::uniform_int_distribution< lcb_U64 > dis;
+    return dis(gen);
+}
+#endif

data/ext/libcouchbase/src/rnd.h

@@ -0,0 +1,39 @@
+/* -*- 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 LIBCOUCHBASE_RND_H
+#define LIBCOUCHBASE_RND_H 1
+
+#include "config.h"
+#include <libcouchbase/couchbase.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LCB_INTERNAL_API lcb_U32 lcb_next_rand32(void);
+LCB_INTERNAL_API lcb_U64 lcb_next_rand64(void);
+
+#if !defined(COMPILER_SUPPORTS_CXX11) || (defined(_MSC_VER) && _MSC_VER < 1600)
+    LCB_INTERNAL_API void lcb_rnd_global_init(void);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/src/settings.c

@@ -46,6 +46,8 @@ void lcb_default_settings(lcb_settings *settings)
     settings->retry[LCB_RETRY_ON_MISSINGNODE] = 0;
     settings->bc_http_urltype = LCB_DEFAULT_HTCONFIG_URLTYPE;
     settings->compressopts = LCB_DEFAULT_COMPRESSOPTS;
+    settings->compress_min_size = LCB_DEFAULT_COMPRESS_MIN_SIZE;
+    settings->compress_min_ratio = LCB_DEFAULT_COMPRESS_MIN_RATIO;
     settings->allocator_factory = rdb_bigalloc_new;
     settings->syncmode = LCB_ASYNCHRONOUS;
     settings->detailed_neterr = 0;
@@ -57,11 +59,26 @@ void lcb_default_settings(lcb_settings *settings)
     settings->tcp_nodelay = LCB_DEFAULT_TCP_NODELAY;
     settings->retry_nmv_interval = LCB_DEFAULT_RETRY_NMV_INTERVAL;
     settings->vb_noguess = LCB_DEFAULT_VB_NOGUESS;
+    settings->vb_noremap = LCB_DEFAULT_VB_NOREMAP;
     settings->select_bucket = LCB_DEFAULT_SELECT_BUCKET;
     settings->tcp_keepalive = LCB_DEFAULT_TCP_KEEPALIVE;
     settings->send_hello = 1;
     settings->config_poll_interval = LCB_DEFAULT_CONFIG_POLL_INTERVAL;
     settings->use_errmap = 1;
+    settings->use_collections = 0;
+    settings->log_redaction = 0;
+    settings->use_tracing = 0;
+#ifdef LCB_TRACING
+    settings->tracer_orphaned_queue_flush_interval = LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL;
+    settings->tracer_orphaned_queue_size = LCBTRACE_DEFAULT_ORPHANED_QUEUE_SIZE;
+    settings->tracer_threshold_queue_flush_interval = LCBTRACE_DEFAULT_THRESHOLD_QUEUE_FLUSH_INTERVAL;
+    settings->tracer_threshold_queue_size = LCBTRACE_DEFAULT_THRESHOLD_QUEUE_SIZE;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_KV] =  LCBTRACE_DEFAULT_THRESHOLD_KV;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_N1QL] =  LCBTRACE_DEFAULT_THRESHOLD_N1QL;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_VIEW] =  LCBTRACE_DEFAULT_THRESHOLD_VIEW;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_FTS] =  LCBTRACE_DEFAULT_THRESHOLD_FTS;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_ANALYTICS] =  LCBTRACE_DEFAULT_THRESHOLD_ANALYTICS;
+#endif
 }
 
 LCB_INTERNAL_API
@@ -86,6 +103,7 @@ lcb_settings_unref(lcb_settings *settings)
     free(settings->bucket);
     free(settings->sasl_mech_force);
     free(settings->certpath);
+    free(settings->keypath);
     free(settings->client_string);
 
     lcbauth_unref(settings->auth);
@@ -94,6 +112,15 @@ lcb_settings_unref(lcb_settings *settings)
     if (settings->ssl_ctx) {
         lcbio_ssl_free(settings->ssl_ctx);
     }
+    if (settings->metrics) {
+        lcb_metrics_destroy(settings->metrics);
+    }
+#ifdef LCB_TRACING
+    if (settings->tracer) {
+        lcbtrace_destroy(settings->tracer);
+        settings->tracer = NULL;
+    }
+#endif
     if (settings->dtorcb) {
         settings->dtorcb(settings->dtorarg);
     }

data/ext/libcouchbase/src/settings.h

@@ -32,7 +32,7 @@
 #define LCB_S2NS(s) (((hrtime_t)s) * 1000000000)
 
 /** Convert nanoseconds to microseconds */
-#define LCB_NS2US(s) (lcb_uint32_t) ((s) / 1000)
+#define LCB_NS2US(s) ((s) / 1000)
 
 #define LCB_MS2US(s) ((s) * 1000)
 
@@ -80,11 +80,17 @@
 #define LCB_DEFAULT_NETRETRY LCB_RETRY_CMDS_ALL
 #define LCB_DEFAULT_NMVRETRY LCB_RETRY_CMDS_ALL
 #define LCB_DEFAULT_HTCONFIG_URLTYPE LCB_HTCONFIG_URLTYPE_TRYALL
-#define LCB_DEFAULT_COMPRESSOPTS LCB_COMPRESS_NONE
+#define LCB_DEFAULT_COMPRESSOPTS LCB_COMPRESS_INOUT
+
+/* in bytes */
+#define LCB_DEFAULT_COMPRESS_MIN_SIZE 32
+/* compressed_bytes / original_bytes */
+#define LCB_DEFAULT_COMPRESS_MIN_RATIO 0.83
 
 #define LCB_DEFAULT_NVM_RETRY_IMM 1
 #define LCB_DEFAULT_RETRY_NMV_INTERVAL LCB_MS2US(100)
 #define LCB_DEFAULT_VB_NOGUESS 1
+#define LCB_DEFAULT_VB_NOREMAP 0
 #define LCB_DEFAULT_TCP_NODELAY 1
 #define LCB_DEFAULT_SELECT_BUCKET 1
 #define LCB_DEFAULT_TCP_KEEPALIVE 1
@@ -93,10 +99,25 @@
 /* 50 ms */
 #define LCB_CONFIG_POLL_INTERVAL_FLOOR LCB_MS2US(50)
 
+#define LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_ORPHANED_QUEUE_SIZE 128
+#define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_FLUSH_INTERVAL LCB_MS2US(3000)
+#define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_SIZE 128
+#define LCBTRACE_DEFAULT_THRESHOLD_KV  LCB_MS2US(500)
+#define LCBTRACE_DEFAULT_THRESHOLD_N1QL LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_THRESHOLD_VIEW LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_THRESHOLD_FTS LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_THRESHOLD_ANALYTICS LCB_MS2US(1000)
+
 #include "config.h"
 #include <libcouchbase/couchbase.h>
+#include <libcouchbase/metrics.h>
 #include "errmap.h"
 
+#ifdef LCB_TRACING
+#include <libcouchbase/tracing.h>
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -104,6 +125,7 @@ extern "C" {
 struct lcb_logprocs_st;
 struct lcbio_SSLCTX;
 struct rdb_ALLOCATOR;
+struct lcb_METRICS_st;
 
 /**
  * Stateless setting structure.
@@ -111,7 +133,8 @@ struct rdb_ALLOCATOR;
  * which are intended to be passed around to other objects.
  */
 typedef struct lcb_settings_st {
-    lcb_U16 iid;
+    /* TODO: [SDK3] change to uint64_t as per RFC. logging API exposes it as unsigned int currently */
+    lcb_U32 iid;
     lcb_U8 compressopts;
     lcb_U8 syncmode;
     lcb_U32 read_chunk_size;
@@ -164,6 +187,11 @@ typedef struct lcb_settings_st {
     unsigned select_bucket : 1;
     unsigned tcp_keepalive : 1;
     unsigned send_hello : 1;
+    unsigned use_collections : 1;
+    unsigned log_redaction : 1;
+    unsigned use_tracing : 1;
+    /** Do not use remap vbuckets (do not use fast forward map, or any other heuristics) */
+    unsigned vb_noremap : 1;
 
     short max_redir;
     unsigned refcount;
@@ -173,7 +201,9 @@ typedef struct lcb_settings_st {
 
     char *bucket;
     char *sasl_mech_force;
+    char *truststorepath;
     char *certpath;
+    char *keypath;
     lcb_AUTHENTICATOR *auth;
     struct rdb_ALLOCATOR* (*allocator_factory)(void);
     struct lcbio_SSLCTX *ssl_ctx;
@@ -183,6 +213,17 @@ typedef struct lcb_settings_st {
     char *client_string;
     lcb_pERRMAP errmap;
     lcb_U32 retry_nmv_interval;
+    struct lcb_METRICS_st *metrics;
+#ifdef LCB_TRACING
+    lcbtrace_TRACER *tracer;
+    lcb_U32 tracer_orphaned_queue_flush_interval;
+    lcb_U32 tracer_orphaned_queue_size;
+    lcb_U32 tracer_threshold_queue_flush_interval;
+    lcb_U32 tracer_threshold_queue_size;
+    lcb_U32 tracer_threshold[LCBTRACE_THRESHOLD__MAX];
+#endif
+    lcb_U32 compress_min_size;
+    float compress_min_ratio;
 } lcb_settings;
 
 LCB_INTERNAL_API
@@ -199,6 +240,29 @@ lcb_settings_unref(lcb_settings *);
 #define lcb_settings_ref(settings) ((void)(settings)->refcount++)
 #define lcb_settings_ref2(settings) ((settings)->refcount++, settings)
 
+/**
+ * Metric functionality. Defined in metrics.h, but retains a global-like
+ * setting similar to lcb_settings
+ */
+void
+lcb_metrics_dumpio(const lcb_IOMETRICS *metrics, FILE *fp);
+
+void
+lcb_metrics_dumpserver(const lcb_SERVERMETRICS *metrics, FILE *fp);
+
+lcb_METRICS *
+lcb_metrics_new(void);
+
+void
+lcb_metrics_destroy(lcb_METRICS *metrics);
+
+lcb_SERVERMETRICS *
+lcb_metrics_getserver(lcb_METRICS *metrics,
+    const char *host, const char *port, int create);
+
+void
+lcb_metrics_reset_pipeline_gauges(lcb_SERVERMETRICS *metrics);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/libcouchbase/src/ssl/CMakeLists.txt

@@ -1,13 +1,3 @@
-IF(APPLE)
-    IF(NOT OpenSSL_DIR)
-        EXECUTE_PROCESS(COMMAND brew --prefix openssl
-                        OUTPUT_VARIABLE OPENSSL_ROOT_DIR
-                        OUTPUT_STRIP_TRAILING_WHITESPACE)
-        MESSAGE(STATUS "Found OpenSSL Prefix: ${OPENSSL_ROOT_DIR}")
-    ENDIF()
-ENDIF()
-
-FIND_PACKAGE(OpenSSL)
 IF(OPENSSL_FOUND AND (NOT LCB_NO_SSL))
     INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
     ADD_DEFINITIONS(${OPENSSL_DEFINITIONS})
@@ -15,9 +5,7 @@ IF(OPENSSL_FOUND AND (NOT LCB_NO_SSL))
     SET(lcb_ssl_libs ${OPENSSL_LIBRARIES} PARENT_SCOPE)
     SET(lcb_ssl_objs $<TARGET_OBJECTS:lcbssl> PARENT_SCOPE)
     LCB_UTIL(lcbssl)
-    MESSAGE(STATUS "SSL Found")
 ELSE()
     SET(LCB_NO_SSL ON PARENT_SCOPE)
     SET(lcb_ssl_libs "" PARENT_SCOPE)
-    MESSAGE(STATUS "SSL Not Found")
 ENDIF()

data/ext/libcouchbase/src/ssl/ssl_common.c

@@ -255,9 +255,10 @@ struct lcbio_SSLCTX {
     SSL_CTX *ctx;
 };
 
-lcbio_pSSLCTX
-lcbio_ssl_new(const char *cafile, int noverify, lcb_error_t *errp,
-    lcb_settings *settings)
+#define LOGARGS_S(settings, lvl) settings, "SSL", lvl, __FILE__, __LINE__
+
+lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *keyfile, int noverify,
+                            lcb_error_t *errp, lcb_settings *settings)
 {
     lcb_error_t err_s;
     lcbio_pSSLCTX ret;
@@ -281,10 +282,28 @@ lcbio_ssl_new(const char *cafile, int noverify, lcb_error_t *errp,
 //    SSL_CTX_set_cipher_list(ret->ctx, "!NULL");
 
     if (cafile) {
-        if (!SSL_CTX_load_verify_locations(ret->ctx, cafile, NULL)) {
+        lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Load verify locations from \"%s\"", tsfile ? tsfile : keyfile);
+        if (!SSL_CTX_load_verify_locations(ret->ctx, tsfile ? tsfile : cafile, NULL)) {
             *errp = LCB_SSL_ERROR;
             goto GT_ERR;
         }
+        if (keyfile) {
+            lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Authenticate with key \"%s\", cert \"%s\"", keyfile, cafile);
+            if (!SSL_CTX_use_certificate_file(ret->ctx, cafile, SSL_FILETYPE_PEM)) {
+                *errp = LCB_SSL_ERROR;
+                goto GT_ERR;
+            }
+            if (!SSL_CTX_use_PrivateKey_file(ret->ctx, keyfile, SSL_FILETYPE_PEM)) {
+                lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR), "Unable to load private key \"%s\"", keyfile);
+                *errp = LCB_SSL_ERROR;
+                goto GT_ERR;
+            }
+            if (!SSL_CTX_check_private_key(ret->ctx)) {
+                lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR), "Unable to verify private key \"%s\"", keyfile);
+                *errp = LCB_SSL_ERROR;
+                goto GT_ERR;
+            }
+        }
     }
 
     if (noverify) {

data/ext/libcouchbase/src/strcodecs/base64.c

@@ -17,6 +17,7 @@
 
 #include "strcodecs.h"
 #include <string.h>
+#include <stdlib.h>
 
 /*
  * Function to base64 encode a text string as described in RFC 4648
@@ -37,19 +38,19 @@ static const lcb_uint8_t code[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrs
  * @param num the number of characters from s to encode
  * @return 0 upon success, -1 otherwise.
  */
-static int encode_rest(const lcb_uint8_t *s, lcb_uint8_t *d, lcb_size_t num)
+static int encode_rest(const lcb_uint8_t *s, lcb_uint8_t *d, lcb_SIZE num)
 {
     lcb_uint32_t val = 0;
 
     switch (num) {
-    case 2:
-        val = (lcb_uint32_t)((*s << 16) | (*(s + 1) << 8));
-        break;
-    case 1:
-        val = (lcb_uint32_t)((*s << 16));
-        break;
-    default:
-        return -1;
+        case 2:
+            val = (lcb_uint32_t)((*s << 16) | (*(s + 1) << 8));
+            break;
+        case 1:
+            val = (lcb_uint32_t)((*s << 16));
+            break;
+        default:
+            return -1;
     }
 
     d[3] = '=';
@@ -75,7 +76,7 @@ static int encode_rest(const lcb_uint8_t *s, lcb_uint8_t *d, lcb_size_t num)
 static int encode_triplet(const lcb_uint8_t *s, lcb_uint8_t *d)
 {
     lcb_uint32_t val = (lcb_uint32_t)((*s << 16) | (*(s + 1) << 8) | (*(s + 2)));
-    d[3] = code[val & 63] ;
+    d[3] = code[val & 63];
     d[2] = code[(val >> 6) & 63];
     d[1] = code[(val >> 12) & 63];
     d[0] = code[(val >> 18) & 63];
@@ -90,16 +91,15 @@ static int encode_triplet(const lcb_uint8_t *s, lcb_uint8_t *d)
  * @param sz size of destination buffer
  * @return 0 if success, -1 if the destination buffer isn't big enough
  */
-int lcb_base64_encode(const char *src, char *dst, lcb_size_t sz)
+int lcb_base64_encode(const char *src, lcb_SIZE len, char *dst, lcb_SIZE sz)
 {
-    lcb_size_t len = strlen(src);
-    lcb_size_t triplets = len / 3;
-    lcb_size_t rest = len % 3;
-    lcb_size_t ii;
+    lcb_SIZE triplets = len / 3;
+    lcb_SIZE rest = len % 3;
+    lcb_SIZE ii;
     const lcb_uint8_t *in = (const lcb_uint8_t *)src;
     lcb_uint8_t *out = (lcb_uint8_t *)dst;
 
-    if (sz < (lcb_size_t)((triplets + 1) * 4)) {
+    if (sz < (lcb_SIZE)((triplets + 1) * 4)) {
         return -1;
     }
 
@@ -121,3 +121,128 @@ int lcb_base64_encode(const char *src, char *dst, lcb_size_t sz)
 
     return 0;
 }
+
+int lcb_base64_encode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *ndst)
+{
+    lcb_SIZE len = (nsrc / 3 + 1) * 4 + 1;
+    char *ptr = calloc(len, sizeof(char));
+    int rc = lcb_base64_encode(src, nsrc, ptr, len);
+    if (rc == 0) {
+        *ndst = strlen(ptr);
+        *dst = ptr;
+    } else {
+        free(ptr);
+    }
+    return rc;
+}
+
+static int code2val(char c)
+{
+    if (c >= 'A' && c <= 'Z') {
+        return c - 'A';
+    }
+    if (c >= 'a' && c <= 'z') {
+        return c - 'a' + 26;
+    }
+    if (c >= '0' && c <= '9') {
+        return c - '0' + 52;
+    }
+    if (c == '+') {
+        return 62;
+    }
+    if (c == '/') {
+        return 63;
+    }
+    return -1;
+}
+
+lcb_SSIZE lcb_base64_decode(const char *src, lcb_SIZE nsrc, char *dst, lcb_SIZE ndst)
+{
+    lcb_SIZE offset = 0;
+    lcb_SSIZE idx = 0;
+
+    if (nsrc == 0) {
+        *dst = '\0';
+        return 0;
+    }
+
+    while (offset < nsrc) {
+        int val, ins;
+        lcb_U32 value;
+
+        if (isspace((int)*src)) {
+            ++offset;
+            ++src;
+            continue;
+        }
+
+        // We need at least 4 bytes
+        if ((offset + 4) > nsrc) {
+            return -1;
+        }
+
+        val = code2val(src[0]);
+        if (val < 0) {
+            return -1;
+        }
+        value = val << 18;
+        val = code2val(src[1]);
+        if (val < 0) {
+            return -1;
+        }
+        value |= val << 12;
+
+        ins = 3; /* number of characters to insert */
+        if (src[2] == '=') {
+            ins = 1;
+        } else {
+            value |= code2val(src[2]) << 6;
+            if (src[3] == '=') {
+                ins = 2;
+            } else {
+                value |= code2val(src[3]);
+            }
+        }
+
+        if ((lcb_SIZE)idx >= ndst) {
+            return -1;
+        }
+        dst[idx++] = (char)(value >> 16);
+        if (ins > 1) {
+            if ((lcb_SIZE)idx >= ndst) {
+                return -1;
+            }
+            dst[idx++] = (char)(value >> 8);
+            if (ins > 2) {
+                if ((lcb_SIZE)idx >= ndst) {
+                    return -1;
+                }
+                dst[idx++] = (char)(value);
+            }
+        }
+
+        src += 4;
+        offset += 4;
+    }
+    dst[idx + 1] = '\0';
+
+    return idx;
+}
+
+lcb_SSIZE lcb_base64_decode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *ndst)
+{
+    // To reduce the number of reallocations, start by reserving an
+    // output buffer of 75% of the input size (and add 3 to avoid dealing
+    // with zero)
+    lcb_SIZE len = nsrc * 3 / 4 + 3;
+    char *ptr = calloc(len, sizeof(char));
+
+    lcb_SSIZE rc = lcb_base64_decode(src, nsrc, ptr, len);
+    if (rc < 0) {
+        free(ptr);
+    } else {
+        *ndst = rc;
+        *dst = ptr;
+    }
+    return rc;
+}