ffi-nats-core 0.3.0 → 0.3.1

data/vendor/cnats/src/CMakeLists.txt

@@ -0,0 +1,31 @@
+#------------------------
+# Add the sub-directories
+#------------------------
+include_directories(include)
+include_directories(${NATS_PLATFORM_INCLUDE})
+if(NATS_BUILD_WITH_TLS)
+include_directories(${OPENSSL_INCLUDE_DIR})
+set(NATS_OPENSSL_LIBS "${OPENSSL_LIBRARIES}")
+endif(NATS_BUILD_WITH_TLS)
+
+#---------------------------------------
+# Grab all files in 'src' and 'src/unix'
+# or 'src/win' depending on the platform
+#---------------------------------------
+file(GLOB SOURCES "*.c")
+file(GLOB PS_SOURCES "${NATS_PLATFORM_INCLUDE}/*.c")
+
+# --------------------------------------
+# Create the shared and static libraries
+# --------------------------------------
+add_library(nats SHARED ${SOURCES} ${PS_SOURCES})
+target_link_libraries(nats ${NATS_OPENSSL_LIBS} ${NATS_EXTRA_LIB})
+add_library(nats_static STATIC ${SOURCES} ${PS_SOURCES})
+target_link_libraries(nats_static ${NATS_OPENSSL_LIBS})
+
+# --------------------------------------
+# Install the libraries and header files
+# --------------------------------------
+install(TARGETS nats DESTINATION lib)
+install(TARGETS nats_static DESTINATION lib)
+install(FILES nats.h status.h version.h DESTINATION include)

data/vendor/cnats/src/asynccb.c

@@ -0,0 +1,66 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include "natsp.h"
+#include "mem.h"
+#include "conn.h"
+
+static void
+_freeAsyncCbInfo(natsAsyncCbInfo *info)
+{
+    NATS_FREE(info);
+}
+
+static void
+_createAndPostCb(natsAsyncCbType type, natsConnection *nc, natsSubscription *sub, natsStatus err)
+{
+    natsStatus          s  = NATS_OK;
+    natsAsyncCbInfo     *cb;
+
+    cb = NATS_CALLOC(1, sizeof(natsAsyncCbInfo));
+    if (cb == NULL)
+    {
+        // We will ignore for now since that makes the caller handle the
+        // possibility of having to run the callbacks in-line...
+        return;
+    }
+
+    cb->type = type;
+    cb->nc   = nc;
+    cb->sub  = sub;
+    cb->err  = err;
+
+    natsConn_retain(nc);
+
+    s = nats_postAsyncCbInfo(cb);
+    if (s != NATS_OK)
+    {
+        _freeAsyncCbInfo(cb);
+        natsConn_release(nc);
+    }
+}
+
+void
+natsAsyncCb_PostConnHandler(natsConnection *nc, natsAsyncCbType type)
+{
+    _createAndPostCb(type, nc, NULL, NATS_OK);
+}
+
+void
+natsAsyncCb_PostErrHandler(natsConnection *nc, natsSubscription *sub, natsStatus err)
+{
+    _createAndPostCb(ASYNC_ERROR, nc, sub, err);
+}
+
+void
+natsAsyncCb_Destroy(natsAsyncCbInfo *info)
+{
+    natsConnection *nc;
+
+    if (info == NULL)
+        return;
+
+    nc = info->nc;
+
+    _freeAsyncCbInfo(info);
+    natsConn_release(nc);
+}

data/vendor/cnats/src/asynccb.h

