ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/src/conn.h

@@ -0,0 +1,75 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef CONN_H_
+#define CONN_H_
+
+#include "natsp.h"
+
+#ifdef DEV_MODE
+// For type safety
+
+void natsConn_Lock(natsConnection *nc);
+void natsConn_Unlock(natsConnection *nc);
+
+#else
+// We know what we are doing :-)
+
+#define natsConn_Lock(c)    (natsMutex_Lock((c)->mu))
+#define natsConn_Unlock(c)  (natsMutex_Unlock((c)->mu))
+
+#endif // DEV_MODE
+
+natsStatus
+natsConn_create(natsConnection **newConn, natsOptions *options);
+
+void
+natsConn_retain(natsConnection *nc);
+
+void
+natsConn_release(natsConnection *nc);
+
+natsStatus
+natsConn_bufferWrite(natsConnection *nc, const char *buffer, int len);
+
+natsStatus
+natsConn_bufferFlush(natsConnection *nc);
+
+bool
+natsConn_isClosed(natsConnection *nc);
+
+bool
+natsConn_isReconnecting(natsConnection *nc);
+
+void
+natsConn_kickFlusher(natsConnection *nc);
+
+natsStatus
+natsConn_processMsg(natsConnection *nc, char *buf, int bufLen);
+
+void
+natsConn_processOK(natsConnection *nc);
+
+void
+natsConn_processErr(natsConnection *nc, char *buf, int bufLen);
+
+void
+natsConn_processPing(natsConnection *nc);
+
+void
+natsConn_processPong(natsConnection *nc);
+
+natsStatus
+natsConn_subscribe(natsSubscription **newSub,
+                   natsConnection *nc, const char *subj, const char *queue,
+                   int64_t timeout, natsMsgHandler cb, void *cbClosure);
+
+natsStatus
+natsConn_unsubscribe(natsConnection *nc, natsSubscription *sub, int max);
+
+void
+natsConn_removeSubscription(natsConnection *nc, natsSubscription *sub, bool needsLock);
+
+void
+natsConn_processAsyncINFO(natsConnection *nc, char *buf, int len);
+
+#endif /* CONN_H_ */

data/vendor/cnats/src/err.h

@@ -0,0 +1,31 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+
+#ifndef ERR_H_
+#define ERR_H_
+
+#include "status.h"
+#include "nats.h"
+#include "natsp.h"
+
+#define NATS_SSL_ERR_REASON_STRING ERR_reason_error_string(ERR_get_error())
+
+#define nats_setDefaultError(e) nats_setError((e), "%s", natsStatus_GetText(e))
+
+#define nats_setError(e, f, ...) nats_setErrorReal(__FILE__, __NATS_FUNCTION__, __LINE__, (e), (f), __VA_ARGS__)
+
+natsStatus
+nats_setErrorReal(const char *fileName, const char *funcName, int line, natsStatus errSts, const void *errTxtFmt, ...);
+
+#define NATS_UPDATE_ERR_STACK(s) (s == NATS_OK ? s : nats_updateErrStack(s, __NATS_FUNCTION__))
+
+natsStatus
+nats_updateErrStack(natsStatus err, const char *func);
+
+void
+nats_clearLastError(void);
+
+void
+nats_doNotUpdateErrStack(bool skipStackUpdate);
+
+#endif /* ERR_H_ */

data/vendor/cnats/src/gc.h

@@ -0,0 +1,27 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+
+#ifndef GC_H_
+#define GC_H_
+
+// This callback implements the specific code to free the given object.
+// This is invoked by the garbage collector.
+typedef void (*nats_FreeObjectCb)(void *object);
+
+// This structure should be included as the first field of any object
+// that needs to be garbage collected.
+typedef struct __natsGCItem
+{
+    struct __natsGCItem     *next;
+    nats_FreeObjectCb       freeCb;
+
+} natsGCItem;
+
+// Gives the object to the garbage collector.
+// Returns 'true' if the GC takes ownership, 'false' otherwise (in this case,
+// the caller is responsible for freeing the object).
+bool
+natsGC_collect(natsGCItem *item);
+
+
+#endif /* GC_H_ */

