ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/src/util.h

@@ -0,0 +1,75 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef UTIL_H_
+#define UTIL_H_
+
+#include "natsp.h"
+
+#define TYPE_NOT_SET    (0)
+#define TYPE_STR        (1)
+#define TYPE_BOOL       (2)
+#define TYPE_NUM        (3)
+#define TYPE_INT        (4)
+#define TYPE_LONG       (5)
+#define TYPE_DOUBLE     (6)
+#define TYPE_ARRAY      (7)
+
+typedef struct
+{
+    void    **values;
+    int     typ;
+    int     eltSize;
+    int     size;
+    int     cap;
+
+} nats_JSONArray;
+
+typedef struct
+{
+    char    *name;
+    int     typ;
+    union
+    {
+            char            *vstr;
+            bool            vbool;
+            long double     vdec;
+            nats_JSONArray  *varr;
+    } value;
+
+} nats_JSONField;
+
+typedef struct
+{
+    char        *str;
+    natsStrHash *fields;
+
+} nats_JSON;
+
+int64_t
+nats_ParseInt64(const char *d, int dLen);
+
+natsStatus
+nats_ParseControl(natsControl *control, const char *line);
+
+natsStatus
+nats_CreateStringFromBuffer(char **newStr, natsBuffer *buf);
+
+const char*
+nats_GetBoolStr(bool value);
+
+void
+nats_NormalizeErr(char *error);
+
+natsStatus
+nats_JSONParse(nats_JSON **json, const char *str, int strLen);
+
+natsStatus
+nats_JSONGetValue(nats_JSON *json, const char *fieldName, int fieldType, void **addr);
+
+natsStatus
+nats_JSONGetArrayValue(nats_JSON *json, const char *fieldName, int fieldType, void ***array, int *arraySize);
+
+void
+nats_JSONDestroy(nats_JSON *json);
+
+#endif /* UTIL_H_ */

data/vendor/cnats/src/version.h

@@ -0,0 +1,29 @@
+/*
+ * DO NOT EDIT! Generated during make process.
+ * Copyright 2015 Apcera Inc. All rights reserved.
+ */
+
+#ifndef VERSION_H_
+#define VERSION_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NATS_VERSION_MAJOR  1
+#define NATS_VERSION_MINOR  5
+#define NATS_VERSION_PATCH  0
+
+#define NATS_VERSION_STRING "1.5.0"
+			 				  
+#define NATS_VERSION_NUMBER ((NATS_VERSION_MAJOR << 16) | \
+                             (NATS_VERSION_MINOR <<  8) | \
+                             NATS_VERSION_PATCH)
+                             
+#define NATS_VERSION_REQUIRED_NUMBER 0x010100                             
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VERSION_H_ */

data/vendor/cnats/src/version.h.in

@@ -0,0 +1,29 @@
+/*
+ * DO NOT EDIT! Generated during make process.
+ * Copyright 2015 Apcera Inc. All rights reserved.
+ */
+
+#ifndef VERSION_H_
+#define VERSION_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NATS_VERSION_MAJOR  @NATS_VERSION_MAJOR@
+#define NATS_VERSION_MINOR  @NATS_VERSION_MINOR@
+#define NATS_VERSION_PATCH  @NATS_VERSION_PATCH@
+
+#define NATS_VERSION_STRING "@NATS_VERSION_MAJOR@.@NATS_VERSION_MINOR@.@NATS_VERSION_PATCH@@NATS_VERSION_SUFFIX@"
+			 				  
+#define NATS_VERSION_NUMBER ((NATS_VERSION_MAJOR << 16) | \
+                             (NATS_VERSION_MINOR <<  8) | \
+                             NATS_VERSION_PATCH)
+                             
+#define NATS_VERSION_REQUIRED_NUMBER @NATS_VERSION_REQUIRED_NUMBER@                             
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VERSION_H_ */

data/vendor/cnats/src/win/cond.c

