@openziti/ziti-sdk-nodejs 0.6.0

package/src/Ziti_https_request_data.c

@@ -0,0 +1,250 @@
+/*
+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 <ziti/ziti_src.h>
+
+
+/**
+ * This function is responsible for calling the JavaScript on_resp_data callback function 
+ * that was specified when the Ziti_https_request_data(...) was called from JavaScript.
+ */
+static void CallJs_on_req_body(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 HttpsRespBodyItem created by the worker thread.
+  HttpsReqBodyItem* item = (HttpsReqBodyItem*)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
+  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.
+    napi_get_undefined(env, &undefined);
+
+    // const obj = {}
+    napi_value js_http_item, js_req, js_status, js_body;
+    int rc = napi_create_object(env, &js_http_item);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to create object");
+    }
+
+    // obj.req = req
+    napi_create_int64(env, (int64_t)item->req, &js_req);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to create resp.req");
+    }
+    rc = napi_set_named_property(env, js_http_item, "req", js_req);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to set named property req");
+    }
+    ZITI_NODEJS_LOG(DEBUG, "js_req: %p", item->req);
+
+    // obj.code = status
+    rc = napi_create_int32(env, item->status, &js_status);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to create resp.status");
+    }
+    rc = napi_set_named_property(env, js_http_item, "status", js_status);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to set named property status");
+    }
+    ZITI_NODEJS_LOG(DEBUG, "status: %zd", item->status);
+
+    // obj.body = body
+    rc = napi_create_int32(env, (int32_t)item->body, &js_body);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to create resp.body");
+    }
+    rc = napi_set_named_property(env, js_http_item, "body", js_body);
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to set named property body");
+    }
+
+    // Call the JavaScript function and pass it the HttpsRespItem
+    rc = napi_call_function(
+      env,
+      undefined,
+      js_cb,
+      1,
+      &js_http_item,
+      NULL
+    );
+    if (rc != napi_ok) {
+      napi_throw_error(env, "EINVAL", "failure to invoke JS callback");
+    }
+
+  }
+}
+
+
+
+/**
+ * 
+ */
+void on_req_body(um_http_req_t *req, const char *body, ssize_t status) {
+
+  ZITI_NODEJS_LOG(DEBUG, "status: %zd, body: %p", status, body);
+
+  HttpsAddonData* addon_data = (HttpsAddonData*) req->data;
+  ZITI_NODEJS_LOG(DEBUG, "addon_data is: %p", addon_data);
+
+  HttpsReqBodyItem* item = calloc(1, sizeof(*item));
+  ZITI_NODEJS_LOG(DEBUG, "new HttpsReqBodyItem is: %p", item);
+  
+  //  Grab everything off the um_http_resp_t that we need to eventually pass on to the JS on_resp_body callback.
+  //  If we wait until CallJs_on_resp_body is invoked to do that work, the um_http_resp_t may have already been free'd by the C-SDK
+
+  item->req = req;
+  item->body = (void*)body;
+  item->status = status;
+
+  ZITI_NODEJS_LOG(DEBUG, "calling tsfn_on_req_body: %p", addon_data->tsfn_on_req_body);
+
+  // Initiate the call into the JavaScript callback.
+  int rc = napi_call_threadsafe_function(
+      addon_data->tsfn_on_req_body,
+      item,
+      napi_tsfn_blocking);
+  if (rc != napi_ok) {
+    napi_throw_error(addon_data->env, "EINVAL", "failure to invoke JS callback");
+  }
+}
+
+
+
+/**
+ * Send Body data over active HTTPS request
+ * 
+ * @param {string} [0] req
+ * @param {string} [1] data (we expect a Buffer)
+ * @param {func}   [2] JS on_write callback;      This is invoked from 'on_req_body' function above
+ * 
+ * @returns NULL
+ */
+napi_value _Ziti_http_request_data(napi_env env, const napi_callback_info info) {
+  napi_status status;
+  int rc;
+  size_t argc = 3;
+  napi_value args[3];
+  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 < 3) {
+    napi_throw_error(env, "EINVAL", "Too few arguments");
+    return NULL;
+  }
+
+  // Obtain um_http_req_t
+  int64_t js_req;
+  status = napi_get_value_int64(env, args[0], &js_req);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get Req");
+  }
+  // um_http_req_t *r = (um_http_req_t*)js_req;
+  HttpsReq* httpsReq = (HttpsReq*)js_req;
+  um_http_req_t *r = httpsReq->req;
+
+  ZITI_NODEJS_LOG(DEBUG, "req: %p", r);
+
+  HttpsAddonData* addon_data = httpsReq->addon_data;
+  ZITI_NODEJS_LOG(DEBUG, "addon_data is: %p", addon_data);
+
+  // If some kind of Ziti error previously occured on this request, then short-circuit now
+  if (httpsReq->on_resp_has_fired && (httpsReq->respCode < 0)) {
+    ZITI_NODEJS_LOG(DEBUG, "aborting due to previous error: %d", httpsReq->respCode);
+    return NULL;
+  }
+
+  // Obtain data to write (we expect a Buffer)
+  void*  buffer;
+  size_t bufferLength;
+  status = napi_get_buffer_info(env, args[1], &buffer, &bufferLength);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get Buffer info");
+  }
+  ZITI_NODEJS_LOG(DEBUG, "bufferLength: %zd", bufferLength);
+
+  // Since the underlying Buffer's lifetime is not guaranteed if it's managed by the VM, we will copy the chunk into our heap
+  void* chunk = calloc(1, bufferLength + 1);
+  memcpy(chunk, buffer, bufferLength);
+
+  // Obtain ptr to JS 'on_write' callback function
+  napi_value js_write_cb = args[2];
+  napi_value work_name;
+
+  // Create a string to describe this asynchronous operation.
+  status = napi_create_string_utf8(
+    env,
+    "N-API on_write",
+    NAPI_AUTO_LENGTH,
+    &work_name);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed 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.
+  rc = napi_create_threadsafe_function(
+      env,
+      js_write_cb,
+      NULL,
+      work_name,
+      0,
+      1,
+      NULL,
+      NULL,
+      NULL,
+      CallJs_on_req_body,
+      &(addon_data->tsfn_on_req_body)
+  );
+  if (rc != napi_ok) {
+    napi_throw_error(env, "EINVAL", "Failed to create threadsafe_function");
+  }
+  ZITI_NODEJS_LOG(DEBUG, "napi_create_threadsafe_function addon_data->tsfn_on_req_body() : %p", addon_data->tsfn_on_req_body);
+
+  // Now, call the C-SDK to actually write the data over to the service
+  um_http_req_data(r, chunk, bufferLength, on_req_body );
+
+  return NULL;
+}
+
+
+void expose_ziti_https_request_data(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn;
+
+  status = napi_create_function(env, NULL, 0, _Ziti_http_request_data, NULL, &fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to wrap native function '_Ziti_http_request_data");
+  }
+
+  status = napi_set_named_property(env, exports, "Ziti_http_request_data", fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to populate exports for 'Ziti_http_request_data");
+  }
+
+}

