libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/src/bucketconfig/bc_http.cc

@@ -22,8 +22,9 @@
 #include <lcbio/ssl.h>
 #include "ctx-log-inl.h"
 #define LOGARGS(ht, lvlbase) ht->parent->settings, "htconfig", LCB_LOG_##lvlbase, __FILE__, __LINE__
-#define LOGFMT "<%s:%s> "
-#define LOGID(h) get_ctx_host(h->ioctx), get_ctx_port(h->ioctx)
+
+#define LOGFMT CTX_LOGFMT
+#define LOGID(p) CTX_LOGID(p->ioctx)
 
 using namespace lcb::clconfig;
 
@@ -243,24 +244,31 @@ lcb_error_t HttpProvider::setup_request_header(const lcb_host_t &host) {
     }
 
     request_buf.append(" HTTP/1.1\r\n");
-    const std::string& password = (settings().conntype == LCB_TYPE_BUCKET)
-        ? settings().auth->password_for(settings().bucket)
-        : settings().auth->password();
-    if (!password.empty()) {
-        const std::string& username = (settings().conntype == LCB_TYPE_BUCKET)
-            ? settings().auth->username_for(settings().bucket)
-            : settings().auth->username();
-        std::string cred;
-        cred.append(username).append(":").append(password);
-        char b64[256] = { 0 };
-        if (lcb_base64_encode(cred.c_str(), b64, sizeof(b64)) == -1) {
-            return LCB_EINTERNAL;
+    if (!settings().keypath) {
+        // not using SSL client certificate to authenticate
+        const std::string password = (settings().conntype == LCB_TYPE_BUCKET)
+            ? settings().auth->password_for(host.host, host.port, settings().bucket)
+            : settings().auth->password();
+        if (!password.empty()) {
+            const std::string username = (settings().conntype == LCB_TYPE_BUCKET)
+                ? settings().auth->username_for(host.host, host.port, settings().bucket)
+                : settings().auth->username();
+            std::string cred;
+            cred.append(username).append(":").append(password);
+            char b64[256] = { 0 };
+            if (lcb_base64_encode(cred.c_str(), cred.size(), b64, sizeof(b64)) == -1) {
+                return LCB_EINTERNAL;
+            }
+            request_buf.append("Authorization: Basic ").append(b64).append("\r\n");
         }
-        request_buf.append("Authorization: Basic ").append(b64).append("\r\n");
     }
 
     request_buf.append("Host: ").append(host.host).append(":").append(host.port).append("\r\n");
-    request_buf.append("User-Agent: libcouchbase/").append(LCB_VERSION_STRING).append("\r\n");
+    request_buf.append("User-Agent: ").append(LCB_CLIENT_ID);
+    if (settings().client_string) {
+        request_buf.append(" ").append(settings().client_string);
+    }
+    request_buf.append("\r\n");
     request_buf.append("\r\n");
     return LCB_SUCCESS;
 }
@@ -294,7 +302,7 @@ on_connected(lcbio_SOCKET *sock, void *arg, lcb_error_t err, lcbio_OSERR syserr)
         return;
     }
     host = lcbio_get_host(sock);
-    lcb_log(LOGARGS(http, DEBUG), "Successfuly connected to REST API %s:%s", host->host, host->port);
+    lcb_log(LOGARGS(http, DEBUG), "Successfuly connected to REST API " LCB_HOST_FMT, LCB_HOST_ARG(http->parent->settings, host));
 
     lcbio_sslify_if_needed(sock, http->parent->settings);
     http->reset_stream_state();
@@ -310,6 +318,7 @@ on_connected(lcbio_SOCKET *sock, void *arg, lcb_error_t err, lcbio_OSERR syserr)
     procs.cb_read = read_common;
     http->ioctx = lcbio_ctx_new(sock, http, &procs);
     http->ioctx->subsys = "bc_http";
+    sock->service = LCBIO_SERVICE_CFG;
 
     lcbio_ctx_put(http->ioctx, http->request_buf.c_str(), http->request_buf.size());
     lcbio_ctx_rwant(http->ioctx, 1);

data/ext/libcouchbase/src/bucketconfig/bc_http.h

@@ -34,7 +34,7 @@
 
 #define REQPOOLS_URI "/pools/"
 #define HOSTHDR_FMT  "Host: %s:%s\r\n"
