nutcracker 0.2.3

data/ext/nutcracker/src/nc_stats.h

@@ -0,0 +1,206 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, 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 _NC_STATS_H_
+#define _NC_STATS_H_
+
+#include <sys/epoll.h>
+
+#include <nc_core.h>
+
+#define STATS_POOL_CODEC(ACTION)                                                                            \
+    /* client behavior */                                                                                   \
+    ACTION( client_eof,             STATS_COUNTER,      "# eof on client connections")                      \
+    ACTION( client_err,             STATS_COUNTER,      "# errors on client connections")                   \
+    ACTION( client_connections,     STATS_GAUGE,        "# active client connections")                      \
+    /* pool behavior */                                                                                     \
+    ACTION( server_ejects,          STATS_COUNTER,      "# times backend server was ejected")               \
+    /* forwarder behavior */                                                                                \
+    ACTION( forward_error,          STATS_COUNTER,      "# times we encountered a forwarding error")        \
+    ACTION( fragments,              STATS_COUNTER,      "# fragments created from a multi-vector request")  \
+
+#define STATS_SERVER_CODEC(ACTION)                                                                          \
+    /* server behavior */                                                                                   \
+    ACTION( server_eof,             STATS_COUNTER,      "# eof on server connections")                      \
+    ACTION( server_err,             STATS_COUNTER,      "# errors on server connections")                   \
+    ACTION( server_timedout,        STATS_COUNTER,      "# timeouts on server connections")                 \
+    ACTION( server_connections,     STATS_GAUGE,        "# active server connections")                      \
+    /* data behavior */                                                                                     \
+    ACTION( requests,               STATS_COUNTER,      "# requests")                                       \
+    ACTION( request_bytes,          STATS_COUNTER,      "total request bytes")                              \
+    ACTION( responses,              STATS_COUNTER,      "# respones")                                       \
+    ACTION( response_bytes,         STATS_COUNTER,      "total response bytes")                             \
+    ACTION( in_queue,               STATS_GAUGE,        "# requests in incoming queue")                     \
+    ACTION( in_queue_bytes,         STATS_GAUGE,        "current request bytes in incoming queue")          \
+    ACTION( out_queue,              STATS_GAUGE,        "# requests in outgoing queue")                     \
+    ACTION( out_queue_bytes,        STATS_GAUGE,        "current request bytes in outgoing queue")          \
+
+#define STATS_ADDR      "0.0.0.0"
+#define STATS_PORT      22222
+#define STATS_INTERVAL  (30 * 1000) /* in msec */
+
+typedef enum stats_type {
+    STATS_INVALID,
+    STATS_COUNTER,    /* monotonic accumulator */
+    STATS_GAUGE,      /* non-monotonic accumulator */
+    STATS_TIMESTAMP,  /* monotonic timestamp (in nsec) */
+    STATS_SENTINEL
+} stats_type_t;
+
+struct stats_metric {
+    stats_type_t  type;         /* type */
+    struct string name;         /* name (ref) */
+    union {
+        int64_t   counter;      /* accumulating counter */
+        int64_t   timestamp;    /* monotonic timestamp */
+    } value;
+};
+
+struct stats_server {
+    struct string name;   /* server name (ref) */
+    struct array  metric; /* stats_metric[] for server codec */
+};
+
+struct stats_pool {
+    struct string name;   /* pool name (ref) */
+    struct array  metric; /* stats_metric[] for pool codec */
+    struct array  server; /* stats_server[] */
+};
+
+struct stats_buffer {
+    size_t   len;   /* buffer length */
+    uint8_t  *data; /* buffer data */
+    size_t   size;  /* buffer alloc size */
+};
+
+struct stats {
+    uint16_t            port;           /* stats monitoring port */
+    int                 interval;       /* stats aggregation interval */
+    struct string       addr;           /* stats monitoring address */
+
+    int64_t             start_ts;       /* start timestamp of nutcracker */
+    struct stats_buffer buf;            /* output buffer */
+
+    struct array        current;        /* stats_pool[] (a) */
+    struct array        shadow;         /* stats_pool[] (b) */
+    struct array        sum;            /* stats_pool[] (c = a + b) */
+
+    pthread_t           tid;            /* stats aggregator thread */
+    int                 sd;             /* stats descriptor */
+    int                 ep;             /* epoll device */
+    struct epoll_event  event;          /* epoll event */
+
+    struct string       service_str;    /* service string */
+    struct string       service;        /* service */
+    struct string       source_str;     /* source string */
+    struct string       source;         /* source */
+    struct string       version_str;    /* version string */
+    struct string       version;        /* version */
+    struct string       uptime_str;     /* uptime string */
+    struct string       timestamp_str;  /* timestamp string */
+
+    volatile int        aggregate;      /* shadow (b) aggregate? */
+    volatile int        updated;        /* current (a) updated? */
+};
+
+#define DEFINE_ACTION(_name, _type, _desc) STATS_POOL_##_name,
+typedef enum stats_pool_field {
+    STATS_POOL_CODEC(DEFINE_ACTION)
+    STATS_POOL_NFIELD
+} stats_pool_field_t;
+#undef DEFINE_ACTION
+
+#define DEFINE_ACTION(_name, _type, _desc) STATS_SERVER_##_name,
+typedef enum stats_server_field {
+    STATS_SERVER_CODEC(DEFINE_ACTION)
+    STATS_SERVER_NFIELD
+} stats_server_field_t;
+#undef DEFINE_ACTION
+
+#if defined NC_STATS && NC_STATS == 1
+
+#define stats_pool_incr(_ctx, _pool, _name) do {                        \
+    _stats_pool_incr(_ctx, _pool, STATS_POOL_##_name);                  \
+} while (0)
+
+#define stats_pool_decr(_ctx, _pool, _name) do {                        \
+    _stats_pool_decr(_ctx, _pool, STATS_POOL_##_name);                  \
+} while (0)
+
+#define stats_pool_incr_by(_ctx, _pool, _name, _val) do {               \
+    _stats_pool_incr_by(_ctx, _pool, STATS_POOL_##_name, _val);         \
+} while (0)
+
+#define stats_pool_decr_by(_ctx, _pool, _name, _val) do {               \
+    _stats_pool_decr_by(_ctx, _pool, STATS_POOL_##_name, _val);         \
+} while (0)
+
+#define stats_server_incr(_ctx, _server, _name) do {                    \
+    _stats_server_incr(_ctx, _server, STATS_SERVER_##_name);            \
+} while (0)
+
+#define stats_server_decr(_ctx, _server, _name) do {                    \
+    _stats_server_decr(_ctx, _server, STATS_SERVER_##_name);            \
+} while (0)
+
+#define stats_server_incr_by(_ctx, _server, _name, _val) do {           \
+    _stats_server_incr_by(_ctx, _server, STATS_SERVER_##_name, _val);   \
+} while (0)
+
+#define stats_server_decr_by(_ctx, _server, _name, _val) do {           \
+    _stats_server_decr_by(_ctx, _server, STATS_SERVER_##_name, _val);   \
+} while (0)
+
+#else
+
+#define stats_pool_incr(_ctx, _pool, _name)
+
+#define stats_pool_decr(_ctx, _pool, _name)
+
+#define stats_pool_incr_by(_ctx, _pool, _name, _val)
+
+#define stats_pool_decr_by(_ctx, _pool, _name, _val)
+
+#define stats_server_incr(_ctx, _server, _name)
+
+#define stats_server_decr(_ctx, _server, _name)
+
+#define stats_server_incr_by(_ctx, _server, _name, _val)
+
+#define stats_server_decr_by(_ctx, _server, _name, _val)
+
+#endif
+
+#define stats_enabled   NC_STATS
+
+void stats_describe(void);
+
+void _stats_pool_incr(struct context *ctx, struct server_pool *pool, stats_pool_field_t fidx);
+void _stats_pool_decr(struct context *ctx, struct server_pool *pool, stats_pool_field_t fidx);
+void _stats_pool_incr_by(struct context *ctx, struct server_pool *pool, stats_pool_field_t fidx, int64_t val);
+void _stats_pool_decr_by(struct context *ctx, struct server_pool *pool, stats_pool_field_t fidx, int64_t val);
+
+void _stats_server_incr(struct context *ctx, struct server *server, stats_server_field_t fidx);
+void _stats_server_decr(struct context *ctx, struct server *server, stats_server_field_t fidx);
+void _stats_server_incr_by(struct context *ctx, struct server *server, stats_server_field_t fidx, int64_t val);
+void _stats_server_decr_by(struct context *ctx, struct server *server, stats_server_field_t fidx, int64_t val);
+
+struct stats *stats_create(uint16_t stats_port, char *stats_ip, int stats_interval, char *source, struct array *server_pool);
+void stats_destroy(struct stats *stats);
+void stats_swap(struct stats *stats);
+
+#endif

