ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/src/hash.h

@@ -0,0 +1,141 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+
+#ifndef HASH_H_
+#define HASH_H_
+
+struct __natsHashEntry;
+
+typedef struct __natsHashEntry
+{
+    int64_t                 key;
+    void                    *data;
+    struct __natsHashEntry  *next;
+
+} natsHashEntry;
+
+typedef struct __natsHash
+{
+    natsHashEntry   **bkts;
+    int             numBkts;
+    int             mask;
+    int             used;
+    bool            canResize;
+
+} natsHash;
+
+typedef struct __natsHashIter
+{
+    natsHash        *hash;
+    natsHashEntry   *current;
+    natsHashEntry   *next;
+    int             currBkt;
+    bool            started;
+
+} natsHashIter;
+
+typedef struct __natsStrHashEntry
+{
+    uint32_t                    hk;
+    char                        *key;
+    bool                        freeKey;
+    void                        *data;
+    struct __natsStrHashEntry   *next;
+
+} natsStrHashEntry;
+
+typedef struct __natsStrHash
+{
+    natsStrHashEntry    **bkts;
+    int                 numBkts;
+    int                 mask;
+    int                 used;
+    bool                canResize;
+
+} natsStrHash;
+
+typedef struct __natsStrHashIter
+{
+    natsStrHash         *hash;
+    natsStrHashEntry    *current;
+    natsStrHashEntry    *next;
+    int                 currBkt;
+    bool                started;
+
+} natsStrHashIter;
+
+#define natsHash_Count(h)       ((h)->used)
+#define natsStrHash_Count(h)    ((h)->used)
+
+//
+// Hash with in64_t as the key
+//
+natsStatus
+natsHash_Create(natsHash **newHash, int initialSize);
+
+natsStatus
+natsHash_Set(natsHash *hash, int64_t key, void *data, void **oldData);
+
+void*
+natsHash_Get(natsHash *hash, int64_t key);
+
+void*
+natsHash_Remove(natsHash *hash, int64_t key);
+
+void
+natsHash_Destroy(natsHash *hash);
+
+//
+// Iterator for Hash int64_t
+//
+void
+natsHashIter_Init(natsHashIter *iter, natsHash *hash);
+
+bool
+natsHashIter_Next(natsHashIter *iter, int64_t *key, void **value);
+
+natsStatus
+natsHashIter_RemoveCurrent(natsHashIter *iter);
+
+void
+natsHashIter_Done(natsHashIter *iter);
+
+//
+// Hash with char* as the key
+//
+natsStatus
+natsStrHash_Create(natsStrHash **newHash, int initialSize);
+
+uint32_t
+natsStrHash_Hash(const char *data, int dataLen);
+
+natsStatus
+natsStrHash_Set(natsStrHash *hash, char *key, bool copyKey,
+                void *data, void **oldData);
+
+void*
+natsStrHash_Get(natsStrHash *hash, char *key);
+
+void*
+natsStrHash_Remove(natsStrHash *hash, char *key);
+
+void
+natsStrHash_Destroy(natsStrHash *hash);
+
+//
+// Iterator for Hash char*
+//
+void
+natsStrHashIter_Init(natsStrHashIter *iter, natsStrHash *hash);
+
+bool
+natsStrHashIter_Next(natsStrHashIter *iter, char **key, void **value);
+
+natsStatus
+natsStrHashIter_RemoveCurrent(natsStrHashIter *iter);
+
+void
+natsStrHashIter_Done(natsStrHashIter *iter);
+
+
+#endif /* HASH_H_ */

data/vendor/cnats/src/include/n-unix.h

