libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/src/lcbio/ctx.c

@@ -25,18 +25,16 @@
 #define CTX_FD(ctx) (ctx)->fd
 #define CTX_SD(ctx) (ctx)->sd
 #define CTX_IOT(ctx) (ctx)->io
+#define CTX_INCR_METRIC(ctx, metric, n) do { \
+    if (ctx->sock->metrics) { \
+        ctx->sock->metrics->metric += n; \
+    } \
+} while (0)
+
 #include "rw-inl.h"
+#include "ctx-log-inl.h"
 
 #define LOGARGS(c, lvl) (c)->sock->settings, "ioctx", LCB_LOG_##lvl, __FILE__, __LINE__
-static const lcb_host_t * get_ctx_host(const lcbio_CTX *ctx) {
-    static lcb_host_t host = { "NOHOST", "NOPORT" };
-    if (!ctx) { return &host; }
-    if (!ctx->sock) { return &host; }
-    if (!ctx->sock->info) { return &host; }
-    return &ctx->sock->info->ep;
-}
-#define CTX_LOGFMT "<%s:%s> (CTX=%p,%s) "
-#define CTX_LOGID(ctx) get_ctx_host(ctx)->host, get_ctx_host(ctx)->port, (void*)ctx, ctx?ctx->subsys : ""
 
 typedef enum {
     ES_ACTIVE = 0,
@@ -84,6 +82,8 @@ lcbio_ctx_new(lcbio_SOCKET *sock, void *data, const lcbio_CTXPROCS *procs)
     ctx->state = ES_ACTIVE;
     ctx->as_err = lcbio_timer_new(ctx->io, ctx, err_handler);
     ctx->subsys = "unknown";
+    sock->service = LCBIO_SERVICE_UNSPEC;
+    sock->atime = LCB_NS2US(gethrtime());
 
     rdb_init(&ctx->ior, sock->settings->allocator_factory());
     lcbio_ref(sock);
@@ -98,7 +98,7 @@ lcbio_ctx_new(lcbio_SOCKET *sock, void *data, const lcbio_CTXPROCS *procs)
     ctx->procs = *procs;
     ctx->state = ES_ACTIVE;
 
-    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Pairing with SOCK=%p", CTX_LOGID(ctx), (void*)sock);
+    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Pairing with SOCK=%016" PRIx64, CTX_LOGID(ctx), sock->id);
     return ctx;
 }
 
@@ -160,6 +160,7 @@ lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg,
         cb(ctx->sock, reusable, arg);
     }
 
+    ctx->sock->ctx = NULL;
     if (oldrc == ctx->sock->refcount) {
         lcbio_shutdown(ctx->sock);
     }
@@ -274,6 +275,17 @@ invoke_read_cb(lcbio_CTX *ctx, unsigned nb)
     ctx->entered--;
 }
 
+static void
+send_io_error(lcbio_CTX *ctx, lcbio_IOSTATUS status)
+{
+    lcb_error_t rc = convert_lcberr(ctx, status);
+    CTX_INCR_METRIC(ctx, io_error, 1);
+    if (status == LCBIO_SHUTDOWN) {
+        CTX_INCR_METRIC(ctx, io_close, 1);
+    }
+    lcbio_ctx_senderr(ctx, rc);
+}
+
 static void
 E_handler(lcb_socket_t sock, short which, void *arg)
 {
@@ -286,6 +298,7 @@ E_handler(lcb_socket_t sock, short which, void *arg)
         status = lcbio_E_rdb_slurp(ctx, &ctx->ior);
         nb = rdb_get_nused(&ctx->ior);
 
+        ctx->sock->atime = LCB_NS2US(gethrtime());
         if (nb >= ctx->rdwant) {
             invoke_read_cb(ctx, nb);
             if (E_free_detached(ctx)) {
@@ -293,10 +306,10 @@ E_handler(lcb_socket_t sock, short which, void *arg)
             }
         }
         if (!LCBIO_IS_OK(status)) {
-            lcb_error_t err = convert_lcberr(ctx, status);
-            lcbio_ctx_senderr(ctx, err);
+            send_io_error(ctx, status);
             return;
         }
+        CTX_INCR_METRIC(ctx, bytes_received, nb);
     }
 
     if (which & LCB_WRITE_EVENT) {
@@ -308,10 +321,9 @@ E_handler(lcb_socket_t sock, short which, void *arg)
             }
         } else if (ctx->output) {
             status = lcbio_E_rb_write(ctx, &ctx->output->rb);
+            /** Metrics are logged by E_rb_write */
             if (!LCBIO_IS_OK(status)) {
-                deactivate_watcher(ctx);
-                ctx->err = convert_lcberr(ctx, status);
-                err_handler(ctx);
+                send_io_error(ctx, status);
                 return;
             }
         }