data/vendor/cnats/src/hash.c

@@ -0,0 +1,725 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "natsp.h"
+
+#include <string.h>
+
+#include "status.h"
+#include "mem.h"
+#include "hash.h"
+
+#define _freeEntry(e)   { NATS_FREE(e); (e) = NULL; }
+
+#define _OFF32  (2166136261)
+#define _YP32   (709607)
+
+#define _BSZ (8)
+#define _WSZ (4)
+
+static int _DWSZ   = _WSZ << 1; // 8
+static int _DDWSZ  = _WSZ << 2; // 16
+
+static int _MAX_BKT_SIZE = (1 << 30) - 1;
+
+natsStatus
+natsHash_Create(natsHash **newHash, int initialSize)
+{
+    natsHash    *hash = NULL;
+
+    if (initialSize <= 0)
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    if ((initialSize & (initialSize - 1)) != 0)
+    {
+        // Size of buckets must be power of 2
+        initialSize--;
+        initialSize |= initialSize >> 1;
+        initialSize |= initialSize >> 2;
+        initialSize |= initialSize >> 4;
+        initialSize |= initialSize >> 8;
+        initialSize |= initialSize >> 16;
+        initialSize++;
+    }
+
+    hash = (natsHash*) NATS_CALLOC(1, sizeof(natsHash));
+    if (hash == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    hash->mask      = (initialSize - 1);
+    hash->numBkts   = initialSize;
+    hash->canResize = true;
+    hash->bkts      = (natsHashEntry**) NATS_CALLOC(initialSize, sizeof(natsHashEntry*));
+    if (hash->bkts == NULL)
+    {
+        NATS_FREE(hash);
+        return nats_setDefaultError(NATS_NO_MEMORY);
+    }
+
+    *newHash = hash;
+
+    return NATS_OK;
+}
+
+static natsStatus
+_resize(natsHash *hash, int newSize)
+{
+    natsHashEntry   **bkts    = NULL;
+    int             newMask   = newSize - 1;
+    natsHashEntry   *ne;
+    natsHashEntry   *e;
+    int             k;
+    int             newIndex;
+
+    bkts = (natsHashEntry**) NATS_CALLOC(newSize, sizeof(natsHashEntry*));
+    if (bkts == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    for (k = 0; k < hash->numBkts; k++)
+    {
+        e = hash->bkts[k];
+        while (e != NULL)
+        {
+            ne = e;
+            e  = e->next;
+
+            newIndex = ne->key & newMask;
+            ne->next = bkts[newIndex];
+            bkts[newIndex] = ne;
+        }
+    }
+
+    NATS_FREE(hash->bkts);
+    hash->bkts = bkts;
+    hash->mask = newMask;
+    hash->numBkts = newSize;
+
+    return NATS_OK;
+}
+
+static natsStatus
+_grow(natsHash *hash)
+{
+    // Can't grow beyond max signed int for now
+    if (hash->numBkts >= _MAX_BKT_SIZE)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    return _resize(hash, 2 * (hash->numBkts));
+}
+
+static void
+_shrink(natsHash *hash)
+{
+    if (hash->numBkts <= _BSZ)
+        return;
+
+    // Ignore memory issue when resizing, since if we fail to allocate
+    // the original hash is still intact.
+    (void) _resize(hash, hash->numBkts / 2);
+}
+
+static natsHashEntry*
+_createEntry(int64_t key, void *data)
+{
+    natsHashEntry *e = (natsHashEntry*) NATS_MALLOC(sizeof(natsHashEntry));
+
+    if (e == NULL)
+        return NULL;
+
+    e->key  = key;
+    e->data = data;
+    e->next = NULL;
+
+    return e;
+}
+
+natsStatus
+natsHash_Set(natsHash *hash, int64_t key, void *data, void **oldData)
+{
+    natsStatus      s         = NATS_OK;
+    int             index     = (int) (key & hash->mask);
+    natsHashEntry   *newEntry = NULL;
+    natsHashEntry   *e;
+
+    if (oldData != NULL)
+        *oldData = NULL;
+
+    e = (natsHashEntry*) hash->bkts[index];
+    while (e != NULL)
+    {
+        if (e->key == key)
+        {
+            // Success, replace data field
+            if (oldData != NULL)
+                *oldData = e->data;
+            e->data  = data;
+            return NATS_OK;
+        }
+
+        e = e->next;
+    }
+
+    // We have a new entry here
+    newEntry = _createEntry(key, data);
+    if (newEntry == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    newEntry->next = hash->bkts[index];
+    hash->bkts[index] = newEntry;
+    hash->used++;
+
+    // Check for resizing
+    if (hash->canResize && (hash->used > hash->numBkts))
+        s = _grow(hash);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+void*
+natsHash_Get(natsHash *hash, int64_t key)
+{
+    natsHashEntry *e;
+
+    e = hash->bkts[key & hash->mask];
+    while (e != NULL)
+    {
+        if (e->key == key)
+            return e->data;
+
+        e = e->next;
+    }
+
+    return NULL;
+}
+
+void*
+natsHash_Remove(natsHash *hash, int64_t key)
+{
+    natsHashEntry *entryRemoved = NULL;
+    void          *dataRemoved  = NULL;
+    natsHashEntry **e;
+
+    e = (natsHashEntry**) &(hash->bkts[key & hash->mask]);
+    while (*e != NULL)
+    {
+        if ((*e)->key == key)
+        {
+            // Success
+            entryRemoved = *e;
+            dataRemoved  = entryRemoved->data;
+
+            *e = entryRemoved->next;
+            _freeEntry(entryRemoved);
+
+            hash->used--;
+
+            // Check for resizing
+            if (hash->canResize
+                && (hash->numBkts > _BSZ)
+                && (hash->used < hash->numBkts / 4))
+            {
+                _shrink(hash);
+            }
+
+            break;
+        }
+
+        e = (natsHashEntry**) &((*e)->next);
+    }
+
+    return dataRemoved;
+}
+
+void
+natsHash_Destroy(natsHash *hash)
+{
+    natsHashEntry   *e, *ne;
+    int             i;
+
+    if (hash == NULL)
+        return;
+
+    for (i = 0; i < hash->numBkts; i++)
+    {
+        e = hash->bkts[i];
+        while (e != NULL)
+        {
+            ne = e->next;
+
+            _freeEntry(e);
+
+            e = ne;
+        }
+    }
+
+    NATS_FREE(hash->bkts);
+    NATS_FREE(hash);
+}
+
+void
+natsHashIter_Init(natsHashIter *iter, natsHash *hash)
+{
+    memset(iter, 0, sizeof(natsHashIter));
+
+    hash->canResize = false;
+    iter->hash      = hash;
+    iter->current   = hash->bkts[0];
+    iter->next      = iter->current;
+}
+
+bool
+natsHashIter_Next(natsHashIter *iter, int64_t *key, void **value)
+{
+    if ((iter->started) && (iter->next == NULL))
+        return false;
+
+    if (!(iter->started) && (iter->current == NULL))
+    {
+        while ((iter->next == NULL)
+               && (iter->currBkt < (iter->hash->numBkts - 1)))
+        {
+            iter->next = iter->hash->bkts[++(iter->currBkt)];
+        }
+
+        if (iter->next == NULL)
+        {
+            iter->started = true;
+            return false;
+        }
+    }
+
+    iter->started = true;
+
+    iter->current = iter->next;
+    if (iter->current != NULL)
+    {
+        if (key != NULL)
+            *key = iter->current->key;
+        if (value != NULL)
+            *value = iter->current->data;
+
+        iter->next = iter->current->next;
+    }
+
+    while ((iter->next == NULL)
+           && (iter->currBkt < (iter->hash->numBkts - 1)))
+    {
+        iter->next = iter->hash->bkts[++(iter->currBkt)];
+    }
+
+    return true;
+}
+
+natsStatus
+natsHashIter_RemoveCurrent(natsHashIter *iter)
+{
+    int64_t key;
+
+    if (iter->current == NULL)
+        return nats_setDefaultError(NATS_NOT_FOUND);
+
+    key = iter->current->key;
+    iter->current = iter->next;
+
+    (void) natsHash_Remove(iter->hash, key);
+
+    return NATS_OK;
+}
+
+void
+natsHashIter_Done(natsHashIter *iter)
+{
+    iter->hash->canResize = true;
+}
+
+
+// Jesteress derivative of FNV1A from [http://www.sanmayce.com/Fastest_Hash/]
+uint32_t
+natsStrHash_Hash(const char *data, int dataLen)
+{
+    int      i      = 0;
+    int      dlen   = dataLen;
+    uint32_t h32    = (uint32_t)_OFF32;
+    uint64_t k1, k2;
+
+    for (; dlen >= _DDWSZ; dlen -= _DDWSZ)
+    {
+        k1  = *(uint64_t*) &(data[i]);
+        k2  = *(uint64_t*) &(data[i + 4]);
+        h32 = (uint32_t) ((((uint64_t) h32) ^ ((k1<<5 | k1>>27) ^ k2)) * _YP32);
+        i += _DDWSZ;
+    }
+
+    // Cases: 0,1,2,3,4,5,6,7
+    if ((dlen & _DWSZ) > 0)
+    {
+        k1  = *(uint64_t*) &(data[i]);
+        h32 = (uint32_t) ((((uint64_t) h32) ^ k1) * _YP32);
+        i += _DWSZ;
+    }
+    if ((dlen & _WSZ) > 0)
+    {
+        k1  = *(uint32_t*) &(data[i]);
+        h32 = (uint32_t) ((((uint64_t) h32) ^ k1) * _YP32);
+        i += _WSZ;
+    }
+    if ((dlen & 1) > 0)
+    {
+        h32 = (h32 ^ (uint32_t)(data[i])) * _YP32;
+    }
+
+    return h32 ^ (h32 >> 16);
+}
+
+natsStatus
+natsStrHash_Create(natsStrHash **newHash, int initialSize)
+{
+    natsStrHash *hash = NULL;
+
+    if (initialSize <= 0)
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    if ((initialSize & (initialSize - 1)) != 0)
+    {
+        // Size of buckets must be power of 2
+        initialSize--;
+        initialSize |= initialSize >> 1;
+        initialSize |= initialSize >> 2;
+        initialSize |= initialSize >> 4;
+        initialSize |= initialSize >> 8;
+        initialSize |= initialSize >> 16;
+        initialSize++;
+    }
+
+    hash = (natsStrHash*) NATS_CALLOC(1, sizeof(natsStrHash));
+    if (hash == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    hash->mask      = (initialSize - 1);
+    hash->numBkts   = initialSize;
+    hash->canResize = true;
+    hash->bkts      = (natsStrHashEntry**) NATS_CALLOC(initialSize, sizeof(natsStrHashEntry*));
+    if (hash->bkts == NULL)
+    {
+        NATS_FREE(hash);
+        return nats_setDefaultError(NATS_NO_MEMORY);
+    }
+
+    *newHash = hash;
+
+    return NATS_OK;
+}
+
+static natsStatus
+_resizeStr(natsStrHash *hash, int newSize)
+{
+    natsStrHashEntry    **bkts    = NULL;
+    int                 newMask   = newSize - 1;
+    natsStrHashEntry    *ne;
+    natsStrHashEntry    *e;
+    int                 k;
+    int                 newIndex;
+
+    bkts = (natsStrHashEntry**) NATS_CALLOC(newSize, sizeof(natsStrHashEntry*));
+    if (bkts == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    for (k = 0; k < hash->numBkts; k++)
+    {
+        e = hash->bkts[k];
+        while (e != NULL)
+        {
+            ne = e;
+            e  = e->next;
+
+            newIndex = ne->hk & newMask;
+            ne->next = bkts[newIndex];
+            bkts[newIndex] = ne;
+        }
+    }
+
+    NATS_FREE(hash->bkts);
+    hash->bkts = bkts;
+    hash->mask = newMask;
+    hash->numBkts = newSize;
+
+    return NATS_OK;
+}
+
+static natsStatus
+_growStr(natsStrHash *hash)
+{
+    // Can't grow beyond max signed int for now
+    if (hash->numBkts >= _MAX_BKT_SIZE)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    return _resizeStr(hash, 2 * (hash->numBkts));
+}
+
+static void
+_shrinkStr(natsStrHash *hash)
+{
+    if (hash->numBkts <= _BSZ)
+        return;
+
+    // Ignore memory issue when resizing, since if we fail to allocate
+    // the original hash is still intact.
+    (void) _resizeStr(hash, hash->numBkts / 2);
+}
+
+
+static natsStrHashEntry*
+_createStrEntry(uint32_t hk, char *key, bool copyKey, void *data)
+{
+    natsStrHashEntry *e = (natsStrHashEntry*) NATS_MALLOC(sizeof(natsStrHashEntry));
+
+    if (e == NULL)
+        return NULL;
+
+    e->hk       = hk;
+    e->key      = (copyKey ? NATS_STRDUP(key) : key);
+    e->freeKey  = copyKey;
+    e->data     = data;
+    e->next     = NULL;
+
+    if (e->key == NULL)
+    {
+        NATS_FREE(e);
+        return NULL;
+    }
+
+    return e;
+}
+
+natsStatus
+natsStrHash_Set(natsStrHash *hash, char *key, bool copyKey,
+                void *data, void **oldData)
+{
+    natsStatus          s         = NATS_OK;
+    uint32_t            hk        = 0;
+    int                 index     = 0;
+    natsStrHashEntry    *newEntry = NULL;
+    natsStrHashEntry    *e;
+    char                *oldKey;
+
+    if (oldData != NULL)
+        *oldData = NULL;
+
+    hk    = natsStrHash_Hash(key, (int) strlen(key));
+    index = hk & hash->mask;
+
+    e = (natsStrHashEntry*) hash->bkts[index];
+    while (e != NULL)
+    {
+        if ((e->hk == hk)
+            && (strcmp(e->key, key) == 0))
+        {
+            // Success, replace data field
+            if (oldData != NULL)
+                *oldData = e->data;
+            e->data  = data;
+
+            if (copyKey)
+            {
+                oldKey = e->key;
+                e->key = NATS_STRDUP(key);
+
+                if (e->freeKey)
+                    NATS_FREE(oldKey);
+
+                e->freeKey = true;
+            }
+            return NATS_OK;
+        }
+
+        e = e->next;
+    }
+
+    // We have a new entry here
+    newEntry = _createStrEntry(hk, key, copyKey, data);
+    if (newEntry == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    newEntry->next = hash->bkts[index];
+    hash->bkts[index] = newEntry;
+    hash->used++;
+
+    // Check for resizing
+    if (hash->canResize && (hash->used > hash->numBkts))
+        s = _growStr(hash);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+void*
+natsStrHash_Get(natsStrHash *hash, char *key)
+{
+    natsStrHashEntry    *e;
+    uint32_t            hk = natsStrHash_Hash(key, (int) strlen(key));
+
+    e = hash->bkts[hk & hash->mask];
+    while (e != NULL)
+    {
+        if ((e->hk == hk)
+            && (strcmp(e->key, key) == 0))
+        {
+            return e->data;
+        }
+
+        e = e->next;
+    }
+
+    return NULL;
+}
+
+static void
+_freeStrEntry(natsStrHashEntry *e)
+{
+    if (e->freeKey)
+        NATS_FREE(e->key);
+
+    NATS_FREE(e);
+}
+
+void*
+natsStrHash_Remove(natsStrHash *hash, char *key)
+{
+    natsStrHashEntry    *entryRemoved = NULL;
+    void                *dataRemoved  = NULL;
+    natsStrHashEntry    **e;
+    uint32_t            hk;
+
+    hk = natsStrHash_Hash(key, (int) strlen(key));
+
+    e = (natsStrHashEntry**) &(hash->bkts[hk & hash->mask]);
+    while (*e != NULL)
+    {
+        if (((*e)->hk == hk)
+            && (strcmp((*e)->key, key) == 0))
+        {
+            // Success
+            entryRemoved = *e;
+            dataRemoved  = entryRemoved->data;
+
+            *e = entryRemoved->next;
+            _freeStrEntry(entryRemoved);
+
+            hash->used--;
+
+            // Check for resizing
+            if (hash->canResize
+                && (hash->numBkts > _BSZ)
+                && (hash->used < hash->numBkts / 4))
+            {
+                _shrinkStr(hash);
+            }
+
+            break;
+        }
+
+        e = (natsStrHashEntry**) &((*e)->next);
+    }
+
+    return dataRemoved;
+}
+
+void
+natsStrHash_Destroy(natsStrHash *hash)
+{
+    natsStrHashEntry    *e, *ne;
+    int                 i;
+
+    if (hash == NULL)
+        return;
+
+    for (i = 0; i < hash->numBkts; i++)
+    {
+        e = hash->bkts[i];
+        while (e != NULL)
+        {
+            ne = e->next;
+
+            _freeStrEntry(e);
+
+            e = ne;
+        }
+    }
+
+    NATS_FREE(hash->bkts);
+    NATS_FREE(hash);
+}
+
+void
+natsStrHashIter_Init(natsStrHashIter *iter, natsStrHash *hash)
+{
+    memset(iter, 0, sizeof(natsStrHashIter));
+
+    hash->canResize = false;
+    iter->hash      = hash;
+    iter->current   = hash->bkts[0];
+    iter->next      = iter->current;
+}
+
+bool
+natsStrHashIter_Next(natsStrHashIter *iter, char **key, void **value)
+{
+    if ((iter->started) && (iter->next == NULL))
+        return false;
+
+    if (!(iter->started) && (iter->current == NULL))
+    {
+        while ((iter->next == NULL)
+               && (iter->currBkt < (iter->hash->numBkts - 1)))
+        {
+            iter->next = iter->hash->bkts[++(iter->currBkt)];
+        }
+
+        if (iter->next == NULL)
+        {
+            iter->started = true;
+            return false;
+        }
+    }
+
+    iter->started = true;
+
+    iter->current = iter->next;
+    if (iter->current != NULL)
+    {
+        if (key != NULL)
+            *key = iter->current->key;
+        if (value != NULL)
+            *value = iter->current->data;
+
+        iter->next = iter->current->next;
+    }
+
+    while ((iter->next == NULL)
+           && (iter->currBkt < (iter->hash->numBkts - 1)))
+    {
+        iter->next = iter->hash->bkts[++(iter->currBkt)];
+    }
+
+    return true;
+}
+
+natsStatus
+natsStrHashIter_RemoveCurrent(natsStrHashIter *iter)
+{
+    char *key;
+
+    if (iter->current == NULL)
+        return nats_setDefaultError(NATS_NOT_FOUND);
+
+    key = iter->current->key;
+    iter->current = iter->next;
+
+    (void) natsStrHash_Remove(iter->hash, key);
+
+    return NATS_OK;
+}
+
+void
+natsStrHashIter_Done(natsStrHashIter *iter)
+{
+    natsHashIter_Done((natsHashIter*) iter);
+}