data/ext/nutcracker/src/nc_string.c

@@ -0,0 +1,109 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, 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 <stdlib.h>
+#include <string.h>
+
+#include <nc_core.h>
+
+/*
+ * String (struct string) is a sequence of unsigned char objects terminated
+ * by the null character '\0'. The length of the string is pre-computed and
+ * made available explicitly as an additional field. This means that we don't
+ * have to walk the entire character sequence until the null terminating
+ * character everytime that the length of the String is requested
+ *
+ * The only way to create a String is to initialize it using, string_init()
+ * and duplicate an existing String - string_duplicate() or copy an existing
+ * raw sequence of character bytes - string_copy(). Such String's must be
+ * freed using string_deinit()
+ *
+ * We can also create String as reference to raw string - string_set_raw()
+ * or to text string - string_set_text() or string(). Such String don't have
+ * to be freed.
+ */
+
+void
+string_init(struct string *str)
+{
+    str->len = 0;
+    str->data = NULL;
+}
+
+void
+string_deinit(struct string *str)
+{
+    ASSERT((str->len == 0 && str->data == NULL) ||
+           (str->len != 0 && str->data != NULL));
+
+    if (str->data != NULL) {
+        nc_free(str->data);
+        string_init(str);
+    }
+}
+
+bool
+string_empty(const struct string *str)
+{
+    ASSERT((str->len == 0 && str->data == NULL) ||
+           (str->len != 0 && str->data != NULL));
+    return str->len == 0 ? true : false;
+}
+
+rstatus_t
+string_duplicate(struct string *dst, const struct string *src)
+{
+    ASSERT(dst->len == 0 && dst->data == NULL);
+    ASSERT(src->len != 0 && src->data != NULL);
+
+    dst->data = nc_strndup(src->data, src->len + 1);
+    if (dst->data == NULL) {
+        return NC_ENOMEM;
+    }
+
+    dst->len = src->len;
+    dst->data[dst->len] = '\0';
+
+    return NC_OK;
+}
+
+rstatus_t
+string_copy(struct string *dst, const uint8_t *src, uint32_t srclen)
+{
+    ASSERT(dst->len == 0 && dst->data == NULL);
+    ASSERT(src != NULL && srclen != 0);
+
+    dst->data = nc_strndup(src, srclen + 1);
+    if (dst->data == NULL) {
+        return NC_ENOMEM;
+    }
+
+    dst->len = srclen;
+    dst->data[dst->len] = '\0';
+
+    return NC_OK;
+}
+
+int
+string_compare(const struct string *s1, const struct string *s2)
+{
+    if (s1->len != s2->len) {
+        return s1->len - s2->len > 0 ? 1 : -1;
+    }
+
+    return nc_strncmp(s1->data, s2->data, s1->len);
+}

