text: /*
     american fuzzy lop++ - GCC plugin instrumentation bootstrap
     ---------------------------------------------------------
  
     Written by Austin Seipp <aseipp@pobox.com> and
                Laszlo Szekeres <lszekeres@google.com> and
                Michal Zalewski
  
     GCC integration design is based on the LLVM design, which comes
     from Laszlo Szekeres.
  
     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:
  
       http://www.apache.org/licenses/LICENSE-2.0
  
     This code is the rewrite of afl-as.h's main_payload.
  
  */
  
  #ifdef __ANDROID__
  #include "android-ashmem.h"
  #endif
  #include "../config.h"
  #include "../types.h"
  
  #include <stdlib.h>
  #include <signal.h>
  #include <unistd.h>
  #include <string.h>
  #include <assert.h>
  
  #include <sys/mman.h>
  #include <sys/shm.h>
  #include <sys/wait.h>
  #include <sys/types.h>
  
  #include <sys/mman.h>
  #include <fcntl.h>
  
  /* Globals needed by the injected instrumentation. The __afl_area_initial region
     is used for instrumentation output before __afl_map_shm() has a chance to
     run. It will end up as .comm, so it shouldn't be too wasteful. */
  
  u8  __afl_area_initial[MAP_SIZE];
  u8 *__afl_area_ptr = __afl_area_initial;
  
  #ifdef __ANDROID__
  u32 __afl_prev_loc;
  #else
  __thread u32 __afl_prev_loc;
  #endif
  
  /* Trace a basic block with some ID */
  void __afl_trace(const u32 x) {
  
  #if 1                                      /* enable for neverZero feature. */
    __afl_area_ptr[__afl_prev_loc ^ x] +=
        1 + ((u8)(1 + __afl_area_ptr[__afl_prev_loc ^ x]) == 0);
  #else
    ++__afl_area_ptr[__afl_prev_loc ^ x];
  #endif
  
    __afl_prev_loc = (x >> 1);
    return;
  
  }
  
  /* Running in persistent mode? */
  
  static u8 is_persistent;
  
  /* SHM setup. */
  
  static void __afl_map_shm(void) {
  
    u8 *id_str = getenv(SHM_ENV_VAR);
  
    /* If we're running under AFL, attach to the appropriate region, replacing the
       early-stage __afl_area_initial region that is needed to allow some really
       hacky .init code to work correctly in projects such as OpenSSL. */
  
    if (id_str) {
  
  #ifdef USEMMAP
      const char *   shm_file_path = id_str;
      int            shm_fd = -1;
      unsigned char *shm_base = NULL;
  
      /* create the shared memory segment as if it was a file */
      shm_fd = shm_open(shm_file_path, O_RDWR, 0600);
      if (shm_fd == -1) {
  
        printf("shm_open() failed\n");
        exit(1);
  
      }
  
      /* map the shared memory segment to the address space of the process */
      shm_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
      if (shm_base == MAP_FAILED) {
  
        close(shm_fd);
        shm_fd = -1;
  
        printf("mmap() failed\n");
        exit(2);
  
      }
  
      __afl_area_ptr = shm_base;
  #else
      u32 shm_id = atoi(id_str);
  
      __afl_area_ptr = shmat(shm_id, NULL, 0);
  #endif
  
      /* Whooooops. */
  
      if (__afl_area_ptr == (void *)-1) exit(1);
  
      /* Write something into the bitmap so that even with low AFL_INST_RATIO,
         our parent doesn't give up on us. */
  
      __afl_area_ptr[0] = 1;
  
    }
  
  }
  
  /* Fork server logic. */
  
  static void __afl_start_forkserver(void) {
  
    static u8 tmp[4];
    s32       child_pid;
  
    u8 child_stopped = 0;
  
    void (*old_sigchld_handler)(int) = signal(SIGCHLD, SIG_DFL);
  
    /* Phone home and tell the parent that we're OK. If parent isn't there,
       assume we're not running in forkserver mode and just execute program. */
  
    if (write(FORKSRV_FD + 1, tmp, 4) != 4) return;
  
    while (1) {
  
      u32 was_killed;
      int status;
  
      /* Wait for parent by reading from the pipe. Abort if read fails. */
  
      if (read(FORKSRV_FD, &was_killed, 4) != 4) exit(1);
  
      /* If we stopped the child in persistent mode, but there was a race
         condition and afl-fuzz already issued SIGKILL, write off the old
         process. */
  
      if (child_stopped && was_killed) {
  
        child_stopped = 0;
        if (waitpid(child_pid, &status, 0) < 0) exit(1);
  
      }
  
      if (!child_stopped) {
  
        /* Once woken up, create a clone of our process. */
  
        child_pid = fork();
        if (child_pid < 0) exit(1);
  
        /* In child process: close fds, resume execution. */
  
        if (!child_pid) {
  
          signal(SIGCHLD, old_sigchld_handler);
  
          close(FORKSRV_FD);
          close(FORKSRV_FD + 1);
          return;
  
        }
  
      } else {
  
        /* Special handling for persistent mode: if the child is alive but
           currently stopped, simply restart it with SIGCONT. */
  
        kill(child_pid, SIGCONT);
        child_stopped = 0;
  
      }
  
      /* In parent process: write PID to pipe, then wait for child. */
  
      if (write(FORKSRV_FD + 1, &child_pid, 4) != 4) exit(1);
  
      if (waitpid(child_pid, &status, is_persistent ? WUNTRACED : 0) < 0) exit(1);
  
      /* In persistent mode, the child stops itself with SIGSTOP to indicate
         a successful run. In this case, we want to wake it up without forking
         again. */
  
      if (WIFSTOPPED(status)) child_stopped = 1;
  
      /* Relay wait status to pipe, then loop back. */
  
      if (write(FORKSRV_FD + 1, &status, 4) != 4) exit(1);
  
    }
  
  }
  
  /* A simplified persistent mode handler, used as explained in README.md. */
  
  int __afl_persistent_loop(unsigned int max_cnt) {
  
    static u8  first_pass = 1;
    static u32 cycle_cnt;
  
    if (first_pass) {
  
      /* Make sure that every iteration of __AFL_LOOP() starts with a clean slate.
         On subsequent calls, the parent will take care of that, but on the first
         iteration, it's our job to erase any trace of whatever happened
         before the loop. */
  
      if (is_persistent) {
  
        memset(__afl_area_ptr, 0, MAP_SIZE);
        __afl_area_ptr[0] = 1;
        __afl_prev_loc = 0;
  
      }
  
      cycle_cnt = max_cnt;
      first_pass = 0;
      return 1;
  
    }
  
    if (is_persistent) {
  
      if (--cycle_cnt) {
  
        raise(SIGSTOP);
  
        __afl_area_ptr[0] = 1;
        __afl_prev_loc = 0;
  
        return 1;
  
      } else {
  
        /* When exiting __AFL_LOOP(), make sure that the subsequent code that
           follows the loop is not traced. We do that by pivoting back to the
           dummy output region. */
  
        __afl_area_ptr = __afl_area_initial;
  
      }
  
    }
  
    return 0;
  
  }
  
  /* This one can be called from user code when deferred forkserver mode
      is enabled. */
  
  void __afl_manual_init(void) {
  
    static u8 init_done;
  
    if (!init_done) {
  
      __afl_map_shm();
      __afl_start_forkserver();
      init_done = 1;
  
    }
  
  }
  
  /* Proper initialization routine. */
  
  __attribute__((constructor(101))) void __afl_auto_init(void) {
  
    is_persistent = !!getenv(PERSIST_ENV_VAR);
  
    if (getenv(DEFER_ENV_VAR)) return;
  
    __afl_manual_init();
  
  }
  
  