-#define LAST_HTTP_HEADER "X-Libcouchbase: " LCB_VERSION_STRING "\r\n"
+#define LAST_HTTP_HEADER "X-Libcouchbase: " LCB_CLIENT_ID "\r\n"
 #define CONFIG_DELIMITER "\n\n\n\n"
 
 namespace lcb {

data/ext/libcouchbase/src/bucketconfig/clconfig.h

@@ -164,7 +164,7 @@ struct Confmon {
      * remain to be activated you should call lcb_confmon_prepare() once. Then
      * call the rest of the functions.
      */
-    Confmon(lcb_settings*, lcbio_pTABLE iot);
+    Confmon(lcb_settings*, lcbio_pTABLE iot, lcb_t instance);
     void destroy() { delete this; }
     ~Confmon();
 
@@ -383,10 +383,12 @@ struct Confmon {
     int state;
 
     /** Last time the provider was stopped. As a microsecond timestamp */
-    lcb_uint32_t last_stop_us;
+    lcb_uint64_t last_stop_us;
 
     typedef std::list<Provider*> ProviderList;
     ProviderList active_providers;
+
+    lcb_t instance;
 };
 
 /**

data/ext/libcouchbase/src/bucketconfig/confmon.cc

@@ -19,6 +19,7 @@
 #include "clconfig.h"
 #include <list>
 #include <algorithm>
+#include "trace.h"
 
 #define LOGARGS(mon, lvlbase) mon->settings, "confmon", LCB_LOG_##lvlbase, __FILE__, __LINE__
 #define LOG(mon, lvlbase, msg) lcb_log(mon->settings, "confmon", LCB_LOG_##lvlbase, __FILE__, __LINE__, msg)
@@ -55,7 +56,7 @@ provider_string(Method type) {
     return "";
 }
 
-Confmon::Confmon(lcb_settings *settings_, lcbio_pTABLE iot_)
+Confmon::Confmon(lcb_settings *settings_, lcbio_pTABLE iot_, lcb_t instance_)
     : cur_provider(NULL),
       config(NULL),
       settings(settings_),
@@ -64,7 +65,8 @@ Confmon::Confmon(lcb_settings *settings_, lcbio_pTABLE iot_)
       as_start(iot_, this),
       as_stop(iot_, this),
       state(0),
-      last_stop_us(0) {
+      last_stop_us(0),
+      instance(instance_) {
 
     lcbio_table_ref(iot);
     lcb_settings_ref(settings);
@@ -147,7 +149,7 @@ int Confmon::do_set_next(ConfigInfo *new_config, bool notify_miss)
             ca = config->vbc;
             cb = new_config->vbc;
 
-            lcb_log(LOGARGS(this, DEBUG), "Not applying configuration received via %s. No changes detected. A.rev=%d, B.rev=%d", provider_string(new_config->get_origin()), ca->revid, cb->revid);
+            lcb_log(LOGARGS(this, TRACE), "Not applying configuration received via %s. No changes detected. A.rev=%d, B.rev=%d", provider_string(new_config->get_origin()), ca->revid, cb->revid);
             if (notify_miss) {
                 invoke_listeners(CLCONFIG_EVENT_GOT_ANY_CONFIG, new_config);
             }
@@ -156,6 +158,7 @@ int Confmon::do_set_next(ConfigInfo *new_config, bool notify_miss)
     }
 
     lcb_log(LOGARGS(this, INFO), "Setting new configuration. Received via %s", provider_string(new_config->get_origin()));
+    TRACE_NEW_CONFIG(instance, new_config);
 
     if (config) {
         /** DECREF the old one */

data/ext/libcouchbase/src/cbft.cc

@@ -36,6 +36,10 @@ struct lcb_FTSREQ : lcb::jsparse::Parser::Actions {
     lcb_t instance;
     size_t nrows;
     lcb_error_t lasterr;
+#ifdef LCB_TRACING
+    lcbtrace_SPAN *span;
+#endif
+
     void invoke_row(lcb_RESPFTS *resp);
     void invoke_last();
 
@@ -116,6 +120,9 @@ lcb_FTSREQ::lcb_FTSREQ(lcb_t instance_, const void *cookie_, const lcb_CMDFTS *c
   parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_FTS, this)),
   cookie(cookie_), callback(cmd->callback), instance(instance_), nrows(0),
   lasterr(LCB_SUCCESS)
+#ifdef LCB_TRACING
+    , span(NULL)
+#endif
 {
     lcb_CMDHTTP htcmd = { 0 };
     htcmd.type = LCB_HTTP_TYPE_FTS;
@@ -169,6 +176,15 @@ lcb_FTSREQ::lcb_FTSREQ(lcb_t instance_, const void *cookie_, const lcb_CMDFTS *c
         if (cmd->handle) {
             *cmd->handle = reinterpret_cast<lcb_FTSREQ*>(this);
         }
+#ifdef LCB_TRACING
+        if (instance->settings->tracer) {
+            char id[20] = {0};
+            snprintf(id, sizeof(id), "%p", (void *)this);
+            span = lcbtrace_span_start(instance->settings->tracer, LCBTRACE_OP_DISPATCH_TO_SERVER, LCBTRACE_NOW, NULL);
+            lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, id);
+            lcbtrace_span_add_system_tags(span, instance->settings, LCBTRACE_TAG_SERVICE_SEARCH);
+        }
+#endif
     }
 }
 
@@ -178,6 +194,26 @@ lcb_FTSREQ::~lcb_FTSREQ()
         lcb_cancel_http_request(instance, htreq);
         htreq = NULL;
     }
