@openziti/ziti-sdk-nodejs 0.6.0

package/src/ziti_dial.c

@@ -0,0 +1,375 @@
+/*
+Copyright 2019-2020 Netfoundry, 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
+
+https://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 "ziti-nodejs.h"
+#include <string.h>
+
+// An item that will be generated here and passed into the JavaScript on_data callback
+typedef struct OnDataItem {
+
+  uint8_t *buf;
+  int len;
+
+} OnDataItem;
+
+/**
+ * This function is responsible for calling the JavaScript 'connect' callback function 
+ * that was specified when the ziti_dial(...) was called from JavaScript.
+ */
+static void CallJs_on_connect(napi_env env, napi_value js_cb, void* context, void* data) {
+  napi_status status;
+
+  // This parameter is not used.
+  (void) context;
+
+  // env and js_cb may both be NULL if Node.js is in its cleanup phase, and
+  // items are left over from earlier thread-safe calls from the worker thread.
+  // When env is NULL, we simply skip over the call into Javascript
+  if (env != NULL) {
+    napi_value undefined, js_conn;
+
+    ZITI_NODEJS_LOG(INFO, "data: %p", data);
+
+    // Convert the ziti_connection to a napi_value.
+    if (NULL != data) {
+      // Retrieve the ziti_connection from the item created by the worker thread.
+      ziti_connection conn = *(ziti_connection*)data;
+      status = napi_create_int64(env, (int64_t)conn, &js_conn);
+      if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Unable to napi_create_int64");
+      }
+    } else {
+      status = napi_get_undefined(env, &js_conn) == napi_ok;
+      if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Unable to napi_get_undefined (1)");
+      }
+    }
+
+    // Retrieve the JavaScript `undefined` value so we can use it as the `this`
+    // value of the JavaScript function call.
+    status = napi_get_undefined(env, &undefined);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_get_undefined (2)");
+    }
+
+    ZITI_NODEJS_LOG(INFO, "calling JS callback...");
+
+    // Call the JavaScript function and pass it the ziti_connection
+    status = napi_call_function(
+        env,
+        undefined,
+        js_cb,
+        1,
+        &js_conn,
+        NULL
+      );
+    ZITI_NODEJS_LOG(INFO, "returned from JS callback...");
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_call_function");
+    }
+  }
+}
+
+
+/**
+ * This function is responsible for calling the JavaScript 'data' callback function 
+ * that was specified when the ziti_dial(...) was called from JavaScript.
+ */
+static void CallJs_on_data(napi_env env, napi_value js_cb, void* context, void* data) {
+  napi_status status;
+
+  // This parameter is not used.
+  (void) context;
+
+  // Retrieve the OnDataItem created by the worker thread.
+  OnDataItem* item = (OnDataItem*)data;
+
+  // env and js_cb may both be NULL if Node.js is in its cleanup phase, and
+  // items are left over from earlier thread-safe calls from the worker thread.
+  // When env is NULL, we simply skip over the call into Javascript and free the
+  // items.
+  if (env != NULL) {
+    napi_value undefined, js_buffer;
+    void* result_data;
+
+    // Convert the buffer to a napi_value.
+    status = napi_create_buffer_copy(env,
+                              item->len,
+                              (const void*)item->buf,
+                              (void**)&result_data,
+                              &js_buffer);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_create_buffer_copy");
+    }
+
+    // Retrieve the JavaScript `undefined` value so we can use it as the `this`
+    // value of the JavaScript function call.
+    status = napi_get_undefined(env, &undefined);
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_get_undefined (3)");
+    }
+
+    // Call the JavaScript function and pass it the data
+    status = napi_call_function(
+        env,
+        undefined,
+        js_cb,
+        1,
+        &js_buffer,
+        NULL
+      );
+    if (status != napi_ok) {
+      napi_throw_error(env, NULL, "Unable to napi_call_function");
+    }
+  }
+}
+
+
+
+
+/**
+ * This function is the callback invoked by the C-SDK when data arrives on the connection.
+ */
+ssize_t on_data(ziti_connection conn, uint8_t *buf, ssize_t len) {
+  napi_status status;
+
+  ConnAddonData* addon_data = (ConnAddonData*) ziti_conn_data(conn);
+
+  ZITI_NODEJS_LOG(INFO, "len: %zd, conn: %p", len, conn);
+
+  if (len == ZITI_EOF) {
+    if (addon_data->isWebsocket) {
+      ZITI_NODEJS_LOG(DEBUG, "skipping ziti_close on ZITI_EOF due to isWebsocket=true");
+      return 0;
+    } else {
+      ziti_close(conn, NULL);
+      return 0;
+    }
+  }
+  else if (len < 0) {
+    ziti_close(conn, NULL);
+    return 0;
+  }
+  else {
+
+    OnDataItem* item = memset(malloc(sizeof(*item)), 0, sizeof(*item));
+    item->buf = buf;
+    item->buf = calloc(1, len);
+    memcpy(item->buf, buf, len);
+    item->len = len;
+
+    // if (addon_data->isWebsocket) {
+    //   hexDump("on_data", item->buf, item->len);
+    // }
+
+    // Initiate the call into the JavaScript callback. 
+    // The call into JavaScript will not have happened 
+    // when this function returns, but it will be queued.
+    status = napi_call_threadsafe_function(
+        addon_data->tsfn_on_data,        
+        item,  // Send the data we received from the service on over to the JS callback
+        napi_tsfn_blocking);
+    if (status != napi_ok) {
+      ZITI_NODEJS_LOG(ERROR, "Unable to napi_call_threadsafe_function");
+    }
+
+    return len;
+  }
+}
+
+
+/**
+ * 
+ */
+void on_connect(ziti_connection conn, int status) {
+  napi_status nstatus;
+
+
+  ConnAddonData* addon_data = (ConnAddonData*) ziti_conn_data(conn);
+  ziti_connection* the_conn = NULL;
+
+  ZITI_NODEJS_LOG(DEBUG, "conn: %p, status: %o, isWebsocket: %o", conn, status, addon_data->isWebsocket);
+
+  if (status == ZITI_OK) {
+
+    // Save the 'ziti_connection' to the heap. The JavaScript marshaller (CallJs)
+    // will free this item after having sent it to JavaScript.
+    the_conn = malloc(sizeof(ziti_connection));
+    *the_conn = conn;
+  }
+
+    ZITI_NODEJS_LOG(DEBUG, "the_conn: %p", the_conn);
+
+  // Initiate the call into the JavaScript callback. 
+  // The call into JavaScript will not have happened 
+  // when this function returns, but it will be queued.
+  nstatus = napi_call_threadsafe_function(
+      addon_data->tsfn_on_connect,
+      the_conn,   // Send the ziti_connection over to the JS callback
+      napi_tsfn_blocking);
+    if (nstatus != napi_ok) {
+      ZITI_NODEJS_LOG(ERROR, "Unable to napi_call_threadsafe_function");
+    }
+}
+
+
+/**
+ * 
+ */
+napi_value _ziti_dial(napi_env env, const napi_callback_info info) {
+
+  napi_status status;
+  size_t argc = 4;
+  napi_value args[4];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to parse arguments");
+  }
+
+  if (argc < 4) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  // Obtain service name
+  size_t result;
+  char ServiceName[256];  //TODO: make this smarter
+  status = napi_get_value_string_utf8(env, args[0], ServiceName, 256, &result);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get Service Name");
+  }
+  ZITI_NODEJS_LOG(DEBUG, "ServiceName: %s", ServiceName);
+
+  // Obtain isWebsocket flag
+  bool isWebsocket = false;
+  status = napi_get_value_bool(env, args[1], &isWebsocket);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get isWebsocket flag");
+  }
+  ZITI_NODEJS_LOG(DEBUG, "isWebsocket is: %o", isWebsocket);
+
+  // Obtain ptr to JS 'connect' callback function
+  napi_value js_connect_cb = args[2];
+  napi_value work_name_connect;
+
+  ConnAddonData* addon_data = memset(malloc(sizeof(*addon_data)), 0, sizeof(*addon_data));
+
+  addon_data->isWebsocket = isWebsocket;
+
+  // Create a string to describe this asynchronous operation.
+  status = napi_create_string_utf8(
+    env,
+    "N-API on_connect",
+    NAPI_AUTO_LENGTH,
+    &work_name_connect);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to napi_create_string_utf8");
+  }
+
+  // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
+  // which we can call from a worker thread.
+  status = napi_create_threadsafe_function(
+      env,
+      js_connect_cb,
+      NULL,
+      work_name_connect,
+      0,
+      1,
+      NULL,
+      NULL,
+      NULL,
+      CallJs_on_connect,
+      &(addon_data->tsfn_on_connect));
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to napi_create_threadsafe_function");
+  }
+
+  // Obtain ptr to JS 'data' callback function
+  napi_value js_data_cb = args[3];
+  napi_value work_name_data;
+
+  // Create a string to describe this asynchronous operation.
+  status = napi_create_string_utf8(
+    env,
+    "N-API on_data",
+    NAPI_AUTO_LENGTH,
+    &work_name_data);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to napi_create_string_utf8");
+  }
+
+  // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
+  // which we can call from a worker thread.
+  status = napi_create_threadsafe_function(
+      env,
+      js_data_cb,
+      NULL,
+      work_name_data,
+      0,
+      1,
+      NULL,
+      NULL,
+      NULL,
+      CallJs_on_data,
+      &(addon_data->tsfn_on_data));
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to napi_create_threadsafe_function");
+  }
+  
+  ziti_set_timeout(ztx, 5*1000);
+
+  // Init a Ziti connection object, and attach our add-on data to it so we can 
+  // pass context around between our callbacks, as propagate it all the way out
+  // to the JavaScript callbacks
+  ziti_connection conn;
+  int rc = ziti_conn_init(ztx, &conn, addon_data);
+  if (rc != ZITI_OK) {
+    napi_throw_error(env, NULL, "failure in 'ziti_conn_init");
+  }
+
+
+  // Connect to the service
+  ZITI_NODEJS_LOG(DEBUG, "calling ziti_dial: %p", ztx);
+  rc = ziti_dial(conn, ServiceName, on_connect, on_data);
+  if (rc != ZITI_OK) {
+    napi_throw_error(env, NULL, "failure in 'ziti_dial");
+  }
+  ZITI_NODEJS_LOG(DEBUG, "returned from ziti_dial: %p", ztx);
+
+  return NULL;
+}
+
+
+
+/**
+ * 
+ */
+void expose_ziti_dial(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn;
+
+  status = napi_create_function(env, NULL, 0, _ziti_dial, NULL, &fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to wrap native function '_ziti_dial");
+  }
+
+  status = napi_set_named_property(env, exports, "ziti_dial", fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to populate exports for 'ziti_dial");
+  }
+
+}
+