@@ -0,0 +1,86 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+#include "../mem.h"
+
+natsStatus
+natsCondition_Create(natsCondition **cond)
+{
+    natsCondition   *c = (natsCondition*) NATS_CALLOC(1, sizeof(natsCondition));
+    natsStatus      s  = NATS_OK;
+
+    if (c == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    InitializeConditionVariable(c);
+    *cond = c;
+
+    return s;
+}
+
+void
+natsCondition_Wait(natsCondition *cond, natsMutex *mutex)
+{
+    if (SleepConditionVariableCS(cond, mutex, INFINITE) == 0)
+        abort();
+}
+
+natsStatus
+natsCondition_TimedWait(natsCondition *cond, natsMutex *mutex, int64_t timeout)
+{
+    if (timeout <= 0)
+        return NATS_TIMEOUT;
+
+    if (SleepConditionVariableCS(cond, mutex, (DWORD) timeout) == 0)
+    {
+        if (GetLastError() == ERROR_TIMEOUT)
+            return NATS_TIMEOUT;
+
+        abort();
+    }
+
+    return NATS_OK;
+}
+
+natsStatus
+natsCondition_AbsoluteTimedWait(natsCondition *cond, natsMutex *mutex, int64_t absoluteTime)
+{
+    int64_t now = nats_Now();;
+    int64_t sleepTime = absoluteTime - now;
+
+    if (sleepTime <= 0)
+        return NATS_TIMEOUT;
+
+    if (SleepConditionVariableCS(cond, mutex, (DWORD) sleepTime) == 0)
+    {
+        if (GetLastError() == ERROR_TIMEOUT)
+            return NATS_TIMEOUT;
+
+        return nats_setError(NATS_SYS_ERROR,
+                             "SleepConditionVariableCS error: %d",
+                             GetLastError());
+    }
+
+    return NATS_OK;
+}
+
+void
+natsCondition_Signal(natsCondition *cond)
+{
+    WakeConditionVariable(cond);
+}
+
+void
+natsCondition_Broadcast(natsCondition *cond)
+{
+    WakeAllConditionVariable(cond);
+}
+
+void
+natsCondition_Destroy(natsCondition *cond)
+{
+    if (cond == NULL)
+        return;
+
+    NATS_FREE(cond);
+}

data/vendor/cnats/src/win/mutex.c

@@ -0,0 +1,54 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+#include "../mem.h"
+
+natsStatus
+natsMutex_Create(natsMutex **newMutex)
+{
+    natsMutex *m = NATS_CALLOC(1, sizeof(natsMutex));
+
+    if (m == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    if (gLockSpinCount > 0)
+        InitializeCriticalSectionAndSpinCount(m, (DWORD) gLockSpinCount);
+    else
+        InitializeCriticalSection(m);
+    *newMutex = m;
+
+    return NATS_OK;
+}
+
+bool
+natsMutex_TryLock(natsMutex *m)
+{
+    if (TryEnterCriticalSection(m) == 0)
+        return false;
+
+    return true;
+}
+
+void
+natsMutex_Lock(natsMutex *m)
+{
+    // If gLockSpinCount > 0, the mutex has been created as as spin lock,
+    // so we don't have to do anything special here.
+    EnterCriticalSection(m);
+}
+
+void
+natsMutex_Unlock(natsMutex *m)
+{
+    LeaveCriticalSection(m);
+}
+
+void
+natsMutex_Destroy(natsMutex *m)
+{
+    if (m == NULL)
+        return;
+
+    DeleteCriticalSection(m);
+    NATS_FREE(m);
+}

data/vendor/cnats/src/win/sock.c

@@ -0,0 +1,158 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+
+#include <errno.h>
+#include <io.h>
+
+#include "../mem.h"
+#include "../comsock.h"
+
+void
+natsSys_Init(void)
+{
+    WSADATA wsaData;
+    int     errorno;
+
+    /* Initialize winsock */
+    errorno = WSAStartup(MAKEWORD(2, 2), &wsaData);
+    if (errorno != 0)
+    {
+        printf("FATAL: Unable to initialize winsock!\n");
+        abort();
+    }
+}
+
+natsStatus
+natsSock_Init(natsSockCtx *ctx)
+{
+    natsStatus  s;
+
+    memset(ctx, 0, sizeof(natsSockCtx));
+
+    ctx->fd = NATS_SOCK_INVALID;
+
+    s = natsSock_CreateFDSet(&ctx->fdSet);
+    if (s == NATS_OK)
+    {
+        s = natsSock_CreateFDSet(&ctx->errSet);
+        if (s != NATS_OK)
+        {
+            natsSock_DestroyFDSet(ctx->fdSet);
+            ctx->fdSet = NULL;
+        }
+    }
+    return s;
+}
+
+void
+natsSock_Clear(natsSockCtx *ctx)
+{
+    natsSock_DestroyFDSet(ctx->fdSet);
+    natsSock_DestroyFDSet(ctx->errSet);
+}
+
+natsStatus
+natsSock_WaitReady(int waitMode, natsSockCtx *ctx)
+{
+    struct timeval  *timeout = NULL;
+    int             res;
+    fd_set          *fdSet = ctx->fdSet;
+    fd_set          *errSet = ctx->errSet;
+    natsSock        sock = ctx->fd;
+    natsDeadline    *deadline = &(ctx->deadline);
+
+    FD_ZERO(fdSet);
+    FD_SET(sock, fdSet);
+
+    FD_ZERO(errSet);
+    FD_SET(sock, errSet);
+
+    if (deadline != NULL)
+        timeout = natsDeadline_GetTimeout(deadline);
+
+    switch (waitMode)
+    {
+        case WAIT_FOR_READ:     res = select((int) (sock + 1), fdSet, NULL, NULL, timeout); break;
+        case WAIT_FOR_WRITE:    res = select((int) (sock + 1), NULL, fdSet, NULL, timeout); break;
+        // On Windows, we will know if the non-blocking connect has failed
+        // by using the exception set, not the write set.
+        case WAIT_FOR_CONNECT:  res = select((int) (sock + 1), NULL, fdSet, errSet, timeout); break;
+        default: abort();
+    }
+
+    if (res == NATS_SOCK_ERROR)
+        return nats_setError(NATS_IO_ERROR, "select error: %d", res);
+
+    // Not ready if select returned no socket, the socket is not in the
+    // given fdSet, or for connect, the socket is set in the error set.
+    if ((res == 0)
+            || !FD_ISSET(sock, fdSet)
+            || ((waitMode == WAIT_FOR_CONNECT) && FD_ISSET(sock, errSet)))
+    {
+        return nats_setDefaultError(NATS_TIMEOUT);
+    }
+
+    return NATS_OK;
+}
+
+natsStatus
+natsSock_SetBlocking(natsSock fd, bool blocking)
+{
+    u_long iMode = 0;
+
+    // If iMode = 0, blocking is enabled;
+    // If iMode != 0, non-blocking mode is enabled.
+    if (!blocking)
+        iMode = 1;
+
+    if (ioctlsocket(fd, FIONBIO, &iMode) != NO_ERROR)
+        return nats_setError(NATS_SYS_ERROR,
+                             "ioctlsocket error: %d",
+                             NATS_SOCK_GET_ERROR);
+
+    return NATS_OK;
+}
+
+bool
+natsSock_IsConnected(natsSock fd)
+{
+    int res;
+    int error = 0;
+    int errorLen = (socklen_t) sizeof(int);
+
+    res = getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&error, &errorLen);
+    if ((res == NATS_SOCK_ERROR) || (error != 0))
+        return false;
+
+    return true;
+}
+
+natsStatus
+natsSock_Flush(natsSock fd)
+{
+    HANDLE fh = (HANDLE)_get_osfhandle((int) fd);
+
+    if (fh == INVALID_HANDLE_VALUE)
+    {
+        errno = EBADF;
+        return nats_setError(NATS_INVALID_ARG, "%s",
+                             "Error setting flushing socket. Invalid handle");
+    }
+
+    if (!FlushFileBuffers(fh))
+    {
+        DWORD code = GetLastError();
+
+        if (code == ERROR_INVALID_HANDLE)
+            errno = EINVAL;
+        else
+            errno = EIO;
+
+        return nats_setError(NATS_IO_ERROR,
+                             "Error setting flushing socket. Error: %d",
+                             NATS_SOCK_GET_ERROR);
+    }
+
+    return NATS_OK;
+}

data/vendor/cnats/src/win/strings.c

@@ -0,0 +1,108 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "../natsp.h"
+
+#include "../mem.h"
+
+int
+nats_asprintf(char **newStr, const char *fmt, ...)
+{
+    char    tmp[256];
+    char    *str;
+    int     n, size;
+    va_list ap;
+
+    size = sizeof(tmp);
+    str  = (char*) tmp;
+
+    do
+    {
+        va_start(ap, fmt);
+        n = vsnprintf(str, size, fmt, ap);
+        va_end(ap);
+
+        if ((n < 0) || (n >= size))
+        {
+            // We failed, but we don't know how much we need, so start with
+            // doubling the size and see if it's better.
+            if (n < 0)
+            {
+                size *= 2;
+            }
+            else
+            {
+                // We know exactly how much we need.
+                size = (n + 1);
+
+                // now set n to -1 so that we loop again.
+                n = -1;
+            }
+
+            if (str != tmp)
+            {
+                char *realloced = NULL;
+
+                realloced = NATS_REALLOC(str, size);
+                if (realloced == NULL)
+                {
+                    NATS_FREE(str);
+                    str = NULL;
+                }
+                else
+                {
+                    str = realloced;
+                }
+            }
+            else
+            {
+                str = NATS_MALLOC(size);
+            }
+        }
+    }
+    while ((n < 0) && (str != NULL));
+
+    if (str != NULL)
+    {
+        if (str != tmp)
+            *newStr = str;
+        else
+            *newStr = NATS_STRDUP(str);
+
+        if (*newStr == NULL)
+            n = -1;
+    }
+
+    return n;
+}
+
+char*
+nats_strcasestr(const char *haystack, const char *needle)
+{
+    char *lowHaystack = NATS_STRDUP(haystack);
+    char *lowNeedle   = NATS_STRDUP(needle);
+    char *res         = NULL;
+    int  offset       = 0;
+
+    if ((lowHaystack == NULL) || (lowNeedle == NULL))
+    {
+        NATS_FREE(lowHaystack);
+        NATS_FREE(lowNeedle);
+        return NULL;
+    }
+
+    _strlwr(lowHaystack);
+    _strlwr(lowNeedle);
+
+    res = strstr((const char*) lowHaystack, (const char*) lowNeedle);
+    if (res != NULL)
+    {
+        offset = (int) (res - lowHaystack);
+        res = (char *) (haystack + offset);
+    }
+
+    NATS_FREE(lowHaystack);
+    NATS_FREE(lowNeedle);
+
+    return res;
+}
+