+#ifdef LCB_TRACING
+    if (span) {
+        if (htreq) {
+            lcbio_CTX *ctx = htreq->ioctx;
+            if (ctx) {
+                std::string remote;
+                if (htreq->ipv6) {
+                    remote = "[" + std::string(htreq->host) + "]:" + std::string(htreq->port);
+                } else {
+                    remote = std::string(htreq->host) + ":" + std::string(htreq->port);
+                }
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, remote.c_str());
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_LOCAL_ADDRESS,
+                                          lcbio__inet_ntop(&ctx->sock->info->sa_local).c_str());
+            }
+        }
+        lcbtrace_span_finish(span, LCBTRACE_NOW);
+        span = NULL;
+    }
+#endif
     if (parser) {
         delete parser;
         parser = NULL;
@@ -203,3 +239,15 @@ lcb_fts_cancel(lcb_t, lcb_FTSHANDLE handle)
 {
     handle->callback = NULL;
 }
+
+#ifdef LCB_TRACING
+
+LIBCOUCHBASE_API
+void lcb_fts_set_parent_span(lcb_t, lcb_FTSHANDLE handle, lcbtrace_SPAN *span)
+{
+    if (handle) {
+        lcbtrace_span_set_parent(handle->span, span);
+    }
+}
+
+#endif

data/ext/libcouchbase/src/cntl.cc

@@ -82,6 +82,15 @@ static lcb_uint32_t *get_timeout_field(lcb_t instance, int cmd)
     case LCB_CNTL_RETRY_INTERVAL: return &settings->retry_interval;
     case LCB_CNTL_RETRY_NMV_INTERVAL: return &settings->retry_nmv_interval;
     case LCB_CNTL_CONFIG_POLL_INTERVAL: return &settings->config_poll_interval;
+#ifdef LCB_TRACING
+    case LCB_CNTL_TRACING_ORPHANED_QUEUE_FLUSH_INTERVAL: return &settings->tracer_orphaned_queue_flush_interval;
+    case LCB_CNTL_TRACING_THRESHOLD_QUEUE_FLUSH_INTERVAL: return &settings->tracer_threshold_queue_flush_interval;
+    case LCB_CNTL_TRACING_THRESHOLD_KV: return &settings->tracer_threshold[LCBTRACE_THRESHOLD_KV];
+    case LCB_CNTL_TRACING_THRESHOLD_N1QL: return &settings->tracer_threshold[LCBTRACE_THRESHOLD_N1QL];
+    case LCB_CNTL_TRACING_THRESHOLD_VIEW: return &settings->tracer_threshold[LCBTRACE_THRESHOLD_VIEW];
+    case LCB_CNTL_TRACING_THRESHOLD_FTS: return &settings->tracer_threshold[LCBTRACE_THRESHOLD_FTS];
+    case LCB_CNTL_TRACING_THRESHOLD_ANALYTICS: return &settings->tracer_threshold[LCBTRACE_THRESHOLD_ANALYTICS];
+#endif
     default: return NULL;
     }
 }