package/src/ziti_enroll.c

@@ -0,0 +1,245 @@
+/*
+Copyright 2019-2020 Netfoundry, 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
+
+https://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 "ziti-nodejs.h"
+
+ziti_context nf;
+uv_loop_t *enroll_loop = NULL;
+
+uv_loop_t *thread_loop;
+uv_thread_t thread;
+uv_async_t async;
+
+
+typedef struct {
+  napi_async_work work;
+  napi_threadsafe_function tsfn;
+} AddonData;
+
+// An item that will be generated here and passed into the JavaScript enroll callback
+typedef struct EnrollItem {
+
+  unsigned char *json_salvo;
+  int status;
+  char *err;
+
+} EnrollItem;
+
+
+/**
+ * This function is responsible for calling the JavaScript callback function 
+ * that was specified when the ziti_enroll(...) was called from JavaScript.
+ */
+static void CallJs_on_enroll(napi_env env, napi_value js_cb, void* context, void* data) {
+
+  ZITI_NODEJS_LOG(DEBUG, "entered");
+
+  // This parameter is not used.
+  (void) context;
+
+  // Retrieve the EnrollItem created by the worker thread.
+  EnrollItem* item = (EnrollItem*)data;
+
+  ZITI_NODEJS_LOG(DEBUG, "item->json_salvo: %s", item->json_salvo);
+  ZITI_NODEJS_LOG(DEBUG, "item->status: %d", item->status);
+  ZITI_NODEJS_LOG(DEBUG, "item->err: %s", item->err);
+
+  // env and js_cb may both be NULL if Node.js is in its cleanup phase, and
+  // items are left over from earlier thread-safe calls from the worker thread.
+  // When env is NULL, we simply skip over the call into Javascript
+  if (env != NULL) {
+
+    napi_value undefined;
+
+    // Retrieve the JavaScript `undefined` value so we can use it as the `this`
+    // value of the JavaScript function call.
+    assert(napi_get_undefined(env, &undefined) == napi_ok);
+
+    // const obj = {}
+    napi_value js_enroll_item, js_json_salvo, js_status, js_err;
+    assert(napi_create_object(env, &js_enroll_item) == napi_ok);
+
+    // obj.identity = identity
+    if (NULL != item->json_salvo) {
+      assert(napi_create_string_utf8(env, (const char*)item->json_salvo, NAPI_AUTO_LENGTH, &js_json_salvo) == napi_ok);
+      assert(napi_set_named_property(env, js_enroll_item, "identity", js_json_salvo) == napi_ok);
+    } else {
+      assert(napi_set_named_property(env, js_enroll_item, "identity", undefined) == napi_ok);
+    }
+
+    // obj.status = status
+    assert(napi_create_int64(env, (int64_t)item->status, &js_status) == napi_ok);
+    assert(napi_set_named_property(env, js_enroll_item, "status", js_status) == napi_ok);
+
+    // obj.err = err
+    if (NULL != item->err) {
+      assert(napi_create_string_utf8(env, (const char*)item->err, NAPI_AUTO_LENGTH, &js_err) == napi_ok);
+      assert(napi_set_named_property(env, js_enroll_item, "err", js_err) == napi_ok);
+    } else {
+      assert(napi_set_named_property(env, js_enroll_item, "err", undefined) == napi_ok);
+    }
+
+
+    // Call the JavaScript function and pass it the WriteItem
+    assert(
+      napi_call_function(
+        env,
+        undefined,
+        js_cb,
+        1,
+        &js_enroll_item,
+        NULL) == napi_ok);
+
+  }
+}
+
+
+/**
+ * 
+ */
+void on_ziti_enroll(ziti_config *cfg, int status, char *err, void *ctx) {
+
+  ZITI_NODEJS_LOG(DEBUG, "\nstatus: %d, \nerr: %s,\nctx: %p", status, err, ctx);
+
+  AddonData* addon_data = (AddonData*)ctx;
+
+  EnrollItem* item = memset(malloc(sizeof(*item)), 0, sizeof(*item));
+
+  item->status = status;
+
+  if (NULL != err) {
+    item->err = calloc(1, strlen(err));
+    strcpy(item->err, err);
+  } else {
+    item->err = NULL;
+  }
+
+  if (status == ZITI_OK) {
+    size_t len;
+    char *output_buf = ziti_config_to_json(cfg, 0, &len);
+    item->json_salvo = calloc(1, len);
+    strcpy(item->json_salvo, output_buf);
+  }
+
+  // Initiate the call into the JavaScript callback. 
+  // The call into JavaScript will not have happened 
+  // when this function returns, but it will be queued.
+  assert(
+    napi_call_threadsafe_function(
+      addon_data->tsfn,
+      item,
+      napi_tsfn_blocking) == napi_ok);
+}
+
+
+
+void child_thread(void *data){
+    uv_loop_t *thread_loop = (uv_loop_t *) data;
+
+    //Start this loop
+    uv_run(thread_loop, UV_RUN_DEFAULT);
+}
+
+static void consumer_notify(uv_async_t *handle, int status) { }
+
+/**
+ * 
+ */
+napi_value _ziti_enroll(napi_env env, const napi_callback_info info) {
+  napi_status status;
+  napi_value jsRetval;
+
+  ZITI_NODEJS_LOG(DEBUG, "entered");
+
+  size_t argc = 2;
+  napi_value args[2];
+  status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to parse arguments");
+  }
+
+  if (argc < 2) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  // Obtain location of JWT file
+  size_t result;
+  char JWTFileName[256];
+  status = napi_get_value_string_utf8(env, args[0], JWTFileName, 256, &result);
+
+  // Obtain ptr to JS callback function
+  napi_value js_cb = args[1];
+  napi_value work_name;
+  AddonData* addon_data = malloc(sizeof(AddonData));
+
+  // Create a string to describe this asynchronous operation.
+  assert(napi_create_string_utf8(
+    env,
+    "N-API on_ziti_enroll",
+    NAPI_AUTO_LENGTH,
+    &work_name) == napi_ok);
+
+  // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
+  // which we can call from a worker thread.
+  assert(
+    napi_create_threadsafe_function(
+      env,
+      js_cb,
+      NULL,
+      work_name,
+      0,
+      1,
+      NULL,
+      NULL,
+      NULL,
+      CallJs_on_enroll,
+      &(addon_data->tsfn)) == napi_ok);
+
+  // Create and set up the consumer thread
+  thread_loop = uv_loop_new();
+  uv_async_init(thread_loop, &async, (uv_async_cb)consumer_notify);
+  uv_thread_create(&thread, (uv_thread_cb)child_thread, thread_loop);
+
+  // Initiate the enrollment
+  ziti_enroll_opts opts = {0};
+  opts.jwt = JWTFileName;
+  int rc = ziti_enroll(&opts, thread_loop, on_ziti_enroll, addon_data);
+
+  status = napi_create_int32(env, rc, &jsRetval);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to create return value");
+  }
+
+  return jsRetval;
+}
+
+
+void expose_ziti_enroll(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn;
+
+  status = napi_create_function(env, NULL, 0, _ziti_enroll, NULL, &fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to wrap native function '_ziti_enroll");
+  }
+
+  status = napi_set_named_property(env, exports, "ziti_enroll", fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to populate exports for 'ziti_enroll");
+  }
+
+}

package/src/ziti_hello.c

@@ -0,0 +1,52 @@
+/*
+Copyright 2019-2020 Netfoundry, 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
+
+https://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 "ziti-nodejs.h"
+
+
+/**
+ * 
+ */
+napi_value _ziti_hello(napi_env env, const napi_callback_info info) {
+  napi_value jsRetval = NULL;
+  napi_status status = napi_generic_failure;
+
+  status = napi_create_string_utf8(env, "ziti", NAPI_AUTO_LENGTH, &jsRetval);
+  if (status != napi_ok) return NULL;
+
+  return jsRetval;
+}
+
+
+/**
+ * 
+ */
+void expose_ziti_hello(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn;
+
+  status = napi_create_function(env, NULL, 0, _ziti_hello, NULL, &fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to wrap native function '_ziti_hello");
+  }
+
+  status = napi_set_named_property(env, exports, "ziti_hello", fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to populate exports for 'ziti_hello");
+  }
+
+}
+