@@ -337,6 +349,7 @@ Cw_handler(lcb_sockdata_t *sd, int status, void *arg)
     (void)sd;
 
     ctx->npending--;
+    CTX_INCR_METRIC(ctx, bytes_sent, erb->rb.nbytes);
 
     if (!ctx->output) {
         ctx->output = erb;
@@ -366,6 +379,7 @@ Cr_handler(lcb_sockdata_t *sd, lcb_ssize_t nr, void *arg)
     ctx->npending--;
 
     if (ctx->state == ES_ACTIVE) {
+        ctx->sock->atime = LCB_NS2US(gethrtime());
         if (nr > 0) {
             unsigned total;
             rdb_rdend(&ctx->ior, nr);
@@ -373,11 +387,21 @@ Cr_handler(lcb_sockdata_t *sd, lcb_ssize_t nr, void *arg)
             if (total >= ctx->rdwant) {
                 invoke_read_cb(ctx, total);
             }
-
+            CTX_INCR_METRIC(ctx, bytes_received, total);
             lcbio_ctx_schedule(ctx);
         } else {
-            lcb_error_t err =
-                    convert_lcberr(ctx, nr ? LCBIO_SHUTDOWN : LCBIO_IOERR);
+            lcbio_IOSTATUS iostatus;
+            lcb_error_t err;
+
+            CTX_INCR_METRIC(ctx, io_error, 1);
+            if (nr) {
+                iostatus = LCBIO_IOERR;
+            } else {
+                iostatus = LCBIO_SHUTDOWN;
+                CTX_INCR_METRIC(ctx, io_close, 1);
+            }
+
+            err = convert_lcberr(ctx, iostatus);
             ctx->rdwant = 0;
             invoke_entered_errcb(ctx, err);
         }
@@ -404,7 +428,7 @@ C_schedule(lcbio_CTX *ctx)
         niov = iov[1].iov_len ? 2 : 1;
         rv = IOT_V1(io).write2(IOT_ARG(io), sd, iov, niov, ctx->output, Cw_handler);
         if (rv) {
-            lcbio_ctx_senderr(ctx, convert_lcberr(ctx, LCBIO_IOERR));
+            send_io_error(ctx, LCBIO_IOERR);
             return;
         } else {
             ctx->output = NULL;
@@ -429,8 +453,7 @@ C_schedule(lcbio_CTX *ctx)
 
         rv = IOT_V1(io).read2(IOT_ARG(io), sd, iov, niov, ctx, Cr_handler);
         if (rv) {
-            lcbio_ctx_senderr(ctx, convert_lcberr(ctx, LCBIO_IOERR));
-
+            send_io_error(ctx, LCBIO_IOERR);
         } else {
             sd->is_reading = 1;
             ctx->npending++;
@@ -486,6 +509,7 @@ E_put_ex(lcbio_CTX *ctx, lcb_IOV *iov, unsigned niov, unsigned nb)
     nw = IOT_V0IO(iot).sendv(IOT_ARG(iot), fd, iov,
         niov <= RWINL_IOVSIZE ? niov : RWINL_IOVSIZE);
     if (nw > 0) {
+        CTX_INCR_METRIC(ctx, bytes_sent, nw);
         ctx->procs.cb_flush_done(ctx, nb, nw);
         return 1;
 
@@ -504,13 +528,13 @@ E_put_ex(lcbio_CTX *ctx, lcb_IOV *iov, unsigned niov, unsigned nb)
             /* pretend all the bytes were written and deliver an error during
              * the next event loop iteration. */
             nw = nb;
-            lcbio_ctx_senderr(ctx, convert_lcberr(ctx, LCBIO_IOERR));
+            send_io_error(ctx, LCBIO_IOERR);
             goto GT_WRITE0;
         }
     } else {
         /* connection closed. pretend everything was written and send an error */
         nw = nb;
-        lcbio_ctx_senderr(ctx, convert_lcberr(ctx, LCBIO_SHUTDOWN));
+        send_io_error(ctx, LCBIO_SHUTDOWN);
         goto GT_WRITE0;
     }
 
@@ -526,11 +550,13 @@ Cw_ex_handler(lcb_sockdata_t *sd, int status, void *wdata)
     unsigned nflushed = (uintptr_t)wdata;
     ctx->npending--;
 
+    CTX_INCR_METRIC(ctx, bytes_sent, nflushed);
     ctx->entered = 1;
     ctx->procs.cb_flush_done(ctx, nflushed, nflushed);
     ctx->entered = 0;
 
     if (ctx->state == ES_ACTIVE && status) {
+        CTX_INCR_METRIC(ctx, io_error, 1);
         invoke_entered_errcb(ctx, convert_lcberr(ctx, LCBIO_IOERR));
     }
     if (ctx->state != ES_ACTIVE && !ctx->npending) {

data/ext/libcouchbase/src/lcbio/ioutils.cc

@@ -300,9 +300,7 @@ lcbio_ssl_supported(void)
 #endif
 }
 
-lcbio_pSSLCTX
-lcbio_ssl_new__fallback(const char *, int, lcb_error_t *errp,
-    lcb_settings *)
+lcbio_pSSLCTX lcbio_ssl_new__fallback(const char *, const char *, const char *, int, lcb_error_t *errp, lcb_settings *)
 {
     if (errp) { *errp = LCB_CLIENT_FEATURE_UNAVAILABLE; }
     return NULL;
@@ -327,3 +325,32 @@ lcb_error_t lcbio_sslify_if_needed(lcbio_SOCKET *, lcb_settings *) {
     return LCB_SUCCESS;
 }
 #endif
+
+std::string lcbio__inet_ntop(sockaddr_storage *ss)
+{
+    char buf[4096] = {0};
+    switch(ss->ss_family) {
+    case AF_INET:
+    {
+        struct sockaddr_in *addr = (struct sockaddr_in *)ss;
+        inet_ntop(AF_INET, &(addr->sin_addr), buf, sizeof(buf));
+        size_t len = strlen(buf);
+        snprintf(buf + len, 10, ":%d", (int)ntohs(addr->sin_port));
+    }
+    break;
+
+    case AF_INET6:
+    {
+        struct sockaddr_in6 *addr = (struct sockaddr_in6 *)ss;
+        inet_ntop(AF_INET6, &(addr->sin6_addr), buf, sizeof(buf));
+        size_t len = strlen(buf);
+        snprintf(buf + len, 10, ":%d", (int)ntohs(addr->sin6_port));
+    }
+    break;
+
+    default:
+        strncpy(buf, "Unknown AF", sizeof(buf));
+    }
+
+    return std::string(buf);
+}

data/ext/libcouchbase/src/lcbio/ioutils.h

@@ -116,6 +116,8 @@ lcbio__load_socknames(lcbio_SOCKET *sock);
 #ifdef __cplusplus
 }
 
+std::string lcbio__inet_ntop(sockaddr_storage *ss);
+
 namespace lcb {
 namespace io {
 

data/ext/libcouchbase/src/lcbio/manager.cc

@@ -159,14 +159,19 @@ struct PoolRequest : ReqNode, ConnectionRequest {
 }
 }
 
-static const char *get_hehost(PoolHost *h) {
+static const char *get_hehost(const PoolHost *h) {
     if (!h) { return "NOHOST:NOPORT"; }
     return h->key.c_str();
 }
 
 /** Format string arguments for %p%s:%s */
-#define HE_LOGID(h) get_hehost(h), (void*)h
-#define HE_LOGFMT "<%s> (HE=%p) "
+#define HE_LOGID(h)                                                    \
+    (h && h->parent && h->parent->settings->log_redaction) ?  LCB_LOG_SD_OTAG : "", \
+        get_hehost(h),                                                  \
+        (h && h->parent && h->parent->settings->log_redaction) ?  LCB_LOG_SD_CTAG : "", \
+        (void*)h
+#define HE_LOGFMT "<" LCB_LOG_SPEC("%s") "> (HE=%p) "
+
 
 PoolConnInfo::~PoolConnInfo() {
     parent->n_total--;
@@ -238,13 +243,39 @@ void Pool::shutdown() {
     unref();
 }
 
+static void endpointToJSON(hrtime_t now, Json::Value &node, const PoolHost *host, const PoolConnInfo *info) {
+    Json::Value endpoint;
+    char id[20] = {0};
+    snprintf(id, sizeof(id), "%p", (void *)info->sock);
+    endpoint["id"] = id;
+    endpoint["remote"] = get_hehost(host);
+    endpoint["local"] = lcbio__inet_ntop(&info->sock->info->sa_local);
+    endpoint["last_activity_us"] = (Json::Value::UInt64)(now - info->sock->atime);
+    endpoint["status"] = "connected";
+    node[lcbio_svcstr(info->sock->service)].append(endpoint);
+}
+
+void Pool::toJSON(hrtime_t now, Json::Value &node) {
+    lcbio_MGR::HostMap::const_iterator it;
+    for (it = ht.begin(); it != ht.end(); ++it) {
+        const PoolHost *host = it->second;
+        lcb_list_t *llcur;
+        LCB_LIST_FOR(llcur, (lcb_list_t *)&host->ll_idle) {
+            endpointToJSON(now, node, host, PoolConnInfo::from_llnode(llcur));
+        }
+        LCB_LIST_FOR(llcur, (lcb_list_t *)&host->ll_pending) {
+            endpointToJSON(now, node, host, PoolConnInfo::from_llnode(llcur));
+        }
+    }
+}
+
 void
 PoolRequest::invoke() {
     if (sock) {
         PoolConnInfo *info = PoolConnInfo::from_sock(sock);
         info->set_leased();
         state = ASSIGNED;
-        lcb_log(LOGARGS(info->parent->parent, DEBUG), HE_LOGFMT "Assigning R=%p SOCKET=%p",HE_LOGID(info->parent), (void*)this, (void*)sock);
+        lcb_log(LOGARGS(info->parent->parent, DEBUG), HE_LOGFMT "Assigning R=%p SOCKET=%p", HE_LOGID(info->parent), (void*)this, (void*)sock);
     }
 
     callback(sock, arg, err, 0);
@@ -318,7 +349,7 @@ PoolConnInfo::PoolConnInfo(PoolHost *he, uint32_t timeout)
     id = LCBIO_PROTOCTX_POOL;
     dtor = cinfo_protoctx_dtor;
 
-    lcb_host_t tmphost;
+    lcb_host_t tmphost = {"", "", 0};
     lcb_error_t err = lcb_host_parsez(&tmphost, he->key.c_str(), 80);
     if (err != LCB_SUCCESS) {
         lcb_log(LOGARGS(he->parent, ERROR), HE_LOGFMT "Could not parse host! Will supply dummy host (I=%p)", HE_LOGID(he), (void*)this);
@@ -371,8 +402,12 @@ Pool::get(const lcb_host_t& dest, uint32_t timeout, lcbio_CONNDONE_cb cb,
     PoolHost *he;
     lcb_list_t *cur;
 
-    std::string key(dest.host);
-    key.append(":").append(dest.port);
+    std::string key;
+    if (dest.ipv6) {
+        key.append("[").append(dest.host).append("]:").append(dest.port);
+    } else {
+        key.append(dest.host).append(":").append(dest.port);
+    }
 
     HostMap::iterator m = ht.find(key);
     if (m == ht.end()) {
@@ -506,7 +541,8 @@ PoolHost::dump(FILE *out) const {
     lcb_list_t *llcur;
     fprintf(out, "HOST=%s", key.c_str());
     fprintf(out, "Requests=%lu, Idle=%lu, Pending=%lu, Leased=%lu\n",
-            num_requests(), num_idle(), num_pending(), num_leased());
+            (unsigned long int)num_requests(), (unsigned long int)num_idle(),
+            (unsigned long int)num_pending(), (unsigned long int)num_leased());
 
     fprintf(out, CONN_INDENT "Idle Connections:\n");
     write_he_list(&ll_idle, out);

data/ext/libcouchbase/src/lcbio/manager.h

@@ -173,6 +173,8 @@ public:
         return options;
     }
 
+    void toJSON(hrtime_t now, Json::Value &node);
+
 private:
     friend struct PoolRequest;
     friend struct PoolConnInfo;

data/ext/libcouchbase/src/lcbio/rw-inl.h

@@ -109,6 +109,7 @@ lcbio_E_rb_write(lcbio_CTX *ctx, ringbuffer_t *buf)
         }
         if (nw) {
             ringbuffer_consumed(buf, nw);
+            CTX_INCR_METRIC(ctx, bytes_sent, nw);
         }
     }
     return LCBIO_COMPLETED;

data/ext/libcouchbase/src/lcbio/ssl.h

@@ -61,8 +61,7 @@ typedef struct lcbio_SSLCTX *lcbio_pSSLCTX;
 int
 lcbio_ssl_supported(void);
 
-lcbio_pSSLCTX
-lcbio_ssl_new__fallback(const char *, int, lcb_error_t *, lcb_settings *);
+lcbio_pSSLCTX lcbio_ssl_new__fallback(const char *, const char *, const char *, int, lcb_error_t *, lcb_settings *);
 
 #ifndef LCB_NO_SSL
 /**
@@ -74,9 +73,8 @@ lcbio_ssl_new__fallback(const char *, int, lcb_error_t *, lcb_settings *);
  *
  * @return A new SSL context, or NULL on error.
  */
-lcbio_pSSLCTX
-lcbio_ssl_new(const char *cafile, int noverify, lcb_error_t *errp,
-    lcb_settings *settings);
+lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *keyfile, int noverify,
+                            lcb_error_t *errp, lcb_settings *settings);
 #else
 #define lcbio_ssl_new lcbio_ssl_new__fallback
 #endif

data/ext/libcouchbase/src/logging.c

@@ -147,7 +147,7 @@ static void console_log(struct lcb_logprocs_st *procs,
     flockfile(fp);
     fprintf(fp, "%lums ", (unsigned long)(now - start_time) / 1000000);
 
-    fprintf(fp, "[I%d] {%"THREAD_ID_FMT"} [%s] (%s - L:%d) ",
+    fprintf(fp, "[I%08x] {%"THREAD_ID_FMT"} [%s] (%s - L:%d) ",
             iid,
             GET_THREAD_ID(),
             level_to_string(severity),

data/ext/libcouchbase/src/logging.h

@@ -78,6 +78,8 @@ lcb_logprocs * lcb_init_console_logger(void);
 
 /** Macro for overcoming Win32 identifiers */
 #define LCB_LOG_ERR LCB_LOG_ERROR
+/** Undefine DEBUG macro to fix environments which are defining it */
+#undef DEBUG
 
 #ifdef __cplusplus
 }

data/ext/libcouchbase/src/mc/compress.cc

@@ -0,0 +1,164 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014-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 "mcreq.h"
+#include "compress.h"
+
+#include <snappy.h>
+#include <snappy-sinksource.h>
+
+class FragBufSource : public snappy::Source
+{
+  public:
+    explicit FragBufSource(const lcb_FRAGBUF *buf_) : buf(buf_)
+    {
+        if (buf->total_length) {
+            left = buf->total_length;
+        } else {
+            left = 0;
+            for (unsigned int ii = 0; ii < buf->niov; ii++) {
+                left += buf->iov[ii].iov_len;
+            }
+        }
+        idx = 0;
+        ptr = static_cast< const char * >(buf->iov[idx].iov_base);
+    }
+
+    virtual ~FragBufSource() {}
+
+    virtual size_t Available() const
+    {
+        return left;
+    }
+
+    virtual const char *Peek(size_t *len)
+    {
+        *len =
+            buf->iov[idx].iov_len - static_cast< size_t >((ptr - static_cast< const char * >(buf->iov[idx].iov_base)));
+        return ptr;
+    }
+
+    virtual void Skip(size_t n)
+    {
+        lcb_IOV &v = buf->iov[idx];
+        if (ptr == static_cast< const char * >(v.iov_base) && n == v.iov_len) {
+            ptr = static_cast< const char * >(buf->iov[++idx].iov_base);
+        } else {
+            ptr += n;
+            if (static_cast< size_t >(ptr - static_cast< const char * >(v.iov_base)) == v.iov_len) {
+                ptr = static_cast< const char * >(buf->iov[++idx].iov_base);
+            }
+        }
+        left -= n;
+        if (left == 0) {
+            ptr = NULL;
+        }
+    }
+
+  private:
+    const lcb_FRAGBUF *buf;
+    const char *ptr;
+    size_t left;
+    unsigned int idx;
+};
+
+int mcreq_compress_value(mc_PIPELINE *pl, mc_PACKET *pkt, const lcb_VALBUF *vbuf, lcb_settings *settings,
+                         int *should_compress)
+{
+    size_t maxsize, compsize = 0, origsize = 0;
+
+    snappy::Source *source = NULL;
+    switch (vbuf->vtype) {
+        case LCB_KV_COPY:
+        case LCB_KV_CONTIG:
+            origsize = vbuf->u_buf.contig.nbytes;
+            if (origsize < settings->compress_min_size) {
+                *should_compress = 0;
+                mcreq_reserve_value(pl, pkt, vbuf);
+                return 0;
+            }
+            source = new snappy::ByteArraySource(static_cast< const char * >(vbuf->u_buf.contig.bytes),
+                                                 vbuf->u_buf.contig.nbytes);
+            break;
+
+        case LCB_KV_IOV:
+        case LCB_KV_IOVCOPY:
+            if (vbuf->u_buf.multi.total_length == 0) {
+                for (unsigned int ii = 0; ii < vbuf->u_buf.multi.niov; ii++) {
+                    origsize += vbuf->u_buf.multi.iov[ii].iov_len;
+                }
+            }
+            if (origsize < settings->compress_min_size) {
+                *should_compress = 0;
+                mcreq_reserve_value(pl, pkt, vbuf);
+                return 0;
+            }
+            source = new FragBufSource(&vbuf->u_buf.multi);
+            break;
+
+        default:
+            return -1;
+    }
+
+    maxsize = snappy::MaxCompressedLength(source->Available());
+    if (mcreq_reserve_value2(pl, pkt, maxsize) != LCB_SUCCESS) {
+        return -1;
+    }
+    nb_SPAN *outspan = &pkt->u_value.single;
+    snappy::UncheckedByteArraySink sink(SPAN_BUFFER(outspan));
+
+    Compress(source, &sink);
+    compsize = sink.CurrentDestination() - SPAN_BUFFER(outspan);
+    delete source;
+
+    if (compsize == 0 || compsize / origsize > settings->compress_min_ratio) {
+        netbuf_mblock_release(&pl->nbmgr, outspan);
+        *should_compress = 0;
+        mcreq_reserve_value(pl, pkt, vbuf);
+        return 0;
+    }
+
+    if (compsize < maxsize) {
+        /* chop off some bytes? */
+        nb_SPAN trailspan = *outspan;
+        trailspan.offset += compsize;
+        trailspan.size = maxsize - compsize;
+        netbuf_mblock_release(&pl->nbmgr, &trailspan);
+        outspan->size = compsize;
+    }
+    return 0;
+}
+
+int mcreq_inflate_value(const void *compressed, lcb_SIZE ncompressed, const void **bytes, lcb_SIZE *nbytes,
+                        void **freeptr)
+{
+    size_t compsize = 0;
+
+    if (!snappy::GetUncompressedLength(static_cast< const char * >(compressed), (size_t)ncompressed, &compsize)) {
+        return -1;
+    }
+    *freeptr = malloc(compsize);
+    if (!snappy::RawUncompress(static_cast< const char * >(compressed), ncompressed, static_cast< char * >(*freeptr))) {
+        free(*freeptr);
+        *freeptr = NULL;
+        return -1;
+    }
+
+    *bytes = *freeptr;
+    *nbytes = compsize;
+    return 0;
+}