@@ -132,9 +141,15 @@ HANDLER(get_changeset) {
 HANDLER(ssl_mode_handler) {
     RETURN_GET_ONLY(int, LCBT_SETTING(instance, sslopts))
 }
+HANDLER(ssl_truststorepath_handler) {
+    RETURN_GET_ONLY(char*, LCBT_SETTING(instance, truststorepath))
+}
 HANDLER(ssl_certpath_handler) {
     RETURN_GET_ONLY(char*, LCBT_SETTING(instance, certpath))
 }
+HANDLER(ssl_keypath_handler) {
+    RETURN_GET_ONLY(char*, LCBT_SETTING(instance, keypath))
+}
 HANDLER(htconfig_urltype_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, bc_http_urltype));
 }
@@ -168,6 +183,9 @@ HANDLER(schedflush_handler) {
 HANDLER(vbguess_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, keep_guess_vbs))
 }
+HANDLER(vb_noremap_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, vb_noremap))
+}
 HANDLER(fetch_mutation_tokens_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, fetch_mutation_tokens))
 }
@@ -201,6 +219,35 @@ HANDLER(select_bucket_handler) {
 HANDLER(send_hello_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, send_hello));
 }
+HANDLER(log_redaction_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, log_redaction));
+}
+HANDLER(enable_tracing_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, use_tracing));
+}
+HANDLER(tracing_orphaned_queue_size_handler) {
+#ifdef LCB_TRACING
+    RETURN_GET_SET(lcb_U32, LCBT_SETTING(instance, tracer_orphaned_queue_size));
+#else
+    (void)mode;
+    (void)instance;
+    (void)cmd;
+    (void)arg;
+    return LCB_ECTL_BADARG;
+#endif
+}
+HANDLER(tracing_threshold_queue_size_handler) {
+#ifdef LCB_TRACING
+    RETURN_GET_SET(lcb_U32, LCBT_SETTING(instance, tracer_threshold_queue_size));
+#else
+    (void)mode;
+    (void)instance;
+    (void)cmd;
+    (void)arg;
+    return LCB_ECTL_BADARG;
+#endif
+}
+
 HANDLER(config_poll_interval_handler) {
     lcb_U32 *user = reinterpret_cast<lcb_U32*>(arg);
     if (mode == LCB_CNTL_SET && *user > 0 && *user < LCB_CONFIG_POLL_INTERVAL_FLOOR) {
@@ -528,6 +575,9 @@ HANDLER(n1ql_cache_clear_handler) {
 HANDLER(bucket_auth_handler) {
     const lcb_BUCKETCRED *cred;
     if (mode == LCB_CNTL_SET) {
+        if (LCBT_SETTING(instance, keypath)) {
+            return LCB_ECTL_UNSUPPMODE;
+        }
         /* Parse the bucket string... */
         cred = (const lcb_BUCKETCRED *)arg;
         return lcbauth_add_pass(instance->settings->auth, (*cred)[0], (*cred)[1], LCBAUTH_F_BUCKET);
@@ -551,6 +601,45 @@ HANDLER(bucket_auth_handler) {
     return LCB_SUCCESS;
 }
 
+HANDLER(metrics_handler) {
+    if (mode == LCB_CNTL_SET) {
+        int val = *(int *)arg;
+        if (!val) {
+            return LCB_ECTL_BADARG;
+        }
+        if (!instance->settings->metrics) {
+            instance->settings->metrics = lcb_metrics_new();
+        }
+        return LCB_SUCCESS;
+    } else if (mode == LCB_CNTL_GET) {
+        *(lcb_METRICS**)arg = instance->settings->metrics;
+        return LCB_SUCCESS;
+    } else {
+        return LCB_ECTL_UNSUPPMODE;
+    }
+    (void)cmd;
+}
+
+HANDLER(collections_handler) {
+    RETURN_GET_SET(int, LCBT_SETTING(instance, use_collections));
+}
+
+HANDLER(comp_min_size_handler) {
+    if (mode == LCB_CNTL_SET && *reinterpret_cast<lcb_U32*>(arg) < LCB_DEFAULT_COMPRESS_MIN_SIZE) {
+        return LCB_ECTL_BADARG;
+    }
+    RETURN_GET_SET(lcb_U32, LCBT_SETTING(instance, compress_min_size))
+}
+
+HANDLER(comp_min_ratio_handler) {
+    if (mode == LCB_CNTL_SET) {
+        float val = *reinterpret_cast<float*>(arg);
+        if (val > 1 || val < 0) {
+            return LCB_ECTL_BADARG;
+        }
+    }
+    RETURN_GET_SET(float, LCBT_SETTING(instance, compress_min_ratio))
+}
 
 static ctl_handler handlers[] = {
     timeout_common, /* LCB_CNTL_OP_TIMEOUT */
@@ -588,7 +677,7 @@ static ctl_handler handlers[] = {
     init_providers, /* LCB_CNTL_CONFIG_ALL_NODES */
     config_cache_handler, /* LCB_CNTL_CONFIGCACHE */
     ssl_mode_handler, /* LCB_CNTL_SSL_MODE */
-    ssl_certpath_handler, /* LCB_CNTL_SSL_CAPATH */
+    ssl_certpath_handler, /* LCB_CNTL_SSL_CERT */
     retrymode_handler, /* LCB_CNTL_RETRYMODE */
     htconfig_urltype_handler, /* LCB_CNTL_HTCONFIG_URLTYPE */
     compmode_handler, /* LCB_CNTL_COMPRESSION_OPTS */
@@ -625,7 +714,25 @@ static ctl_handler handlers[] = {
     tcp_keepalive_handler, /* LCB_CNTL_TCP_KEEPALIVE */
     config_poll_interval_handler, /* LCB_CNTL_CONFIG_POLL_INTERVAL */
     send_hello_handler, /* LCB_CNTL_SEND_HELLO */
-    buckettype_handler /* LCB_CNTL_BUCKETTYPE */
+    buckettype_handler, /* LCB_CNTL_BUCKETTYPE */
+    metrics_handler, /* LCB_CNTL_METRICS */
+    collections_handler, /* LCB_CNTL_USE_COLLECTIONS */
+    ssl_keypath_handler, /* LCB_CNTL_SSL_KEY */
+    log_redaction_handler, /* LCB_CNTL_LOG_REDACTION */
+    ssl_truststorepath_handler, /* LCB_CNTL_SSL_TRUSTSTORE */
+    enable_tracing_handler, /* LCB_CNTL_ENABLE_TRACING */
+    timeout_common, /* LCB_CNTL_TRACING_ORPHANED_QUEUE_FLUSH_INTERVAL */
+    tracing_orphaned_queue_size_handler, /* LCB_CNTL_TRACING_ORPHANED_QUEUE_SIZE */
+    timeout_common, /* LCB_CNTL_TRACING_THRESHOLD_QUEUE_FLUSH_INTERVAL */
+    tracing_threshold_queue_size_handler, /* LCB_CNTL_TRACING_THRESHOLD_QUEUE_SIZE */
+    timeout_common, /* LCB_CNTL_TRACING_THRESHOLD_KV */
+    timeout_common, /* LCB_CNTL_TRACING_THRESHOLD_N1QL */
+    timeout_common, /* LCB_CNTL_TRACING_THRESHOLD_VIEW */
+    timeout_common, /* LCB_CNTL_TRACING_THRESHOLD_FTS */
+    timeout_common, /* LCB_CNTL_TRACING_THRESHOLD_ANALYTICS */
+    comp_min_size_handler, /* LCB_CNTL_COMPRESSION_MIN_SIZE */
+    comp_min_ratio_handler, /* LCB_CNTL_COMPRESSION_MIN_RATIO */
+    vb_noremap_handler, /* LCB_CNTL_VB_NOREMAP */
 };
 
 /* Union used for conversion to/from string functions */
@@ -708,6 +815,7 @@ static lcb_error_t convert_compression(const char *arg, u_STRCONVERT *u) {
         { "on", LCB_COMPRESS_INOUT },
         { "off", LCB_COMPRESS_NONE },
         { "inflate_only", LCB_COMPRESS_IN },
+        { "deflate_only", LCB_COMPRESS_OUT },
         { "force", LCB_COMPRESS_INOUT|LCB_COMPRESS_FORCE },
         { NULL }
     };
@@ -739,6 +847,18 @@ static lcb_error_t convert_retrymode(const char *arg, u_STRCONVERT *u) {
     return LCB_SUCCESS;
 }
 
+static lcb_error_t convert_ipv6(const char *arg, u_STRCONVERT *u)
+{
+    static const STR_u32MAP optmap[] = {
+        {"disabled", LCB_IPV6_DISABLED},
+        {"only", LCB_IPV6_ONLY},
+        {"allow", LCB_IPV6_ALLOW},
+        {NULL}
+    };
+    DO_CONVERT_STR2NUM(arg, optmap, u->i);
+    return LCB_SUCCESS;
+}
+
 static cntl_OPCODESTRS stropcode_map[] = {
         {"operation_timeout", LCB_CNTL_OP_TIMEOUT, convert_timevalue},
         {"timeout", LCB_CNTL_OP_TIMEOUT, convert_timevalue},
@@ -782,6 +902,22 @@ static cntl_OPCODESTRS stropcode_map[] = {
         {"tcp_keepalive", LCB_CNTL_TCP_KEEPALIVE, convert_intbool},
         {"config_poll_interval", LCB_CNTL_CONFIG_POLL_INTERVAL, convert_timevalue},
         {"send_hello", LCB_CNTL_SEND_HELLO, convert_intbool},
+        {"ipv6", LCB_CNTL_IP6POLICY, convert_ipv6},
+        {"metrics", LCB_CNTL_METRICS, convert_intbool },
+        {"log_redaction", LCB_CNTL_LOG_REDACTION, convert_intbool},
+        {"enable_tracing", LCB_CNTL_ENABLE_TRACING, convert_intbool},
+        {"tracing_orphaned_queue_flush_interval", LCB_CNTL_TRACING_ORPHANED_QUEUE_FLUSH_INTERVAL, convert_timevalue},
+        {"tracing_orphaned_queue_size", LCB_CNTL_TRACING_ORPHANED_QUEUE_SIZE, convert_u32},
+        {"tracing_threshold_queue_flush_interval", LCB_CNTL_TRACING_THRESHOLD_QUEUE_FLUSH_INTERVAL, convert_timevalue},
+        {"tracing_threshold_queue_size", LCB_CNTL_TRACING_THRESHOLD_QUEUE_SIZE, convert_u32},
+        {"tracing_threshold_kv", LCB_CNTL_TRACING_THRESHOLD_KV, convert_timevalue},
+        {"tracing_threshold_n1ql", LCB_CNTL_TRACING_THRESHOLD_N1QL, convert_timevalue},
+        {"tracing_threshold_view", LCB_CNTL_TRACING_THRESHOLD_VIEW, convert_timevalue},
+        {"tracing_threshold_fts", LCB_CNTL_TRACING_THRESHOLD_FTS, convert_timevalue},
+        {"tracing_threshold_analytics", LCB_CNTL_TRACING_THRESHOLD_ANALYTICS, convert_timevalue},
+        {"compression_min_size", LCB_CNTL_COMPRESSION_MIN_SIZE, convert_u32},
+        {"compression_min_ratio", LCB_CNTL_COMPRESSION_MIN_RATIO, convert_float},
+        {"vb_noremap", LCB_CNTL_VB_NOREMAP, convert_intbool },
         {NULL, -1}
 };
 

data/ext/libcouchbase/src/config_static.h

@@ -43,7 +43,20 @@
 #endif
 
 #ifdef HAVE_INTTYPES_H
+#ifdef __cplusplus
+#define __STDC_FORMAT_MACROS 1
+#endif
 #include <inttypes.h>
+#elif defined(_MSC_VER)
+#ifndef PRIx64
+#define PRIx64 "I64x"
+#endif
+#ifndef PRId64
+#define PRId64 "I64d"
+#endif
+#ifndef PRIu64
+#define PRIu64 "I64u"
+#endif
 #endif
 
 #ifdef HAVE_NETDB_H
@@ -130,10 +143,14 @@
 extern "C" {
 #endif
     extern uint64_t lcb_byteswap64(uint64_t val);
+    extern uint16_t lcb_byteswap16(uint16_t val);
 #ifdef __cplusplus
 }
 #endif
 
+#define lcb_ntohs(a) lcb_byteswap16(a)
+#define lcb_htons(a) lcb_byteswap16(a)
+
 #ifdef linux
 #undef ntohs
 #undef ntohl