package/src/Ziti_https_request_end.c

@@ -0,0 +1,79 @@
+/*
+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 <ziti/ziti_src.h>
+
+
+/**
+ * Indicate that an active HTTPS request is now complete
+ * 
+ * @param {string} [0] req
+ * 
+ * @returns NULL
+ */
+napi_value _Ziti_http_request_end(napi_env env, const napi_callback_info info) {
+  napi_status status;
+  size_t argc = 1;
+  napi_value args[1];
+  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 != 1) {
+    napi_throw_error(env, "EINVAL", "Invalid argument count");
+    return NULL;
+  }
+
+  // Obtain um_http_req_t
+  int64_t js_req;
+  status = napi_get_value_int64(env, args[0], &js_req);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Failed to get Req");
+  }
+  HttpsReq* httpsReq = (HttpsReq*)js_req;
+  um_http_req_t *r = httpsReq->req;
+
+  ZITI_NODEJS_LOG(DEBUG, "req: %p", r);
+
+  // TEMP hack to work around an issue still being debugged
+  ZITI_NODEJS_LOG(DEBUG, "httpsReq->on_resp_has_fired: %o", httpsReq->on_resp_has_fired);
+  if (httpsReq->on_resp_has_fired) {
+    ZITI_NODEJS_LOG(DEBUG, "seems as though on_resp has previously fired... skipping call to um_http_req_end");
+  } else {
+    um_http_req_end(r);
+  }
+
+  return NULL;
+}
+
+
+void expose_ziti_https_request_end(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value fn;
+
+  status = napi_create_function(env, NULL, 0, _Ziti_http_request_end, NULL, &fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to wrap native function '_Ziti_http_request_end");
+  }
+
+  status = napi_set_named_property(env, exports, "Ziti_http_request_end", fn);
+  if (status != napi_ok) {
+    napi_throw_error(env, NULL, "Unable to populate exports for 'Ziti_http_request_end");
+  }
+
+}