data/ext/nutcracker/src/nc_string.h

@@ -0,0 +1,112 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, 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 _NC_STRING_H_
+#define _NC_STRING_H_
+
+#include <string.h>
+#include <nc_core.h>
+
+struct string {
+    uint32_t len;   /* string length */
+    uint8_t  *data; /* string data */
+};
+
+#define string(_str)   { sizeof(_str) - 1, (uint8_t *)(_str) }
+#define null_string    { 0, NULL }
+
+#define string_set_text(_str, _text) do {       \
+    (_str)->len = (uint32_t)(sizeof(_text) - 1);\
+    (_str)->data = (uint8_t *)(_text);          \
+} while (0);
+
+#define string_set_raw(_str, _raw) do {         \
+    (_str)->len = (uint32_t)(nc_strlen(_raw));  \
+    (_str)->data = (uint8_t *)(_raw);           \
+} while (0);
+
+void string_init(struct string *str);
+void string_deinit(struct string *str);
+bool string_empty(const struct string *str);
+rstatus_t string_duplicate(struct string *dst, const struct string *src);
+rstatus_t string_copy(struct string *dst, const uint8_t *src, uint32_t srclen);
+int string_compare(const struct string *s1, const struct string *s2);
+
+/*
+ * Wrapper around common routines for manipulating C character
+ * strings
+ */
+#define nc_memcpy(_d, _c, _n)           \
+    memcpy(_d, _c, (size_t)(_n))
+
+#define nc_memmove(_d, _c, _n)          \
+    memmove(_d, _c, (size_t)(_n))
+
+#define nc_memchr(_d, _c, _n)           \
+    memchr(_d, _c, (size_t)(_n))
+
+#define nc_strlen(_s)                   \
+    strlen((char *)(_s))
+
+#define nc_strncmp(_s1, _s2, _n)        \
+    strncmp((char *)(_s1), (char *)(_s2), (size_t)(_n))
+
+#define nc_strchr(_p, _l, _c)           \
+    _nc_strchr((uint8_t *)(_p), (uint8_t *)(_l), (uint8_t)(_c))
+
+#define nc_strrchr(_p, _s, _c)          \
+    _nc_strrchr((uint8_t *)(_p),(uint8_t *)(_s), (uint8_t)(_c))
+
+#define nc_strndup(_s, _n)              \
+    (uint8_t *)strndup((char *)(_s), (size_t)(_n));
+
+#define nc_snprintf(_s, _n, ...)        \
+    snprintf((char *)(_s), (size_t)(_n), __VA_ARGS__)
+
+#define nc_scnprintf(_s, _n, ...)       \
+    _scnprintf((char *)(_s), (size_t)(_n), __VA_ARGS__)
+
+#define nc_vscnprintf(_s, _n, _f, _a)   \
+    _vscnprintf((char *)(_s), (size_t)(_n), _f, _a)
+
+static inline uint8_t *
+_nc_strchr(uint8_t *p, uint8_t *last, uint8_t c)
+{
+    while (p < last) {
+        if (*p == c) {
+            return p;
+        }
+        p++;
+    }
+
+    return NULL;
+}
+
+static inline uint8_t *
+_nc_strrchr(uint8_t *p, uint8_t *start, uint8_t c)
+{
+    while (p >= start) {
+        if (*p == c) {
+            return p;
+        }
+        p--;
+    }
+
+    return NULL;
+}
+
+#endif