@@ -0,0 +1,42 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef ASYNCCB_H_
+#define ASYNCCB_H_
+
+#include "status.h"
+
+typedef enum
+{
+    ASYNC_CLOSED          = 0,
+    ASYNC_DISCONNECTED,
+    ASYNC_RECONNECTED,
+    ASYNC_ERROR
+
+} natsAsyncCbType;
+
+struct __natsConnection;
+struct __natsSubscription;
+struct __natsAsyncCbInfo;
+
+typedef struct __natsAsyncCbInfo
+{
+    natsAsyncCbType             type;
+    struct __natsConnection     *nc;
+    struct __natsSubscription   *sub;
+    natsStatus                  err;
+
+    struct __natsAsyncCbInfo    *next;
+
+} natsAsyncCbInfo;
+
+void
+natsAsyncCb_PostConnHandler(struct __natsConnection *nc, natsAsyncCbType type);
+
+void
+natsAsyncCb_PostErrHandler(struct __natsConnection *nc,
+                           struct __natsSubscription *sub, natsStatus err);
+
+void
+natsAsyncCb_Destroy(natsAsyncCbInfo *info);
+
+#endif /* ASYNCCB_H_ */

data/vendor/cnats/src/buf.c

@@ -0,0 +1,246 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#include <string.h>
+#include <assert.h>
+
+#include "err.h"
+#include "mem.h"
+#include "buf.h"
+
+static natsStatus
+_init(natsBuffer *newBuf, char *data, int len, int capacity)
+{
+    natsBuffer *buf = newBuf;
+
+    // Since we explicitly set all fields, no need for memset
+
+    buf->doFree = false;
+
+    if (data != NULL)
+    {
+        buf->data    = data;
+        buf->ownData = false;
+    }
+    else
+    {
+        buf->data = (char*) NATS_MALLOC(capacity);
+        if (buf->data == NULL)
+            return nats_setDefaultError(NATS_NO_MEMORY);
+
+        buf->ownData = true;
+    }
+
+    buf->pos      = buf->data + len;
+    buf->len      = len;
+    buf->capacity = capacity;
+
+    return NATS_OK;
+}
+
+natsStatus
+natsBuf_InitWithBackend(natsBuffer *newBuf, char *data, int len, int capacity)
+{
+    if (data == NULL)
+        return NATS_INVALID_ARG;
+
+    return _init(newBuf, data, len, capacity);
+}
+
+natsStatus
+natsBuf_Init(natsBuffer *buf, int capacity)
+{
+    return _init(buf, NULL, 0, capacity);
+}
+
+static natsStatus
+_newBuf(natsBuffer **newBuf, char *data, int len, int capacity)
+{
+    natsBuffer  *buf;
+
+    buf = (natsBuffer*) NATS_MALLOC(sizeof(natsBuffer));
+    if (buf == NULL)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    if (_init(buf, data, len, capacity) != NATS_OK)
+    {
+        NATS_FREE(buf);
+        return NATS_UPDATE_ERR_STACK(NATS_NO_MEMORY);
+    }
+
+    buf->doFree = true;
+
+    *newBuf = buf;
+
+    return NATS_OK;
+}
+
+natsStatus
+natsBuf_CreateWithBackend(natsBuffer **newBuf, char *data, int len, int capacity)
+{
+    natsStatus s;
+
+    if (data == NULL)
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    s = _newBuf(newBuf, data, len, capacity);
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+natsStatus
+natsBuf_Create(natsBuffer **newBuf, int capacity)
+{
+    natsStatus s = _newBuf(newBuf, NULL, 0, capacity);
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+void
+natsBuf_Reset(natsBuffer *buf)
+{
+    buf->len = 0;
+    buf->pos = buf->data;
+}
+
+void
+natsBuf_RewindTo(natsBuffer *buf, int newPosition)
+{
+    assert(newPosition < buf->capacity);
+
+    buf->len = newPosition;
+    buf->pos = buf->data + newPosition;
+}
+
+
+natsStatus
+natsBuf_Expand(natsBuffer *buf, int newSize)
+{
+    int     offset   = (int) (buf->pos - buf->data);
+    char    *newData = NULL;
+
+    if (newSize <= buf->capacity)
+        return nats_setDefaultError(NATS_INVALID_ARG);
+
+    if (buf->ownData)
+    {
+        newData = NATS_REALLOC(buf->data, newSize);
+        if (newData == NULL)
+            return nats_setDefaultError(NATS_NO_MEMORY);
+    }
+    else
+    {
+        newData = NATS_MALLOC(newSize);
+        if (newData == NULL)
+            return nats_setDefaultError(NATS_NO_MEMORY);
+
+        memcpy(newData, buf->data, buf->len);
+        buf->ownData = true;
+    }
+
+    if (buf->data != newData)
+    {
+        buf->data = newData;
+        buf->pos  = (char*) (buf->data + offset);
+    }
+
+    buf->capacity = newSize;
+
+    return NATS_OK;
+}
+
+natsStatus
+natsBuf_Append(natsBuffer *buf, const char* data, int dataLen)
+{
+    natsStatus  s = NATS_OK;
+    int         n = buf->len + dataLen;
+
+    // We could use int64_t and check for 0x7FFFFFFF, but keeping
+    // all int is faster.
+    if (n < 0)
+        return nats_setDefaultError(NATS_NO_MEMORY);
+
+    if (n > buf->capacity)
+    {
+        // Increase by 10%
+        int extra = (int) (n * 0.1);
+        int newSize;
+
+        // Make sure that we have at least some bytes left after adding.
+        newSize = (n + (extra < 64 ? 64 : extra));
+
+        // Overrun.
+        if (newSize < 0)
+            return nats_setDefaultError(NATS_NO_MEMORY);
+
+        s = natsBuf_Expand(buf, newSize);
+    }
+
+    if (s == NATS_OK)
+    {
+        memcpy(buf->pos, data, dataLen);
+        buf->pos += dataLen;
+        buf->len += dataLen;
+    }
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+natsStatus
+natsBuf_AppendByte(natsBuffer *buf, char b)
+{
+    natsStatus  s = NATS_OK;
+    int         c = buf->capacity;
+
+    if (buf->len == c)
+    {
+        // Increase by 10%
+        int extra = (int) (c * 0.1);
+        int newSize;
+
+        // Make sure that we have at least some bytes left after adding.
+        newSize = (c + (extra < 64 ? 64 : extra));
+
+        // Overrun.
+        if (newSize < 0)
+            return nats_setDefaultError(NATS_NO_MEMORY);
+
+        s = natsBuf_Expand(buf, newSize);
+    }
+
+    if (s == NATS_OK)
+    {
+        *(buf->pos++) = b;
+        buf->len++;
+    }
+
+    return NATS_UPDATE_ERR_STACK(s);
+}
+
+void
+natsBuf_Consume(natsBuffer *buf, int n)
+{
+    int remaining;
+
+    assert(n <= buf->len);
+
+    remaining = buf->len - n;
+    if (remaining > 0)
+        memmove(buf->data, buf->data + n, remaining);
+
+    buf->len = remaining;
+    buf->pos = buf->data + remaining;
+}
+
+void
+natsBuf_Destroy(natsBuffer *buf)
+{
+    if (buf == NULL)
+        return;
+
+    if (buf->ownData)
+        NATS_FREE(buf->data);
+
+    if (buf->doFree)
+        NATS_FREE(buf);
+    else
+        memset(buf, 0, sizeof(natsBuffer));
+}

data/vendor/cnats/src/buf.h

@@ -0,0 +1,116 @@
+// Copyright 2015 Apcera Inc. All rights reserved.
+
+#ifndef BUF_H_
+#define BUF_H_
+
+#include <stdbool.h>
+
+#include "status.h"
+
+typedef struct __natsBuffer
+{
+    char*       data;
+    char*       pos;
+    int         len;
+    int         capacity;
+    bool        ownData;
+    bool        doFree;
+
+} natsBuffer;
+
+#define natsBuf_Data(b)         ((b)->data)
+#define natsBuf_Capacity(b)     ((b)->capacity)
+#define natsBuf_Len(b)          ((b)->len)
+#define natsBuf_Available(b)    ((b)->capacity - (b)->len)
+
+
+// Initializes a natsBuffer using 'data' as the back-end byte array.
+// The length and capacity are set based on the given parameters.
+// Since the 'data' is not owned, and as long as the buffer does not need
+// to be expanded, the byte buffer will not be freed when this natsBuffer
+// is destroyed. Check natsBuf_Expand() for more details.
+//
+// One would use this call to initialize a natsBuffer without the added cost
+// of allocating memory for the natsBuffer structure itself, for instance
+// initializing an natsBuffer on the stack.
+natsStatus
+natsBuf_InitWithBackend(natsBuffer *buf, char *data, int len, int capacity);
+
+// Initializes a natsBuffer and creates a byte buffer of 'capacity' bytes.
+// The natsBuffer owns the buffer and will therefore free the memory used
+// when destroyed.
+//
+// One would use this call to initialize a natsBuffer without the added cost
+// of allocating memory for the natsBuffer structure itself, for instance
+// initializing an natsBuffer on the stack.
+natsStatus
+natsBuf_Init(natsBuffer *buf, int capacity);
+
+// Creates a new natsBuffer using 'data' as the back-end byte array.
+// The length and capacity are set based on the given parameters.
+// Since the 'data' is not owned, and as long as the buffer does not need
+// to be expanded, the byte buffer will not be freed when this natsBuffer
+// is destroyed. Check natsBuf_Expand() for more details.
+natsStatus
+natsBuf_CreateWithBackend(natsBuffer **newBuf, char *data, int len, int capacity);
+
+// Creates a new natsBuffer and creates a byte buffer of 'capacity' bytes.
+// The natsBuffer owns the buffer and will therefore free the memory used
+// when destroyed.
+natsStatus
+natsBuf_Create(natsBuffer **newBuf, int capacity);
+
+// Resets the length to zero, and the position to the beginning of the buffer.
+void
+natsBuf_Reset(natsBuffer *buf);
+
+// Sets the size of the buffer to 'newPosition' and new data will be appended
+// starting at this position.
+void
+natsBuf_RewindTo(natsBuffer *buf, int newPosition);
+
+// Expands 'buf' underlying buffer to the given new size 'newSize'.
+//
+// If 'buf' did not own the underlying buffer, a new buffer is
+// created and data copied over. The original data is now detached.
+// The underlying buffer is now owned by 'buf' and will be freed when
+// the natsBuffer is destroyed.
+//
+// When 'buf' owns the underlying buffer and it is expanded, a memory
+// reallocation of the buffer occurs to satisfy the new size requirement.
+//
+// Note that one should not save the returned value of natsBuf_Data() and
+// use it after any call to natsBuf_Expand/Append/AppendByte() since
+// the memory address for the underlying byte buffer may have changed due
+// to the buffer expansion.
+natsStatus
+natsBuf_Expand(natsBuffer *buf, int newSize);
+
+// Appends 'dataLen' bytes from the 'data' byte array to the buffer,
+// potentially expanding the buffer.
+// See natsBuf_Expand for details about natsBuffer not owning the data.
+natsStatus
+natsBuf_Append(natsBuffer *buf, const char* data, int dataLen);
+
+// Appends a byte to the buffer, potentially expanding the buffer.
+// See natsBuf_Expand for details about natsBuffer not owning the data.
+natsStatus
+natsBuf_AppendByte(natsBuffer *buf, char b);
+
+// Consume data from a buffer, overwriting the 'n' first bytes by the remaining
+// of data in this buffer.
+void
+natsBuf_Consume(natsBuffer *buf, int n);
+
+// Reads better when dealing with a buffer that was initialized as opposed to
+// created, but calling natsBuf_Destroy() will do the right thing regardless
+// of how the buffer was created.
+#define natsBuf_Cleanup(b)  natsBuf_Destroy((b))
+
+// Frees the data if owned (otherwise leaves it untouched) and the structure
+// if the buffer was created with one of the natsBuf_CreateX() function,
+// otherwise simply 'memset' the structure.
+void
+natsBuf_Destroy(natsBuffer *buf);
+
+#endif /* BUF_H_ */