@@ -0,0 +1,56 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef N_UNIX_H_
+#define N_UNIX_H_
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef DARWIN
+#define FD_SETSIZE  (32768)
+#else
+#include <sys/types.h>
+#undef __FD_SETSIZE
+#define __FD_SETSIZE (32768)
+#include <sys/select.h>
+#endif
+
+#include <sys/time.h>
+#include <fcntl.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <string.h>
+
+typedef pthread_t       natsThread;
+typedef pthread_key_t   natsThreadLocal;
+typedef pthread_mutex_t natsMutex;
+typedef pthread_cond_t  natsCondition;
+typedef pthread_once_t  natsInitOnceType;
+typedef socklen_t       natsSockLen;
+typedef size_t          natsRecvLen;
+
+#define NATS_ONCE_STATIC_INIT   PTHREAD_ONCE_INIT
+
+#define NATS_SOCK_INVALID               (-1)
+#define NATS_SOCK_SHUTDOWN(s)           (shutdown((s), SHUT_RDWR))
+#define NATS_SOCK_CLOSE(s)              (close((s)))
+#define NATS_SOCK_CONNECT_IN_PROGRESS   (EINPROGRESS)
+#define NATS_SOCK_WOULD_BLOCK           (EWOULDBLOCK)
+#define NATS_SOCK_ERROR                 (-1)
+#define NATS_SOCK_GET_ERROR             (errno)
+
+#define __NATS_FUNCTION__ __func__
+
+#define nats_asprintf       asprintf
+#define nats_strcasestr     strcasestr
+
+#endif /* N_UNIX_H_ */

data/vendor/cnats/src/include/n-win.h

@@ -0,0 +1,59 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef N_WIN_H_
+#define N_WIN_H_
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#define _CRT_SECURE_NO_WARNINGS
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma warning(disable : 4996)
+
+typedef struct __natsThread
+{
+    HANDLE  t;
+    DWORD   id;
+
+} natsThread;
+
+typedef DWORD               natsThreadLocal;
+
+typedef CRITICAL_SECTION    natsMutex;
+typedef CONDITION_VARIABLE  natsCondition;
+typedef INIT_ONCE           natsInitOnceType;
+typedef int                 natsSockLen;
+typedef int                 natsRecvLen;
+
+#define NATS_ONCE_TYPE          INIT_ONCE
+#define NATS_ONCE_STATIC_INIT   INIT_ONCE_STATIC_INIT
+
+#define NATS_SOCK_INVALID               (INVALID_SOCKET)
+#define NATS_SOCK_CLOSE(s)              closesocket((s))
+#define NATS_SOCK_SHUTDOWN(s)           shutdown((s), SD_BOTH)
+#define NATS_SOCK_CONNECT_IN_PROGRESS   (WSAEWOULDBLOCK)
+#define NATS_SOCK_WOULD_BLOCK           (WSAEWOULDBLOCK)
+#define NATS_SOCK_ERROR                 (SOCKET_ERROR)
+#define NATS_SOCK_GET_ERROR             WSAGetLastError()
+
+#define __NATS_FUNCTION__ __FUNCTION__
+
+// Windows doesn't have those..
+// snprintf support is introduced starting MSVC 14.0 (_MSC_VER 1900: Visual Studio 2015)
+#if _MSC_VER < 1900
+#define snprintf _snprintf
+#endif
+#define strcasecmp  _stricmp
+
+int
+nats_asprintf(char **newStr, const char *fmt, ...);
+
+char*
+nats_strcasestr(const char *haystack, const char *needle);
+
+#endif /* N_WIN_H_ */

data/vendor/cnats/src/mem.h

@@ -0,0 +1,20 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef MEM_H_
+#define MEM_H_
+
+#include <stdlib.h>
+
+#define NATS_MALLOC(s)      malloc((s))
+#define NATS_CALLOC(c,s)    calloc((c), (s))
+#define NATS_REALLOC(p, s)  realloc((p), (s))
+
+#ifdef _WIN32
+#define NATS_STRDUP(s)      _strdup((s))
+#else
+#define NATS_STRDUP(s)      strdup((s))
+#endif
+#define NATS_FREE(p)        free((p))
+
+
+#endif /* MEM_H_ */

data/vendor/cnats/src/msg.c