data/ext/nutcracker/src/nc_util.c

@@ -0,0 +1,619 @@
+/*
+ * twemproxy - A fast and lightweight proxy for memcached protocol.
+ * Copyright (C) 2011 Twitter, 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 <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <execinfo.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <nc_core.h>
+
+int
+nc_set_blocking(int sd)
+{
+    int flags;
+
+    flags = fcntl(sd, F_GETFL, 0);
+    if (flags < 0) {
+        return flags;
+    }
+
+    return fcntl(sd, F_SETFL, flags & ~O_NONBLOCK);
+}
+
+int
+nc_set_nonblocking(int sd)
+{
+    int flags;
+
+    flags = fcntl(sd, F_GETFL, 0);
+    if (flags < 0) {
+        return flags;
+    }
+
+    return fcntl(sd, F_SETFL, flags | O_NONBLOCK);
+}
+
+int
+nc_set_reuseaddr(int sd)
+{
+    int reuse;
+    socklen_t len;
+
+    reuse = 1;
+    len = sizeof(reuse);
+
+    return setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &reuse, len);
+}
+
+/*
+ * Disable Nagle algorithm on TCP socket.
+ *
+ * This option helps to minimize transmit latency by disabling coalescing
+ * of data to fill up a TCP segment inside the kernel. Sockets with this
+ * option must use readv() or writev() to do data transfer in bulk and
+ * hence avoid the overhead of small packets.
+ */
+int
+nc_set_tcpnodelay(int sd)
+{
+    int nodelay;
+    socklen_t len;
+
+    nodelay = 1;
+    len = sizeof(nodelay);
+
+    return setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, &nodelay, len);
+}
+
+int
+nc_set_linger(int sd, int timeout)
+{
+    struct linger linger;
+    socklen_t len;
+
+    linger.l_onoff = 1;
+    linger.l_linger = timeout;
+
+    len = sizeof(linger);
+
+    return setsockopt(sd, SOL_SOCKET, SO_LINGER, &linger, len);
+}
+
+int
+nc_set_sndbuf(int sd, int size)
+{
+    socklen_t len;
+
+    len = sizeof(size);
+
+    return setsockopt(sd, SOL_SOCKET, SO_SNDBUF, &size, len);
+}
+
+int
+nc_set_rcvbuf(int sd, int size)
+{
+    socklen_t len;
+
+    len = sizeof(size);
+
+    return setsockopt(sd, SOL_SOCKET, SO_RCVBUF, &size, len);
+}
+
+int
+nc_get_soerror(int sd)
+{
+    int status, err;
+    socklen_t len;
+
+    err = 0;
+    len = sizeof(err);
+
+    status = getsockopt(sd, SOL_SOCKET, SO_ERROR, &err, &len);
+    if (status == 0) {
+        errno = err;
+    }
+
+    return status;
+}
+
+int
+nc_get_sndbuf(int sd)
+{
+    int status, size;
+    socklen_t len;
+
+    size = 0;
+    len = sizeof(size);
+
+    status = getsockopt(sd, SOL_SOCKET, SO_SNDBUF, &size, &len);
+    if (status < 0) {
+        return status;
+    }
+
+    return size;
+}
+
+int
+nc_get_rcvbuf(int sd)
+{
+    int status, size;
+    socklen_t len;
+
+    size = 0;
+    len = sizeof(size);
+
+    status = getsockopt(sd, SOL_SOCKET, SO_RCVBUF, &size, &len);
+    if (status < 0) {
+        return status;
+    }
+
+    return size;
+}
+
+int
+_nc_atoi(uint8_t *line, size_t n)
+{
+    int value;
+
+    if (n == 0) {
+        return -1;
+    }
+
+    for (value = 0; n--; line++) {
+        if (*line < '0' || *line > '9') {
+            return -1;
+        }
+
+        value = value * 10 + (*line - '0');
+    }
+
+    if (value < 0) {
+        return -1;
+    }
+
+    return value;
+}
+
+bool
+nc_valid_port(int n)
+{
+    if (n < 1 || n > UINT16_MAX) {
+        return false;
+    }
+
+    return true;
+}
+
+void *
+_nc_alloc(size_t size, const char *name, int line)
+{
+    void *p;
+
+    ASSERT(size != 0);
+
+    p = malloc(size);
+    if (p == NULL) {
+        log_error("malloc(%zu) failed @ %s:%d", size, name, line);
+    } else {
+        log_debug(LOG_VVERB, "malloc(%zu) at %p @ %s:%d", size, p, name, line);
+    }
+
+    return p;
+}
+
+void *
+_nc_zalloc(size_t size, const char *name, int line)
+{
+    void *p;
+
+    p = _nc_alloc(size, name, line);
+    if (p != NULL) {
+        memset(p, 0, size);
+    }
+
+    return p;
+}
+
+void *
+_nc_calloc(size_t nmemb, size_t size, const char *name, int line)
+{
+    return _nc_zalloc(nmemb * size, name, line);
+}
+
+void *
+_nc_realloc(void *ptr, size_t size, const char *name, int line)
+{
+    void *p;
+
+    ASSERT(size != 0);
+
+    p = realloc(ptr, size);
+    if (p == NULL) {
+        log_error("realloc(%zu) failed @ %s:%d", size, name, line);
+    } else {
+        log_debug(LOG_VVERB, "realloc(%zu) at %p @ %s:%d", size, p, name, line);
+    }
+
+    return p;
+}
+
+void
+_nc_free(void *ptr, const char *name, int line)
+{
+    ASSERT(ptr != NULL);
+    log_debug(LOG_VVERB, "free(%p) @ %s:%d", ptr, name, line);
+    free(ptr);
+}
+
+void
+nc_stacktrace(int skip_count)
+{
+    void *stack[64];
+    char **symbols;
+    int size, i, j;
+
+    size = backtrace(stack, 64);
+    symbols = backtrace_symbols(stack, size);
+    if (symbols == NULL) {
+        return;
+    }
+
+    skip_count++; /* skip the current frame also */
+
+    for (i = skip_count, j = 0; i < size; i++, j++) {
+        loga("[%d] %s", j, symbols[i]);
+    }
+
+    free(symbols);
+}
+
+void
+nc_assert(const char *cond, const char *file, int line, int panic)
+{
+    log_error("assert '%s' failed @ (%s, %d)", cond, file, line);
+    if (panic) {
+        nc_stacktrace(1);
+        abort();
+    }
+}
+
+int
+_vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+    int n;
+
+    n = vsnprintf(buf, size, fmt, args);
+
+    /*
+     * The return value is the number of characters which would be written
+     * into buf not including the trailing '\0'. If size is == 0 the
+     * function returns 0.
+     *
+     * On error, the function also returns 0. This is to allow idiom such
+     * as len += _vscnprintf(...)
+     *
+     * See: http://lwn.net/Articles/69419/
+     */
+    if (n <= 0) {
+        return 0;
+    }
+
+    if (n < (int) size) {
+        return n;
+    }
+
+    return (int)(size - 1);
+}
+
+int
+_scnprintf(char *buf, size_t size, const char *fmt, ...)
+{
+    va_list args;
+    int n;
+
+    va_start(args, fmt);
+    n = _vscnprintf(buf, size, fmt, args);
+    va_end(args);
+
+    return n;
+}
+
+/*
+ * Send n bytes on a blocking descriptor
+ */
+ssize_t
+_nc_sendn(int sd, const void *vptr, size_t n)
+{
+    size_t nleft;
+    ssize_t	nsend;
+    const char *ptr;
+
+    ptr = vptr;
+    nleft = n;
+    while (nleft > 0) {
+        nsend = send(sd, ptr, nleft, 0);
+        if (nsend < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return nsend;
+        }
+        if (nsend == 0) {
+            return -1;
+        }
+
+        nleft -= (size_t)nsend;
+        ptr += nsend;
+    }
+
+    return (ssize_t)n;
+}
+
+/*
+ * Recv n bytes from a blocking descriptor
+ */
+ssize_t
+_nc_recvn(int sd, void *vptr, size_t n)
+{
+	size_t nleft;
+	ssize_t	nrecv;
+	char *ptr;
+
+	ptr = vptr;
+	nleft = n;
+	while (nleft > 0) {
+        nrecv = recv(sd, ptr, nleft, 0);
+        if (nrecv < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return nrecv;
+        }
+        if (nrecv == 0) {
+            break;
+        }
+
+        nleft -= (size_t)nrecv;
+        ptr += nrecv;
+    }
+
+    return (ssize_t)(n - nleft);
+}
+
+/*
+ * Return the current time in microseconds since Epoch
+ */
+int64_t
+nc_usec_now(void)
+{
+    struct timeval now;
+    int64_t usec;
+    int status;
+
+    status = gettimeofday(&now, NULL);
+    if (status < 0) {
+        log_error("gettimeofday failed: %s", strerror(errno));
+        return -1;
+    }
+
+    usec = (int64_t)now.tv_sec * 1000000LL + (int64_t)now.tv_usec;
+
+    return usec;
+}
+
+/*
+ * Return the current time in milliseconds since Epoch
+ */
+int64_t
+nc_msec_now(void)
+{
+    return nc_usec_now() / 1000LL;
+}
+
+static int
+nc_resolve_inet(struct string *name, int port, struct sockinfo *si)
+{
+    int status;
+    struct addrinfo *ai, *cai; /* head and current addrinfo */
+    struct addrinfo hints;
+    char *node, service[NC_UINTMAX_MAXLEN];
+    bool found;
+
+    ASSERT(nc_valid_port(port));
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_flags = AI_NUMERICSERV;
+    hints.ai_family = AF_UNSPEC;     /* AF_INET or AF_INET6 */
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = 0;
+    hints.ai_addrlen = 0;
+    hints.ai_addr = NULL;
+    hints.ai_canonname = NULL;
+
+    if (name != NULL) {
+        node = (char *)name->data;
+    } else {
+        /*
+         * If AI_PASSIVE flag is specified in hints.ai_flags, and node is
+         * NULL, then the returned socket addresses will be suitable for
+         * bind(2)ing a socket that will accept(2) connections. The returned
+         * socket address will contain the wildcard IP address.
+         */
+        node = NULL;
+        hints.ai_flags |= AI_PASSIVE;
+    }
+
+    nc_snprintf(service, NC_UINTMAX_MAXLEN, "%d", port);
+
+    status = getaddrinfo(node, service, &hints, &ai);
+    if (status < 0) {
+        log_error("address resolution of node '%s' service '%s' failed: %s",
+                  node, service, gai_strerror(status));
+        return -1;
+    }
+
+    /*
+     * getaddrinfo() can return a linked list of more than one addrinfo,
+     * since we requested for both AF_INET and AF_INET6 addresses and the
+     * host itself can be multi-homed. Since we don't care whether we are
+     * using ipv4 or ipv6, we just use the first address from this collection
+     * in the order in which it was returned.
+     *
+     * The sorting function used within getaddrinfo() is defined in RFC 3484;
+     * the order can be tweaked for a particular system by editing
+     * /etc/gai.conf
+     */
+    for (cai = ai, found = false; cai != NULL; cai = cai->ai_next) {
+        si->family = cai->ai_family;
+        si->addrlen = cai->ai_addrlen;
+        nc_memcpy(&si->addr, cai->ai_addr, si->addrlen);
+        found = true;
+        break;
+    }
+
+    freeaddrinfo(ai);
+
+    return !found ? -1 : 0;
+}
+
+static int
+nc_resolve_unix(struct string *name, struct sockinfo *si)
+{
+    struct sockaddr_un *un;
+
+    if (name->len >= NC_UNIX_ADDRSTRLEN) {
+        return -1;
+    }
+
+    un = &si->addr.un;
+
+    un->sun_family = AF_UNIX;
+    nc_memcpy(un->sun_path, name->data, name->len);
+    un->sun_path[name->len] = '\0';
+
+    si->family = AF_UNIX;
+    si->addrlen = sizeof(*un);
+    /* si->addr is an alias of un */
+
+    return 0;
+}
+
+/*
+ * Resolve a hostname and service by translating it to socket address and
+ * return it in si
+ *
+ * This routine is reentrant
+ */
+int
+nc_resolve(struct string *name, int port, struct sockinfo *si)
+{
+    if (name != NULL && name->data[0] == '/') {
+        return nc_resolve_unix(name, si);
+    }
+
+    return nc_resolve_inet(name, port, si);
+}
+
+/*
+ * Unresolve the socket address by translating it to a character string
+ * describing the host and service
+ *
+ * This routine is not reentrant
+ */
+char *
+nc_unresolve_addr(struct sockaddr *addr, socklen_t addrlen)
+{
+    static char unresolve[NI_MAXHOST + NI_MAXSERV];
+    static char host[NI_MAXHOST], service[NI_MAXSERV];
+    int status;
+
+    status = getnameinfo(addr, addrlen, host, sizeof(host),
+                         service, sizeof(service),
+                         NI_NUMERICHOST | NI_NUMERICSERV);
+    if (status < 0) {
+        return "unknown";
+    }
+
+    nc_snprintf(unresolve, sizeof(unresolve), "%s:%s", host, service);
+
+    return unresolve;
+}
+
+/*
+ * Unresolve the socket descriptor peer address by translating it to a
+ * character string describing the host and service
+ *
+ * This routine is not reentrant
+ */
+char *
+nc_unresolve_peer_desc(int sd)
+{
+    static struct sockinfo si;
+    struct sockaddr *addr;
+    socklen_t addrlen;
+    int status;
+
+    memset(&si, 0, sizeof(si));
+    addr = (struct sockaddr *)&si.addr;
+    addrlen = sizeof(si.addr);
+
+    status = getpeername(sd, addr, &addrlen);
+    if (status < 0) {
+        return "unknown";
+    }
+
+    return nc_unresolve_addr(addr, addrlen);
+}
+
+/*
+ * Unresolve the socket descriptor address by translating it to a
+ * character string describing the host and service
+ *
+ * This routine is not reentrant
+ */
+char *
+nc_unresolve_desc(int sd)
+{
+    static struct sockinfo si;
+    struct sockaddr *addr;
+    socklen_t addrlen;
+    int status;
+
+    memset(&si, 0, sizeof(si));
+    addr = (struct sockaddr *)&si.addr;
+    addrlen = sizeof(si.addr);
+
+    status = getsockname(sd, addr, &addrlen);
+    if (status < 0) {
+        return "unknown";
+    }
+
+    return nc_unresolve_addr(addr, addrlen);
+}