[libFuzzer] Diff 40 - [FuzzerSupport] Update Afl Driver to use FuzzerSupport lib.

lib/Fuzzer/afl/afl_driver.cpp

 AFL_DRIVER_EXTRA_STATS_FILENAME: Setting this causes afl_driver to write extra
 statistics to the file specified. Currently these are peak_rss_mb
 (the peak amount of virtual memory used in MB) and slowest_unit_time_secs. If
 the file does not exist it is created. If the file does exist then
 afl_driver assumes it was restarted by afl-fuzz and will try to read old
 statistics from the file. If that fails then the process will quit.
 
 */
-// Platform detection. Copied from FuzzerInternal.h
-#ifdef __linux__
-#define LIBFUZZER_APPLE 0
-#define LIBFUZZER_LINUX 1
-#define LIBFUZZER_WINDOWS 0
-#elif __APPLE__
-#define LIBFUZZER_APPLE 1
-#define LIBFUZZER_LINUX 0
-#define LIBFUZZER_WINDOWS 0
-#elif _WIN32
-#define LIBFUZZER_APPLE 0
-#define LIBFUZZER_LINUX 0
-#define LIBFUZZER_WINDOWS 1
-#else
-#error "Support for your platform has not been implemented"
-#endif
-
-#define LIBFUZZER_POSIX LIBFUZZER_APPLE || LIBFUZZER_LINUX
-
+#include "../Support/Util.h"
 #include <assert.h>
 #include <chrono>
 #include <iostream>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <signal.h>
-#if LIBFUZZER_POSIX
-#include <unistd.h>
-#include <sys/resource.h>
-#elif LIBFUZZER_WINDOWS
-#include <windows.h>
-#include <Psapi.h>
-#endif
 
 // Used to avoid repeating error checking boilerplate. If cond is false, a
 // fatal error has occured in the program. In this event print error_message
 // to stderr and abort(). Otherwise do nothing. Note that setting
 // AFL_DRIVER_STDERR_DUPLICATE_FILENAME may cause error_message to be appended
 // to the file as well, if the error occurs after the duplication is performed.
 #define CHECK_ERROR(cond, error_message)                                       \
   if (!(cond)) {                                                               \

 // 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;
-}
-
-// 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();
+  size_t peak_rss = fuzzer::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(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.
-  SetCrashHandler();
+  fuzzer::HandlerOptions HandlerOpt;
+  HandlerOpt.HandlerAbrt = crash_handler;
+  HandlerOpt.HandlerBus = crash_handler;
+  HandlerOpt.HandlerFpe = crash_handler;
+  HandlerOpt.HandlerIll = crash_handler;
+  HandlerOpt.HandlerInt = crash_handler;
+  HandlerOpt.HandlerSegv = crash_handler;
+  HandlerOpt.HandlerTerm = crash_handler;
+  fuzzer::SetSignalHandler(HandlerOpt);
 
   // 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 =