@@ -0,0 +1,155 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+#include "natsp.h"
+
+// Do this after including natsp.h in order to have some of the
+// GNU specific flag set first.
+#include <string.h>
+
+#include "mem.h"
+
+void
+natsMsg_free(void *object)
+{
+    natsMsg *msg;
+
+    if (object == NULL)
+        return;
+
+    msg = (natsMsg*) object;
+
+    NATS_FREE(msg);
+}
+
+void
+natsMsg_Destroy(natsMsg *msg)
+{
+    if (msg == NULL)
+        return;
+
+    if (natsGC_collect((natsGCItem *) msg))
+        return;
+
+    natsMsg_free((void*) msg);
+}
+
+const char*
+natsMsg_GetSubject(natsMsg *msg)
+{
+    if (msg == NULL)
+        return NULL;
+
+    return (const char*) msg->subject;
+}
+
+const char*
+natsMsg_GetReply(natsMsg *msg)
+{
+    if (msg == NULL)
+        return NULL;
+
+    return (const char*) msg->reply;
+}
+
+const char*
+natsMsg_GetData(natsMsg *msg)
+{
+    if (msg == NULL)
+        return NULL;
+
+    return (const char*) msg->data;
+}
+
+int
+natsMsg_GetDataLength(natsMsg *msg)
+{
+    if (msg == NULL)
+        return 0;
+
+    return msg->dataLen;
+}
+
+natsStatus
+natsMsg_create(natsMsg **newMsg,
+               const char *subject, int subjLen,
+               const char *reply, int replyLen,
+               const char *buf, int bufLen)
+{
+    natsMsg     *msg      = NULL;
+    char        *ptr      = NULL;
+    int         bufSize   = 0;
+
+    bufSize  = subjLen;
+    bufSize += 1;
+    bufSize += replyLen;
+    bufSize += 1;
+    bufSize += bufLen;
+    bufSize += 1;
+
+    msg = NATS_MALLOC(sizeof(natsMsg) + bufSize);
+    if (msg == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    // To be safe, we could 'memset' the message up to sizeof(natsMsg),
+    // but since we are explicitly initializing most of the fields, we save
+    // on that call, but we need to make sure what we initialize all fields!!!
+
+    // That being said, we memset the 'gc' structure to protect us in case
+    // some fields are later added to this 'external' structure and we forget
+    // about updating this initialization code.
+    memset(&(msg->gc), 0, sizeof(natsGCItem));
+
+    msg->sub  = NULL;
+    msg->next = NULL;
+
+    ptr = (char*) (((char*) &(msg->next)) + sizeof(msg->next));
+
+    msg->subject = (const char*) ptr;
+    memcpy(ptr, subject, subjLen);
+    ptr += subjLen;
+    *(ptr++) = '\0';
+
+    msg->reply = (const char*) ptr;
+    if (replyLen > 0)
+    {
+        memcpy(ptr, reply, replyLen);
+        ptr += replyLen;
+    }
+    *(ptr++) = '\0';
+
+    msg->data    = (const char*) ptr;
+    msg->dataLen = bufLen;
+    memcpy(ptr, buf, bufLen);
+    ptr += bufLen;
+    *(ptr) = '\0';
+
+    // Setting the callback will trigger garbage collection when
+    // natsMsg_Destroy() is invoked.
+    msg->gc.freeCb = natsMsg_free;
+
+    *newMsg = msg;
+
+    return NATS_OK;
+}
+
+natsStatus
+natsMsg_Create(natsMsg **newMsg, const char *subj, const char *reply,
+               const char *data, int dataLen)
+{
+    natsStatus  s = NATS_OK;
+
+    if ((subj == NULL)
+        || (subj[0] == '\0')
+        || ((reply != NULL) && (reply[0] == '\0')))
+    {
+        return nats_setDefaultError(NATS_INVALID_ARG);
+    }
+
+    s = natsMsg_create(newMsg,
+                       subj, (int) strlen(subj),
+                       reply, (reply == NULL ? 0 : (int) strlen(reply)),
+                       data, dataLen);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+

data/vendor/cnats/src/msg.h

@@ -0,0 +1,43 @@
+// Copyright 2015-2016 Apcera Inc. All rights reserved.
+
+#ifndef MSG_H_
+#define MSG_H_
+
+#include "status.h"
+#include "gc.h"
+
+struct __natsMsg;
+
+struct __natsMsg
+{
+    natsGCItem          gc;
+
+    // The message is allocated as a single memory block that contains
+    // this structure and enough space for the payload. The msg payload
+    // starts after the 'next' pointer.
+    const char          *subject;
+    const char          *reply;
+    const char          *data;
+    int                 dataLen;
+
+    // subscription (needed when delivery done by connection)
+    struct __natsSubscription *sub;
+
+    // Must be last field!
+    struct __natsMsg    *next;
+
+    // Nothing after this: the message payload goes there.
+
+};
+
+natsStatus
+natsMsg_create(natsMsg **newMsg,
+               const char *subject, int subjLen,
+               const char *reply, int replyLen,
+               const char *buf, int bufLen);
+
+// This needs to follow the nats_FreeObjectCb prototype (see gc.h)
+void
+natsMsg_free(void *object);
+
+#endif /* MSG_H_ */