updated with improved POSIX fatal handling

.vscode/launch.json

@@ -12,10 +12,9 @@
             "name": "(gdb) Start",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/build/g3log-FATAL-contract",
+            "program": "${workspaceFolder}/build/test_signal",
             "MIMode": "gdb",
-            "cwd": "${workspaceFolder}/build"
-            "setupCommands": [
+            "cwd": "${workspaceFolder}/build""setupCommands": [
                 {
                     "description": "Enable pretty-printing for gdb",
                     "text": "-enable-pretty-printing",
@@ -28,6 +27,5 @@
                 }
             ]
         }
-
     ]
 }

.vscode/settings.json

@@ -1,4 +1,7 @@
 {
     "cmake.configureOnOpen": false,
-    "editor.formatOnSave": true
-}
+    "editor.formatOnSave": true,
+    "files.associations": {
+        "ostream": "cpp"
+    }
+}

src/crashhandler_unix.cpp

@@ -242,6 +242,30 @@ namespace g3 {
          exit(signal_number);
       }
 
+      // This function is intended to be async-signal-safe. Using write and STDERR_FILENO should be
+      // safe in a signal handler. ref: http://pubs.opengroup.org/onlinepubs/009695399/functions/write.html
+
+      // This function is intended to be async-signal-safe.
+      // It writes an error message to stderr using the write system call,
+      // which is listed as async-signal-safe by POSIX.
+      size_t writeErrorMessage(const char* message) {
+         if (message == nullptr) {
+            return 0;
+         }
+
+         // Calculate the length of the message without using std library strlen or similar
+         // this is to ensure async-signal-safe by POSIX
+         size_t length = 0;
+         for (const char* p = message; *p != '\0'; ++p) {
+            ++length;
+         }
+
+         // Write the message to STDERR_FILENO in a single call.
+         // This assumes that the message is not too large for a single write.
+         auto bytes_written = write(STDERR_FILENO, message, length);
+         return bytes_written;
+      }
+
       // restores the signal handler back to default
       void restoreFatalHandlingToDefault() {
 #if !(defined(DISABLE_FATAL_SIGNALHANDLING))
@@ -274,10 +298,8 @@ namespace g3 {
 
       if (sigaction(signal_number, &(old_action_it->second), nullptr) < 0) {
          auto signalname = std::string("sigaction - ") + signalToStr(signal_number);
-                  // https://man7.org/linux/man-pages/man7/signal-safety.7.html (see signal-safety)
-                  // perror is not async-signal-safe 
-         perror(signalname.c_str()); 
-
+         // https://man7.org/linux/man-pages/man7/signal-safety.7.html (see signal-safety)
+         internal::writeErrorMessage(signalname.c_str());
       }
 
       gSavedSigActions.erase(old_action_it);

src/crashhandler_windows.cpp

@@ -171,6 +171,12 @@ namespace g3 {
          raise(signal_number);
       }
 
+      // FYI: Concept of async-signal-safe operations does not exist on windows
+      // we stick to perror for lack of better alternatives.
+      void writeErrorMessage(const char* message) {
+         perror(message)
+      }
+
       // Restore back to default fatal event handling
       void restoreFatalHandlingToDefault() {
 #if !(defined(DISABLE_FATAL_SIGNALHANDLING))
@@ -181,19 +187,19 @@ namespace g3 {
 #endif
 
          if (SIG_ERR == signal(SIGABRT, SIG_DFL))
-            perror("signal - SIGABRT");
+            internal::writeErrorMessage("signal - SIGABRT");
 
          if (SIG_ERR == signal(SIGFPE, SIG_DFL))
-            perror("signal - SIGABRT");
+            internal::writeErrorMessage("signal - SIGABRT");
 
          if (SIG_ERR == signal(SIGSEGV, SIG_DFL))
-            perror("signal - SIGABRT");
+            internal::writeErrorMessage("signal - SIGABRT");
 
          if (SIG_ERR == signal(SIGILL, SIG_DFL))
-            perror("signal - SIGABRT");
+            internal::writeErrorMessage("signal - SIGABRT");
 
          if (SIG_ERR == signal(SIGTERM, SIG_DFL))
-            perror("signal - SIGABRT");
+            internal::writeErrorMessage("signal - SIGABRT");
 #endif
       }
 
@@ -207,20 +213,20 @@ namespace g3 {
    /// on Windows. This is automatically done if you do at least one LOG(...) call
    /// you can also use this function call, per thread so make sure these three
    /// fatal signals are covered in your thread (even if you don't do a LOG(...) call
-   void installSignalHandlerForThread() {
+   size_t installSignalHandlerForThread() {
 #if !(defined(DISABLE_FATAL_SIGNALHANDLING))
       if (!g_installed_thread_signal_handler) {
          g_installed_thread_signal_handler = true;
          if (SIG_ERR == signal(SIGTERM, signalHandler))
-            perror("signal - SIGTERM");
+            internal::writeErrorMessage("signal - SIGTERM");
          if (SIG_ERR == signal(SIGABRT, signalHandler))
-            perror("signal - SIGABRT");
+            internal::writeErrorMessage("signal - SIGABRT");
          if (SIG_ERR == signal(SIGFPE, signalHandler))
-            perror("signal - SIGFPE");
+            internal::writeErrorMessage("signal - SIGFPE");
          if (SIG_ERR == signal(SIGSEGV, signalHandler))
-            perror("signal - SIGSEGV");
+            internal::writeErrorMessage("signal - SIGSEGV");
          if (SIG_ERR == signal(SIGILL, signalHandler))
-            perror("signal - SIGILL");
+            internal::writeErrorMessag("signal - SIGILL");
       }
 #endif
    }

src/g3log/crashhandler.hpp

@@ -77,5 +77,6 @@ namespace g3 {
        * This is an internal only function. Do not use it elsewhere. It is triggered
        * from g3log, g3LogWorker after flushing messages to file */
       void exitWithDefaultSignalHandler(const LEVELS& level, g3::SignalType signal_number);
+      size_t writeErrorMessage(const char* message);
    }  // namespace internal
 }  // namespace g3

test_unit/Test.cmake

@@ -62,7 +62,7 @@
         SET(OS_SPECIFIC_TEST test_crashhandler_windows)
      ENDIF(MSVC OR MINGW)
 
-      SET(tests_to_run test_message test_filechange test_io test_fatal test_cpp_future_concepts test_concept_sink test_sink ${OS_SPECIFIC_TEST})
+      SET(tests_to_run test_message test_filechange test_io test_fatal test_signal test_cpp_future_concepts test_concept_sink test_sink ${OS_SPECIFIC_TEST})
       SET(helper ${DIR_UNIT_TEST}/testing_helpers.h ${DIR_UNIT_TEST}/testing_helpers.cpp)
       include_directories(${DIR_UNIT_TEST})