@openziti/ziti-sdk-nodejs 0.12.0 → 0.13.1

package/README.md

@@ -1,3 +1,16 @@
+<p align="center" width="100%">
+OpenZiti is a free and open source project focused on bringing zero trust to any application.
+     <br>
+The project provides all the pieces required to implement or integrate zero trust into your solutions.
+<br/>
+<br/>
+Please star us.
+<br/>
+<a href="https://github.com/openziti/ziti/stargazers"><img src="https://img.shields.io/github/stars/openziti/ziti?style=flat" ></a>
+<br/>
+     <br>
+</p>
+
 <p align="center" width="100%">
 <a href="https://openziti.io"><img src="ziti.png" width="100"></a>
 </p>
@@ -8,7 +21,7 @@
     <br>
     <br>
     <b>
-    A NodeJS-based SDK for delivering secure applications over a <a href="https://openziti.io">Ziti Network</a>
+    This repo hosts the OpenZiti SDK for NodeJS, and is designed to help you deliver secure applications over a <a href="https://openziti.io">OpenZiti Network</a>
     <br>
     <br>
     <b>Part of the <a href="https://openziti.io/about">OpenZiti</a> ecosystem</b>
@@ -33,6 +46,9 @@
 
 ---
 
+# Associated Article(s)
+For more context on this SDK, you may be interested in this
+[article concerning how to secure NodeJS applications](https://openziti.io/securing-nodejs-applications)
 
 
 
@@ -51,9 +67,14 @@ Binaries for most Node versions and platforms are provided by default via [@mapb
 
 # Installing
 
+NPM
 ``` js
 npm i @openziti/ziti-sdk-nodejs
 ```
+or Yarn
+``` js
+yarn add @openziti/ziti-sdk-nodejs
+```
 
 Special note on previous package:
 
@@ -68,6 +89,59 @@ npm install @openziti/ziti-sdk-nodejs --save
 
 **Note:** the module must be [installed](#installing) before use.
 
+ESM example (client-side)
+``` js
+import ziti from '@openziti/ziti-sdk-nodejs';
+
+// Somehow provide path to identity file, e.g. via env var
+const zitiIdentityFile  = process.env.ZITI_IDENTITY_FILE;
+// Authenticate ourselves onto the Ziti network
+await ziti.init( zitiIdentityFile ).catch(( err ) => { /* probably exit */ });
+
+const on_resp_data = ( obj ) => {
+    console.log(`response is: ${obj.body.toString('utf8')}`);
+};
+
+// Perform an HTTP GET request to a dark OpenZiti web service
+ziti.httpRequest(
+  'myDarkWebService', 
+  'GET', 
+  '/',              // path
+  ['Accept: application/json' ], // headers
+  undefined,        // optional on_req cb 
+  undefined,        // optional on_req_data cb
+  on_resp_data      // optional on_resp_data cb
+);
+
+```
+
+ESM example (server-side ExpressJS)
+``` js
+import ziti from '@openziti/ziti-sdk-nodejs';
+import express from 'express';
+let app = ziti.express( express, zitiServiceName );
+app.listen(ignored, function() { ... }
+
+/**
+
+That's right.
+
+With only a single-line code change (the ziti.express call), your web server is now capable
+of being invisible to malicious attackers on the internet, and only accessible to your 
+trusted remote users.
+
+Nothing else in your existing ExpressJS web server code needs to change!
+
+Existing routing, middleware, etc., all operates the same as it always did... 
+but now you enjoy the comfort of knowing that if a connection comes in, it is from 
+a trusted identity on the client side.
+
+No malicious actors can see your dark web server, and thus, no malicious actors can attack it.
+
+*/
+```
+
+CJS example (client-side)
 ``` js
 var ziti = require('@openziti/ziti-sdk-nodejs');
 
@@ -134,6 +208,9 @@ const ziti_write = (conn, data) => {
 
 # Ziti NodeJS SDK - Setup for Development
 
+NOTE: You don't need to compile this SDK in order to use it (we publish pre-built binaries for your OS, NodeJS version, and CPU architecture).
+The following information applies only if you are doing development on the SDK itself.
+
 The following steps should get your NodeJS SDK for Ziti building. The Ziti NodeJS SDK is a native addon for Node JS,
 and is written in C. C development is specific to your operating system and tool chain used. These steps should work 
 properly for you but if your OS has variations you may need to adapt these steps accordingly.
@@ -159,11 +236,10 @@ $ npm run build
 
 Getting Help
 ------------
-Please use these community resources for getting help. We use GitHub [issues](https://github.com/NetFoundry/ziti-sdk-nodejs/issues) 
+Please use these community resources for getting help. We use GitHub [issues](https://github.com/openziti/ziti-sdk-nodejs/issues) 
 for tracking bugs and feature requests and have limited bandwidth to address them.
 
-- Read the [docs](https://netfoundry.github.io/ziti-doc/ziti/overview.html)
-- Join our [Developer Community](https://developer.netfoundry.io)
+- Read the [docs](https://openziti.github.io/ziti/overview.html)
 - Participate in discussion on [Discourse](https://openziti.discourse.group/)
 
 

package/lib/httpRequest.js

@@ -46,7 +46,7 @@ const on_resp_data = ( obj ) => {
 
 };
 
-const httpRequest = ( url, method, headers, on_req_cb, on_resp_cb, on_resp_data_cb ) => {
+const httpRequest = ( url, method, path, headers, on_req_cb, on_resp_cb, on_resp_data_cb ) => {
 
     console.log('httpRequest entered: ', url, method, headers);
 
@@ -72,7 +72,7 @@ const httpRequest = ( url, method, headers, on_req_cb, on_resp_cb, on_resp_data_
         _on_resp_data_cb = on_resp_data_cb;
     }
 
-    ziti.Ziti_http_request( url, method, headers, _on_req_cb, _on_resp_cb, _on_resp_data_cb );
+    ziti.Ziti_http_request( url, method, path, headers, _on_req_cb, _on_resp_cb, _on_resp_data_cb );
 
 };
 

package/lib/init.js

@@ -26,7 +26,12 @@ const init = ( identityPath ) => {
   return new Promise((resolve, reject) => {
 
       let rc = ziti.ziti_init( identityPath, ( result ) => {
+
+        setTimeout( () => {
+
           return resolve( result );
+        
+        }, 1000);
       });
 
       if (rc < 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openziti/ziti-sdk-nodejs",
   "description": "A NodeJS-based SDK for delivering secure applications over a Ziti Network",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "main": "./lib/ziti",
   "scripts": {
     "build": "npm run build:init; npm run build:c-sdk; npm install --build-from-source --clang=1",

package/src/Ziti_https_request.c

@@ -17,7 +17,6 @@ limitations under the License.
 #include "ziti-nodejs.h"
 #include <ziti/ziti_src.h>
 
-static const unsigned int U1 = 1;
 
 /**
  *  Number of hosts we can have client pools for
@@ -30,6 +29,7 @@ enum { listMapCapacity = 50 };
 enum { perKeyListMapCapacity = 25 };
 
 struct ListMap* HttpsClientListMap;
+struct ListMap* ServiceToHostnameListMap = NULL;
 
 struct key_value {
     char* key;
@@ -42,6 +42,11 @@ struct ListMap {
   uv_sem_t sem;
 };
 
+struct hostname_port {
+    char* hostname;
+    int   port;
+};
+
 struct ListMap* newListMap() {
     struct ListMap* listMap = calloc(1, sizeof *listMap);
     return listMap;
@@ -166,7 +171,16 @@ static void allocate_client(uv_work_t* req) {
 
       HttpsClient* httpsClient = calloc(1, sizeof *httpsClient);
       httpsClient->scheme_host_port = strdup(addon_data->scheme_host_port);
-      ziti_src_init(thread_loop, &(httpsClient->ziti_src), addon_data->service, ztx );
+
+      if (addon_data->haveURL) {
+        ZITI_NODEJS_LOG(DEBUG, "URL specified, so pasing NULL to ziti_src_init");
+        ziti_src_init(thread_loop, &(httpsClient->ziti_src), addon_data->service, ztx );
+      } else {
+        ZITI_NODEJS_LOG(DEBUG, "addon_data->service is: %s", addon_data->service);
+        ziti_src_init(thread_loop, &(httpsClient->ziti_src), addon_data->service, ztx );
+      }
+
+      ZITI_NODEJS_LOG(DEBUG, "addon_data->scheme_host_port is: %s", addon_data->scheme_host_port);
       um_http_init_with_src(thread_loop, &(httpsClient->client), addon_data->scheme_host_port, (um_src_t *)&(httpsClient->ziti_src) );
 
       listMapInsert(clientListMap, addon_data->scheme_host_port, (void*)httpsClient);
@@ -200,6 +214,61 @@ static void allocate_client(uv_work_t* req) {
 }
 
 
+struct hostname_port* getHostnamePortForService(char* key) {
+
+  ZITI_NODEJS_LOG(DEBUG, "getHostnamePortForService() entered, key: %s", key);
+
+  struct hostname_port* value = NULL;
+
+  if (NULL != ServiceToHostnameListMap) {
+
+    for (size_t i = 0 ; i < ServiceToHostnameListMap->count && value == NULL ; ++i) {
+      if (strcmp(ServiceToHostnameListMap->kvPairs[i].key, key) == 0) {
+        value = ServiceToHostnameListMap->kvPairs[i].value;
+        ZITI_NODEJS_LOG(DEBUG, "getHostnamePortForService() found value->hostname is: [%s], port is: [%d]", value->hostname, value->port);
+      }
+    }
+  }
+
+  ZITI_NODEJS_LOG(DEBUG, "getHostnamePortForService() returning value '%p'", value);
+
+  return value;
+}
+
+
+/**
+ * 
+ */
+void track_service_to_hostname(char* service_name, char* hostname, int port) {
+
+  ZITI_NODEJS_LOG(DEBUG, "track_service_to_hostname() entered, service_name: %s hostname: %s port: %d", service_name, hostname, port);
+
+  if (NULL == ServiceToHostnameListMap) {
+    ServiceToHostnameListMap = newListMap();
+  }
+
+  struct hostname_port* value = getHostnamePortForService(service_name);
+
+  if (NULL == value) {
+
+    value = calloc(1, sizeof(*value));
+    value->hostname = strdup(hostname);
+    value->port = port;
+
+    listMapInsert(ServiceToHostnameListMap, service_name, (void*)value);
+
+    ZITI_NODEJS_LOG(DEBUG, "track_service_to_hostname() inserting service_name: %s hostname: %s port: %d", service_name, hostname, port);
+
+  } else {
+
+    value->hostname = strdup(hostname);
+    value->port = port;
+
+    ZITI_NODEJS_LOG(DEBUG, "track_service_to_hostname() updating service_name: %s hostname: %s port: %d", service_name, hostname, port);
+
+  }
+}
+
 
 /**
  * This function is responsible for calling the JavaScript on_resp_body callback function 
@@ -657,12 +726,13 @@ void on_client(uv_work_t* req, int status) {
 /**
  * Initiate an HTTPS request
  * 
- * @param {string}   [0] url
+ * @param {string}   [0] serviceName | URL
  * @param {string}   [1] method
- * @param {string[]} [2] headers;                  Array of strings of the form "name:value"
- * @param {func}     [3] JS on_req  callback;      This is invoked from 'on_client' function above
- * @param {func}     [4] JS on_resp callback;      This is invoked from 'on_resp' function above
- * @param {func}     [5] JS on_resp_data callback; This is invoked from 'on_resp_data' function above
+ * @param {string}   [2] path
+ * @param {string[]} [3] headers;                  Array of strings of the form "name:value"
+ * @param {func}     [4] JS on_req  callback;      This is invoked from 'on_client' function above
+ * @param {func}     [5] JS on_resp callback;      This is invoked from 'on_resp' function above
+ * @param {func}     [6] JS on_resp_data callback; This is invoked from 'on_resp_data' function above
  * 
  * @returns {um_http_req_t} req  This allows the JS to subsequently write the Body to the request (see _Ziti_http_request_data)
 
@@ -672,7 +742,6 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   napi_status status;
   size_t result;
   napi_value jsRetval;
-  char* query = "";
   int rc;
 
   ZITI_NODEJS_LOG(DEBUG, "entered");
@@ -681,14 +750,15 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
     HttpsClientListMap = newListMap();
   }
 
-  size_t argc = 6;
-  napi_value args[6];
+  size_t argc = 7;
+  napi_value args[7];
   status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
   if (status != napi_ok) {
     napi_throw_error(env, NULL, "Failed to parse arguments");
+    return NULL;
   }
 
-  if (argc < 6) {
+  if (argc < 7) {
     napi_throw_error(env, "EINVAL", "Too few arguments");
     return NULL;
   }
@@ -697,87 +767,104 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   ZITI_NODEJS_LOG(DEBUG, "allocated addon_data : %p", addon_data);
   addon_data->env = env;
 
-  // Obtain url length
-  size_t url_len;
-  status = napi_get_value_string_utf8(env, args[0], NULL, 0, &url_len);
+  // Obtain serviceName length
+  size_t serviceName_len;
+  status = napi_get_value_string_utf8(env, args[0], NULL, 0, &serviceName_len);
   if (status != napi_ok) {
-    napi_throw_error(env, "EINVAL", "url is not a string");
+    napi_throw_error(env, "EINVAL", "serviceName is not a string");
+    return NULL;
   }
 
-  // Obtain url
-  char* url = calloc(1, url_len+2);
-  status = napi_get_value_string_utf8(env, args[0], url, url_len+1, &result);
+  // Obtain serviceName
+  char* serviceName = calloc(1, serviceName_len+2);
+  status = napi_get_value_string_utf8(env, args[0], serviceName, serviceName_len+1, &result);
   if (status != napi_ok) {
-    napi_throw_error(env, "EINVAL", "Failed to obtain url");
+    napi_throw_error(env, "EINVAL", "Failed to obtain serviceName");
+    return NULL;
   }
 
-  ZITI_NODEJS_LOG(DEBUG, "url: %s", url);
-
+  bool haveURL = false;
   struct http_parser_url url_parse = {0};
-  rc = http_parser_parse_url(url, strlen(url), false, &url_parse);
-  if (rc != 0) {
-    napi_throw_error(env, "EINVAL", "Failed to parse url");
+  rc = http_parser_parse_url(serviceName, strlen(serviceName), false, &url_parse);
+  if (rc == 0) {
+    haveURL = true;
+    ZITI_NODEJS_LOG(DEBUG, "serviceName IS a URL");
+  } else {
+    ZITI_NODEJS_LOG(DEBUG, "serviceName is NOT a URL");
   }
 
-  if (url_parse.field_set & (U1 << (unsigned int) UF_HOST)) {
-    addon_data->service = strndup(url + url_parse.field_data[UF_HOST].off, url_parse.field_data[UF_HOST].len);
-  }
-  else {
-    ZITI_NODEJS_LOG(ERROR, "invalid URL: no host");
-    napi_throw_error(env, "EINVAL", "invalid URL: no host");
-  }
+  struct hostname_port* hostname_port = NULL;
 
-  ZITI_NODEJS_LOG(DEBUG, "service: %s", addon_data->service);
+  if (haveURL) {
 
-  if (url_parse.field_set & (U1 << (unsigned int) UF_PATH)) {
-    addon_data->path = strndup(url + url_parse.field_data[UF_PATH].off, url_parse.field_data[UF_PATH].len);
-  }
-  else {
-    ZITI_NODEJS_LOG(ERROR, "invalid URL: no path");
-    napi_throw_error(env, "EINVAL", "invalid URL: no path");
-  }
+    addon_data->scheme_host_port = strdup(serviceName);
 
-  ZITI_NODEJS_LOG(DEBUG, "path: [%s]", addon_data->path);
+  } else {
 
-  if (url_parse.field_set & (U1 << (unsigned int) UF_QUERY)) {
-    query = strndup(url + url_parse.field_data[UF_QUERY].off, url_parse.field_data[UF_QUERY].len);
-    ZITI_NODEJS_LOG(DEBUG, "query: [%s]", query);
-    char* expanded_path = calloc(1, strlen(addon_data->path)+strlen(query)+2);
+    hostname_port = getHostnamePortForService(serviceName);
+    if (NULL == hostname_port) {
+      napi_throw_error(env, "EINVAL", "Unknown serviceName");
+      return NULL;
+    }
+    addon_data->service = strdup(serviceName);
 
-    strcat(expanded_path, addon_data->path);
-    strcat(expanded_path, "?");
-    strcat(expanded_path, query);
-    ZITI_NODEJS_LOG(DEBUG, "expanded_path: [%s]", expanded_path);
-    free(addon_data->path);
-    addon_data->path = expanded_path;
-  }
-  else {
-    ZITI_NODEJS_LOG(DEBUG, "URL: no query found");
-  }
-  ZITI_NODEJS_LOG(DEBUG, "adjusted path: [%s]", addon_data->path);
+    ZITI_NODEJS_LOG(DEBUG, "addon_data->service: %s", addon_data->service);
+
+    addon_data->scheme_host_port = calloc(1, 100);
 
-  addon_data->scheme_host_port = strndup(url + url_parse.field_data[UF_SCHEMA].off, url_parse.field_data[UF_PATH].off);
+    if (hostname_port->port == 443) {
+      strcat(addon_data->scheme_host_port, "https://");
+      strcat(addon_data->scheme_host_port, hostname_port->hostname);
+    } else {
+      strcat(addon_data->scheme_host_port, "http://");
+      strcat(addon_data->scheme_host_port, hostname_port->hostname);
+      strcat(addon_data->scheme_host_port, ":");
+      char sport[8];
+      sprintf(sport, "%d", hostname_port->port);
+      strcat(addon_data->scheme_host_port, sport);
+    }
+  }
 
-  ZITI_NODEJS_LOG(DEBUG, "scheme_host_port: %s", addon_data->scheme_host_port);
+  addon_data->haveURL = haveURL;
 
+  ZITI_NODEJS_LOG(DEBUG, "scheme_host_port: %s, haveURL: %d", addon_data->scheme_host_port, haveURL);
 
   // Obtain method length
   size_t method_len;
   status = napi_get_value_string_utf8(env, args[1], NULL, 0, &method_len);
   if (status != napi_ok) {
     napi_throw_error(env, "EINVAL", "method is not a string");
+    return NULL;
   }
   // Obtain method
   addon_data->method = calloc(1, method_len+2);
   status = napi_get_value_string_utf8(env, args[1], addon_data->method, method_len+1, &result);
   if (status != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to obtain method");
+    return NULL;
   }
 
   ZITI_NODEJS_LOG(DEBUG, "method: %s", addon_data->method);
 
+  // Obtain path length
+  size_t path_len;
+  status = napi_get_value_string_utf8(env, args[2], NULL, 0, &path_len);
+  if (status != napi_ok) {
+    napi_throw_error(env, "EINVAL", "path is not a string");
+    return NULL;
+  }
+  // Obtain path
+  addon_data->path = calloc(1, path_len+2);
+  status = napi_get_value_string_utf8(env, args[2], addon_data->path, path_len+1, &result);
+  if (status != napi_ok) {
+    napi_throw_error(env, "EINVAL", "Failed to obtain path");
+    return NULL;
+  }
+
+  ZITI_NODEJS_LOG(DEBUG, "path: %s", addon_data->path);
+
   // Obtain ptr to JS on_req callback function
-  napi_value js_cb = args[3];
+  napi_value js_cb = args[4];
   napi_value work_name;
 
 
@@ -789,6 +876,7 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   rc = napi_create_string_utf8(env, "on_req", NAPI_AUTO_LENGTH, &work_name);
   if (rc != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to create string");
+    return NULL;
   }
 
   // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
@@ -808,16 +896,18 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   );
   if (rc != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to create threadsafe_function");
+    return NULL;
   }
   ZITI_NODEJS_LOG(DEBUG, "napi_create_threadsafe_function addon_data->tsfn_on_req() : %p", addon_data->tsfn_on_req);
 
   // Obtain ptr to JS on_resp callback function
-  napi_value js_cb2 = args[4];
+  napi_value js_cb2 = args[5];
 
   // Create a string to describe this asynchronous operation.
   rc = napi_create_string_utf8(env, "on_resp", NAPI_AUTO_LENGTH, &work_name);
   if (rc != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to create string");
+    return NULL;
   }
 
   // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
@@ -837,17 +927,19 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   );
   if (rc != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to create threadsafe_function");
+    return NULL;
   }
   ZITI_NODEJS_LOG(DEBUG, "napi_create_threadsafe_function addon_data->tsfn_on_resp() : %p", addon_data->tsfn_on_resp);
 
 
   // Obtain ptr to JS on_resp_data callback function
-  napi_value js_cb3 = args[5];
+  napi_value js_cb3 = args[6];
 
   // Create a string to describe this asynchronous operation.
   rc = napi_create_string_utf8(env, "on_resp_data", NAPI_AUTO_LENGTH, &work_name);
   if (rc != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to create string");
+    return NULL;
   }
 
   // Convert the callback retrieved from JavaScript into a thread-safe function (tsfn) 
@@ -867,6 +959,7 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   );
   if (rc != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to create threadsafe_function");
+    return NULL;
   }
   ZITI_NODEJS_LOG(DEBUG, "napi_create_threadsafe_function addon_data->tsfn_on_resp_body() : %p", addon_data->tsfn_on_resp_body);
 
@@ -874,17 +967,19 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   // Capture headers
   //
   uint32_t i;
-  status = napi_get_array_length(env, args[2], &addon_data->headers_array_length);
+  status = napi_get_array_length(env, args[3], &addon_data->headers_array_length);
   if (status != napi_ok) {
     napi_throw_error(env, "EINVAL", "Failed to obtain headers array");
+    return NULL;
   }
   ZITI_NODEJS_LOG(DEBUG, "headers_array_length: %d", addon_data->headers_array_length);
   for (i = 0; i < addon_data->headers_array_length; i++) {
 
     napi_value headers_array_element;
-    status = napi_get_element(env, args[2], i, &headers_array_element);
+    status = napi_get_element(env, args[3], i, &headers_array_element);
     if (status != napi_ok) {
       napi_throw_error(env, "EINVAL", "Failed to obtain headers element");
+      return NULL;
     }
 
     // Obtain element length
@@ -892,6 +987,7 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
     status = napi_get_value_string_utf8(env, headers_array_element, NULL, 0, &element_len);
     if (status != napi_ok) {
       napi_throw_error(env, "EINVAL", "header arry element is not a string");
+      return NULL;
     }
     ZITI_NODEJS_LOG(DEBUG, "element_len: %zd", element_len);
 
@@ -906,16 +1002,19 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
     status = napi_get_value_string_utf8(env, headers_array_element, header_element, element_len+1, &result);
     if (status != napi_ok) {
       napi_throw_error(env, "EINVAL", "Failed to obtain element");
+      return NULL;
     }
     ZITI_NODEJS_LOG(DEBUG, "header_element: %s", header_element);
 
     char * header_name = strtok(header_element, ":");
     if (NULL == header_name) {
       napi_throw_error(env, "EINVAL", "Failed to split header element");
+      return NULL;
     }
     char * header_value = strtok(NULL, ":");
     if (strlen(header_value) < 1) {
       napi_throw_error(env, "EINVAL", "Failed to split header element");
+      return NULL;
     }
 
     addon_data->header_name[i] = strdup(header_name);
@@ -938,6 +1037,7 @@ napi_value _Ziti_http_request(napi_env env, const napi_callback_info info) {
   status = napi_create_int64(env, (int64_t)0, &jsRetval);
   if (status != napi_ok) {
     napi_throw_error(env, NULL, "Unable to create return value");
+    return NULL;
   }
   return jsRetval;
 }

package/src/ziti-nodejs.h

@@ -177,6 +177,7 @@ struct HttpsAddonData {
   HttpsRespItem* item;
   HttpsReq* httpsReq;
   uv_work_t uv_req;
+  bool haveURL;
   char* service;
   char* scheme_host_port;
   char* method;
@@ -218,6 +219,7 @@ extern void expose_ziti_websocket_write(napi_env env, napi_value exports);
 //
 extern int um_websocket_init_with_src (uv_loop_t *loop, um_websocket_t *ws, um_src_t *src);
 
+extern void track_service_to_hostname(char* service_name, char* hostname, int port);
 
 #ifdef __cplusplus
 }

package/src/ziti_init.c

@@ -153,6 +153,77 @@ static void on_ziti_event(ziti_context _ztx, const ziti_event_t *event) {
               // service_check_cb(ztx, *sp, ZITI_OK, app_ctx);
           }
       }
+
+      if (event->event.service.changed != NULL) {
+          for (ziti_service **sp = event->event.service.changed; *sp != NULL; sp++) {
+              // service_check_cb(ztx, *sp, ZITI_OK, app_ctx);
+          }
+      }
+
+      //
+      for (int i = 0; event->event.service.added && event->event.service.added[i] != NULL; i++) {
+
+        ziti_service *s = event->event.service.added[i];
+        ziti_intercept_cfg_v1 *intercept = alloc_ziti_intercept_cfg_v1();
+        ziti_client_cfg_v1 clt_cfg = {
+          .hostname = {0},
+          .port = 0
+        };
+
+        if (ziti_service_get_config(s, ZITI_INTERCEPT_CFG_V1, intercept, (int (*)(void *, const char *, size_t))parse_ziti_intercept_cfg_v1) == ZITI_OK) {
+
+          const ziti_address *range_addr;
+          MODEL_LIST_FOREACH(range_addr, intercept->addresses) {
+            ziti_port_range *p;
+            MODEL_LIST_FOREACH(p, intercept->port_ranges) {
+                int lowport = p->low;
+                while (lowport <= p->high) {
+                  track_service_to_hostname(s->name, (char *)range_addr->addr.hostname, lowport);
+                  lowport++;
+                }
+            }
+          }
+
+        } else if (ziti_service_get_config(s, ZITI_CLIENT_CFG_V1, &clt_cfg, (int (*)(void *, const char *, unsigned long))parse_ziti_client_cfg_v1) == ZITI_OK) {
+            track_service_to_hostname(s->name, clt_cfg.hostname.addr.hostname, clt_cfg.port);
+        }
+
+        free_ziti_intercept_cfg_v1(intercept);
+        free(intercept);
+      }
+
+      for (int i = 0; event->event.service.changed && event->event.service.changed[i] != NULL; i++) {
+
+        ziti_service *s = event->event.service.changed[i];
+        ziti_intercept_cfg_v1 *intercept = alloc_ziti_intercept_cfg_v1();
+        ziti_client_cfg_v1 clt_cfg = {
+          .hostname = {0},
+          .port = 0
+        };
+
+        if (ziti_service_get_config(s, ZITI_INTERCEPT_CFG_V1, intercept, (int (*)(void *, const char *, size_t))parse_ziti_intercept_cfg_v1) == ZITI_OK) {
+
+          const ziti_address *range_addr;
+          MODEL_LIST_FOREACH(range_addr, intercept->addresses) {
+            ziti_port_range *p;
+            MODEL_LIST_FOREACH(p, intercept->port_ranges) {
+                int lowport = p->low;
+                while (lowport <= p->high) {
+                  track_service_to_hostname(s->name, (char *)range_addr->addr.hostname, lowport);
+                  lowport++;
+                }
+            }
+          }
+
+        } else if (ziti_service_get_config(s, ZITI_CLIENT_CFG_V1, &clt_cfg, (int (*)(void *, const char *, unsigned long))parse_ziti_client_cfg_v1) == ZITI_OK) {
+            track_service_to_hostname(s->name, clt_cfg.hostname.addr.hostname, clt_cfg.port);
+        }
+
+        free_ziti_intercept_cfg_v1(intercept);
+        free(intercept);
+      }
+
+
       break;
 
     case ZitiRouterEvent: