[libFuzzer] Diff 30 - [AflDriver] Separate implementations of signal handler for diff platforms.

[mpividori]

Summary

For the same reasons mentioned in previous diff, I include the following modifications using macros inside afl_driver, to support different platforms.
Thanks.

lib/Fuzzer/afl/afl_driver.cpp

 // Variables we need for writing to the extra stats file.
 static FILE *extra_stats_file = NULL;
 static uint32_t previous_peak_rss = 0;
 auto slowest_unit_time_secs = std::chrono::seconds::zero();
 static const int kNumExtraStats = 2;
 static const char *kExtraStatsFormatString = "peak_rss_mb            : %u\n"
                                              "slowest_unit_time_sec  : %u\n";
 
+void crash_handler();
+
 // Copied from FuzzerUtil.cpp.
 #if LIBFUZZER_POSIX
+
 size_t GetPeakRSSMb() {
   struct rusage usage;
   if (getrusage(RUSAGE_SELF, &usage))
     return 0;
   if (LIBFUZZER_LINUX) {
     // ru_maxrss is in KiB
     return usage.ru_maxrss >> 10;
   } else if (LIBFUZZER_APPLE) {
     // ru_maxrss is in bytes
     return usage.ru_maxrss >> 20;
   }
   assert(0 && "GetPeakRSSMb() is not implemented for your platform");
   return 0;
 }
-#elif LIBFUZZER_WINDOWS
-size_t GetPeakRSSMb() {
-  PROCESS_MEMORY_COUNTERS info;
-  if (!GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info)))
-    return 0;
-  return info.PeakWorkingSetSize >> 20;
-}
-#endif
 
 // Based on SetSigaction in FuzzerUtil.cpp
 static void SetSigaction(int signum,
                          void (*callback)(int, siginfo_t *, void *)) {
   struct sigaction sigact;
   memset(&sigact, 0, sizeof(sigact));
   sigact.sa_sigaction = callback;
   if (sigaction(signum, &sigact, 0)) {
     fprintf(stderr, "libFuzzer: sigaction failed with %d\n", errno);
     exit(1);
   }
 }
 
+static void SignalHandler(int, siginfo_t *, void *) { crash_handler(); }
+
+void SetCrashHandler() {
+  int crash_signals[] = {SIGSEGV, SIGBUS, SIGABRT, SIGILL, SIGFPE,  SIGINT,
+                         SIGTERM};
+
+  const size_t num_signals = sizeof(crash_signals) / sizeof(crash_signals[0]);
+
+  for (size_t idx = 0; idx < num_signals; idx++)
+    SetSigaction(crash_signals[idx], SignalHandler);
+}
+
+#elif LIBFUZZER_WINDOWS
+
+size_t GetPeakRSSMb() {
+  PROCESS_MEMORY_COUNTERS info;
+  if (!GetProcessMemoryInfo(GetCurrentProcess(), &info, sizeof(info)))
+    return 0;
+  return info.PeakWorkingSetSize >> 20;
+}
+
+static void AbrtHandler(int) { crash_handler(); }
+
+BOOL WINAPI CtrlHandler(DWORD dwCtrlType) {
+  switch (dwCtrlType) {
+    case CTRL_C_EVENT:
+    case CTRL_BREAK_EVENT:
+      crash_handler();
+      return TRUE;
+  }
+  return FALSE;
+}
+
+LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo) {
+  switch (ExceptionInfo->ExceptionRecord->ExceptionCode) {
+    case EXCEPTION_ACCESS_VIOLATION:
+    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+    case EXCEPTION_STACK_OVERFLOW:
+    case EXCEPTION_DATATYPE_MISALIGNMENT:
+    case EXCEPTION_IN_PAGE_ERROR:
+    case EXCEPTION_ILLEGAL_INSTRUCTION:
+    case EXCEPTION_PRIV_INSTRUCTION:
+    case EXCEPTION_FLT_DENORMAL_OPERAND:
+    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+    case EXCEPTION_FLT_INEXACT_RESULT:
+    case EXCEPTION_FLT_INVALID_OPERATION:
+    case EXCEPTION_FLT_OVERFLOW:
+    case EXCEPTION_FLT_STACK_CHECK:
+    case EXCEPTION_FLT_UNDERFLOW:
+    case EXCEPTION_INT_DIVIDE_BY_ZERO:
+    case EXCEPTION_INT_OVERFLOW:
+      crash_handler();
+      break;
+  }
+  return EXCEPTION_CONTINUE_SEARCH;
+}
+
+void SetCrashHandler() {
+  if (!SetConsoleCtrlHandler(CtrlHandler, TRUE)) {
+    DWORD LastError = GetLastError();
+    fprintf(stderr, "libFuzzer: SetConsoleCtrlHandler failed (Error code: %lu)."
+      "\n", LastError);
+    exit(1);
+  }
+
+  if (!AddVectoredExceptionHandler(1, ExceptionHandler)) {
+    fprintf(stderr, "libFuzzer: AddVectoredExceptionHandler failed.\n");
+    exit(1);
+  }
+
+  if (SIG_ERR == signal(SIGABRT, AbrtHandler)) {
+    fprintf(stderr, "libFuzzer: signal failed with %d\n", errno);
+    exit(1);
+  }
+}
+
+#endif
+
 // Write extra stats to the file specified by the user. If none is specified
 // this function will never be called.
 static void write_extra_stats() {
   uint32_t peak_rss = GetPeakRSSMb();
 
   if (peak_rss < previous_peak_rss)
     peak_rss = previous_peak_rss;
 
   int chars_printed = fprintf(extra_stats_file, kExtraStatsFormatString,
                               peak_rss, slowest_unit_time_secs);
 
   CHECK_ERROR(chars_printed != 0, "Failed to write extra_stats_file");
 
   CHECK_ERROR(fclose(extra_stats_file) == 0,
               "Failed to close extra_stats_file");
 }
 
 // Call write_extra_stats before we exit.
-static void crash_handler(int, siginfo_t *, void *) {
+static void crash_handler() {
   // Make sure we don't try calling write_extra_stats again if we crashed while
   // trying to call it.
   static bool first_crash = true;
   CHECK_ERROR(first_crash,
               "Crashed in crash signal handler. This is a bug in the fuzzer.");
 
   first_crash = false;
   write_extra_stats();
CHECK_ERROR(extra_stats_file,
                 "Failed to open extra stats file for writing");
   } else {
     // Looks like this is the first time in a fuzzing job this is being called.
     extra_stats_file = fopen(extra_stats_filename, "w+");
     CHECK_ERROR(extra_stats_file, "failed to create extra stats file");
   }
 
   // Make sure that crash_handler gets called on any kind of fatal error.
-  int crash_signals[] = {SIGSEGV, SIGBUS, SIGABRT, SIGILL, SIGFPE,  SIGINT,
-                         SIGTERM};
-
-  const size_t num_signals = sizeof(crash_signals) / sizeof(crash_signals[0]);
-
-  for (size_t idx = 0; idx < num_signals; idx++)
-    SetSigaction(crash_signals[idx], crash_handler);
+  SetCrashHandler();
 
   // Make sure it gets called on other kinds of exits.
   atexit(write_extra_stats);
 }
 
 // If the user asks us to duplicate stderr, then do it.
 static void maybe_duplicate_stderr() {
   char* stderr_duplicate_filename =