package/src/stack_traces.c

@@ -0,0 +1,334 @@
+/*
+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.
+*/
+
+/* compile with:
+on linux:   gcc -g stack_traces.c
+on OS X:    gcc -g -fno-pie stack_traces.c
+on windows: gcc -g stack_traces.c -limagehlp
+*/
+
+#include <signal.h>
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <errno.h>
+// #include <pthread.h>
+#include <node_api.h>
+
+#ifdef _WIN32
+  #include <windows.h>
+  #include <imagehlp.h>
+#else
+  #include <err.h>
+  #include <execinfo.h>
+#endif
+
+#include <ziti/ziti.h>
+
+static char const * icky_global_program_name = "ziti-nodejs";
+
+
+/**
+ *  Resolve symbol name and source location given the path to the executable and an address
+ */
+int addr2line(char const * const program_name, void const * const addr)
+{
+  char addr2line_cmd[512] = {0};
+
+  /* have addr2line map the address to the relent line in the code */
+  #ifdef __APPLE__
+    /* apple does things differently... */
+    sprintf(addr2line_cmd,"atos -o %.256s %p", program_name, addr); 
+  #else
+    sprintf(addr2line_cmd,"addr2line -f -p -e %.256s %p", program_name, addr); 
+  #endif
+
+  return system(addr2line_cmd);
+}
+
+#ifdef _WIN32
+  void windows_print_stacktrace(CONTEXT* context)
+  {
+    SymInitialize(GetCurrentProcess(), 0, true);
+
+    STACKFRAME frame = { 0 };
+
+    /* setup initial stack frame */
+    frame.AddrPC.Offset         = context->Eip;
+    frame.AddrPC.Mode           = AddrModeFlat;
+    frame.AddrStack.Offset      = context->Esp;
+    frame.AddrStack.Mode        = AddrModeFlat;
+    frame.AddrFrame.Offset      = context->Ebp;
+    frame.AddrFrame.Mode        = AddrModeFlat;
+
+    while (StackWalk(IMAGE_FILE_MACHINE_I386 ,
+                     GetCurrentProcess(),
+                     GetCurrentThread(),
+                     &frame,
+                     context,
+                     0,
+                     SymFunctionTableAccess,
+                     SymGetModuleBase,
+                     0 ) )
+    {
+      addr2line(icky_global_program_name, (void*)frame.AddrPC.Offset);
+    }
+
+    SymCleanup( GetCurrentProcess() );
+  }
+
+  LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS * ExceptionInfo)
+  {
+    switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
+    {
+      case EXCEPTION_ACCESS_VIOLATION:
+        fputs("Error: EXCEPTION_ACCESS_VIOLATION\n", stderr);
+        break;
+      case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+        fputs("Error: EXCEPTION_ARRAY_BOUNDS_EXCEEDED\n", stderr);
+        break;
+      case EXCEPTION_BREAKPOINT:
+        fputs("Error: EXCEPTION_BREAKPOINT\n", stderr);
+        break;
+      case EXCEPTION_DATATYPE_MISALIGNMENT:
+        fputs("Error: EXCEPTION_DATATYPE_MISALIGNMENT\n", stderr);
+        break;
+      case EXCEPTION_FLT_DENORMAL_OPERAND:
+        fputs("Error: EXCEPTION_FLT_DENORMAL_OPERAND\n", stderr);
+        break;
+      case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+        fputs("Error: EXCEPTION_FLT_DIVIDE_BY_ZERO\n", stderr);
+        break;
+      case EXCEPTION_FLT_INEXACT_RESULT:
+        fputs("Error: EXCEPTION_FLT_INEXACT_RESULT\n", stderr);
+        break;
+      case EXCEPTION_FLT_INVALID_OPERATION:
+        fputs("Error: EXCEPTION_FLT_INVALID_OPERATION\n", stderr);
+        break;
+      case EXCEPTION_FLT_OVERFLOW:
+        fputs("Error: EXCEPTION_FLT_OVERFLOW\n", stderr);
+        break;
+      case EXCEPTION_FLT_STACK_CHECK:
+        fputs("Error: EXCEPTION_FLT_STACK_CHECK\n", stderr);
+        break;
+      case EXCEPTION_FLT_UNDERFLOW:
+        fputs("Error: EXCEPTION_FLT_UNDERFLOW\n", stderr);
+        break;
+      case EXCEPTION_ILLEGAL_INSTRUCTION:
+        fputs("Error: EXCEPTION_ILLEGAL_INSTRUCTION\n", stderr);
+        break;
+      case EXCEPTION_IN_PAGE_ERROR:
+        fputs("Error: EXCEPTION_IN_PAGE_ERROR\n", stderr);
+        break;
+      case EXCEPTION_INT_DIVIDE_BY_ZERO:
+        fputs("Error: EXCEPTION_INT_DIVIDE_BY_ZERO\n", stderr);
+        break;
+      case EXCEPTION_INT_OVERFLOW:
+        fputs("Error: EXCEPTION_INT_OVERFLOW\n", stderr);
+        break;
+      case EXCEPTION_INVALID_DISPOSITION:
+        fputs("Error: EXCEPTION_INVALID_DISPOSITION\n", stderr);
+        break;
+      case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+        fputs("Error: EXCEPTION_NONCONTINUABLE_EXCEPTION\n", stderr);
+        break;
+      case EXCEPTION_PRIV_INSTRUCTION:
+        fputs("Error: EXCEPTION_PRIV_INSTRUCTION\n", stderr);
+        break;
+      case EXCEPTION_SINGLE_STEP:
+        fputs("Error: EXCEPTION_SINGLE_STEP\n", stderr);
+        break;
+      case EXCEPTION_STACK_OVERFLOW:
+        fputs("Error: EXCEPTION_STACK_OVERFLOW\n", stderr);
+        break;
+      default:
+        fputs("Error: Unrecognized Exception\n", stderr);
+        break;
+    }
+    fflush(stderr);
+    /* If this is a stack overflow then we can't walk the stack, so just show
+      where the error happened */
+    if (EXCEPTION_STACK_OVERFLOW != ExceptionInfo->ExceptionRecord->ExceptionCode)
+    {
+        windows_print_stacktrace(ExceptionInfo->ContextRecord);
+    }
+    else
+    {
+        addr2line(icky_global_program_name, (void*)ExceptionInfo->ContextRecord->Eip);
+    }
+
+    return EXCEPTION_EXECUTE_HANDLER;
+  }
+
+  void set_signal_handler()
+  {
+    SetUnhandledExceptionFilter(windows_exception_handler);
+  }
+#else
+
+  #define MAX_STACK_FRAMES 64
+  static void *stack_traces[MAX_STACK_FRAMES];
+  void posix_print_stack_trace()
+  {
+    int i, trace_size = 0;
+    char **messages = (char **)NULL;
+
+    trace_size = backtrace(stack_traces, MAX_STACK_FRAMES);
+    messages = backtrace_symbols(stack_traces, trace_size);
+
+    /* skip the first couple stack frames (as they are this function and
+     our handler) and also skip the last frame as it's (always?) junk. */
+    for (i = 3; i < (trace_size - 1); ++i)
+    // for (i = 4; i < (trace_size - 1); ++i)
+    // for (i = 0; i < trace_size; ++i) // we'll use this for now so you can see what's going on
+    {
+      if (addr2line(icky_global_program_name, stack_traces[i]) != 0)
+      {
+        printf("  error determining line # for: %s\n", messages[i]);
+      }
+
+    }
+    if (messages) { free(messages); } 
+  }
+
+  void posix_signal_handler(int sig, siginfo_t *siginfo, void *context)
+  {
+    (void)context;
+    switch(sig)
+    {
+      case SIGSEGV:
+        fputs("Caught SIGSEGV: Segmentation Fault\n", stderr);
+        break;
+      case SIGINT:
+        fputs("Caught SIGINT: Interactive attention signal, (usually ctrl+c)\n", stderr);
+        break;
+      case SIGFPE:
+        switch(siginfo->si_code)
+        {
+          case FPE_INTDIV:
+            fputs("Caught SIGFPE: (integer divide by zero)\n", stderr);
+            break;
+          case FPE_INTOVF:
+            fputs("Caught SIGFPE: (integer overflow)\n", stderr);
+            break;
+          case FPE_FLTDIV:
+            fputs("Caught SIGFPE: (floating-point divide by zero)\n", stderr);
+            break;
+          case FPE_FLTOVF:
+            fputs("Caught SIGFPE: (floating-point overflow)\n", stderr);
+            break;
+          case FPE_FLTUND:
+            fputs("Caught SIGFPE: (floating-point underflow)\n", stderr);
+            break;
+          case FPE_FLTRES:
+            fputs("Caught SIGFPE: (floating-point inexact result)\n", stderr);
+            break;
+          case FPE_FLTINV:
+            fputs("Caught SIGFPE: (floating-point invalid operation)\n", stderr);
+            break;
+          case FPE_FLTSUB:
+            fputs("Caught SIGFPE: (subscript out of range)\n", stderr);
+            break;
+          default:
+            fputs("Caught SIGFPE: Arithmetic Exception\n", stderr);
+            break;
+        }
+      case SIGILL:
+        switch(siginfo->si_code)
+        {
+          case ILL_ILLOPC:
+            fputs("Caught SIGILL: (illegal opcode)\n", stderr);
+            break;
+          case ILL_ILLOPN:
+            fputs("Caught SIGILL: (illegal operand)\n", stderr);
+            break;
+          case ILL_ILLADR:
+            fputs("Caught SIGILL: (illegal addressing mode)\n", stderr);
+            break;
+          case ILL_ILLTRP:
+            fputs("Caught SIGILL: (illegal trap)\n", stderr);
+            break;
+          case ILL_PRVOPC:
+            fputs("Caught SIGILL: (privileged opcode)\n", stderr);
+            break;
+          case ILL_PRVREG:
+            fputs("Caught SIGILL: (privileged register)\n", stderr);
+            break;
+          case ILL_COPROC:
+            fputs("Caught SIGILL: (coprocessor error)\n", stderr);
+            break;
+          case ILL_BADSTK:
+            fputs("Caught SIGILL: (internal stack error)\n", stderr);
+            break;
+          default:
+            fputs("Caught SIGILL: Illegal Instruction\n", stderr);
+            break;
+        }
+        break;
+      case SIGTERM:
+        fputs("Caught SIGTERM: a termination request was sent to the program\n", stderr);
+        break;
+      case SIGABRT:
+        fputs("Caught SIGABRT: usually caused by an abort() or assert()\n", stderr);
+        break;
+      default:
+        break;
+    }
+    posix_print_stack_trace();
+    _Exit(1);
+  }
+
+  static uint8_t alternate_stack[SIGSTKSZ];
+  void set_signal_handler()
+  {
+    /* setup alternate stack */
+    {
+      stack_t ss = {};
+      /* malloc is usually used here, I'm not 100% sure my static allocation
+         is valid but it seems to work just fine. */
+      ss.ss_sp = (void*)alternate_stack;
+      ss.ss_size = SIGSTKSZ;
+      ss.ss_flags = 0;
+
+      if (sigaltstack(&ss, NULL) != 0) { err(1, "sigaltstack"); }
+    }
+
+    /* register our signal handlers */
+    {
+      struct sigaction sig_action = {};
+      sig_action.sa_sigaction = posix_signal_handler;
+      sigemptyset(&sig_action.sa_mask);
+
+      #ifdef __APPLE__
+          /* for some reason we backtrace() doesn't work on osx
+             when we use an alternate stack */
+          sig_action.sa_flags = SA_SIGINFO;
+      #else
+          sig_action.sa_flags = SA_SIGINFO | SA_ONSTACK;
+      #endif
+
+      if (sigaction(SIGSEGV, &sig_action, NULL) != 0) { err(1, "sigaction"); }
+      if (sigaction(SIGFPE,  &sig_action, NULL) != 0) { err(1, "sigaction"); }
+      if (sigaction(SIGINT,  &sig_action, NULL) != 0) { err(1, "sigaction"); }
+      if (sigaction(SIGILL,  &sig_action, NULL) != 0) { err(1, "sigaction"); }
+      if (sigaction(SIGTERM, &sig_action, NULL) != 0) { err(1, "sigaction"); }
+      if (sigaction(SIGABRT, &sig_action, NULL) != 0) { err(1, "sigaction"); }
+    }
+  }
+#endif