/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * 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
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <sys/types.h>
#include <signal.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
#include <errno.h>
#include <unistd.h>
#include <inttypes.h>

#include <backtrace/backtrace.h>

#define FINISH(pid) dump_frames(&backtrace); if (pid < 0) exit(1); else return false;

#define WAIT_INTERVAL_USECS   1000

// Prototypes for functions in the test library.
int test_level_one(int, int, int, int, bool (*)(pid_t));

int test_recursive_call(int, bool (*)(pid_t));

void dump_frames(const backtrace_t* backtrace) {
  for (size_t i = 0; i < backtrace->num_frames; i++) {
    printf("%zu ", i);
    if (backtrace->frames[i].map_name) {
      printf("%s", backtrace->frames[i].map_name);
    } else {
      printf("<unknown>");
    }
    if (backtrace->frames[i].proc_name) {
      printf(" %s", backtrace->frames[i].proc_name);
      if (backtrace->frames[i].proc_offset) {
        printf("+%" PRIuPTR, backtrace->frames[i].proc_offset);
      }
    }
    printf("\n");
  }
}

void wait_for_stop(pid_t pid, size_t max_usecs_to_wait) {
  siginfo_t si;
  size_t usecs_waited = 0;

  while (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) < 0 && (errno == EINTR || errno == ESRCH)) {
    if (usecs_waited >= max_usecs_to_wait) {
      printf("The process did not get to a stopping point in %zu usecs.\n",
             usecs_waited);
      break;
    }
    usleep(WAIT_INTERVAL_USECS);
    usecs_waited += WAIT_INTERVAL_USECS;
  }
}

bool check_frame(const backtrace_t* backtrace, size_t frame_num,
                 const char* expected_name) {
  if (backtrace->frames[frame_num].proc_name == NULL) {
    printf("  Frame %zu function name expected %s, real value is NULL.\n",
           frame_num, expected_name);
    return false;
  }
  if (strcmp(backtrace->frames[frame_num].proc_name, expected_name) != 0) {
    printf("  Frame %zu function name expected %s, real value is %s.\n",
           frame_num, expected_name, backtrace->frames[frame_num].proc_name);
    return false;
  }
  return true;
}

bool verify_level_backtrace(pid_t pid) {
  const char* test_type;
  if (pid < 0) {
    test_type = "current";
  } else {
    test_type = "running";
  }

  backtrace_t backtrace;
  if (!backtrace_get_data(&backtrace, pid)) {
    printf("  backtrace_get_data failed on %s process.\n", test_type);
    FINISH(pid);
  }

  if (backtrace.num_frames == 0) {
    printf("  backtrace_get_data returned no frames for %s process.\n",
           test_type);
    FINISH(pid);
  }

  // Look through the frames starting at the highest to find the
  // frame we want.
  size_t frame_num = 0;
  for (size_t i = backtrace.num_frames-1; i > 2; i--) {
    if (backtrace.frames[i].proc_name != NULL &&
        strcmp(backtrace.frames[i].proc_name, "test_level_one") == 0) {
      frame_num = i;
      break;
    }
  }
  if (!frame_num) {
    printf("  backtrace_get_data did not include the test_level_one frame.\n");
    FINISH(pid);
  }

  if (!check_frame(&backtrace, frame_num, "test_level_one")) {
    FINISH(pid);
  }
  if (!check_frame(&backtrace, frame_num-1, "test_level_two")) {
    FINISH(pid);
  }
  if (!check_frame(&backtrace, frame_num-2, "test_level_three")) {
    FINISH(pid);
  }
  if (!check_frame(&backtrace, frame_num-3, "test_level_four")) {
    FINISH(pid);
  }
  backtrace_free_data(&backtrace);

  return true;
}

bool verify_max_backtrace(pid_t pid) {
  const char* test_type;
  if (pid < 0) {
    test_type = "current";
  } else {
    test_type = "running";
  }

  backtrace_t backtrace;
  if (!backtrace_get_data(&backtrace, pid)) {
    printf("  backtrace_get_data failed on %s process.\n", test_type);
    FINISH(pid);
  }

  if (backtrace.num_frames != MAX_BACKTRACE_FRAMES) {
    printf("  backtrace_get_data %s process max frame check failed:\n",
           test_type);
    printf("    Expected num frames to be %zu, found %zu\n",
           MAX_BACKTRACE_FRAMES, backtrace.num_frames);
    FINISH(pid);
  }
  backtrace_free_data(&backtrace);

  return true;
}

void verify_proc_test(pid_t pid, bool (*verify_func)(pid_t)) {
  printf("  Waiting 5 seconds for process to get to infinite loop.\n");
  sleep(5);
  if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) {
    printf("Failed to attach to pid %d\n", pid);
    kill(pid, SIGKILL);
    exit(1);
  }

  // Wait up to 1 second for the process to get to a point that we can trace it.
  wait_for_stop(pid, 1000000);

  bool pass = verify_func(pid);
  if (ptrace(PTRACE_DETACH, pid, 0, 0) != 0) {
    printf("Failed to detach from pid %d\n", pid);
    kill(pid, SIGKILL);
    exit(1);
  }

  kill(pid, SIGKILL);
  int status;
  if (waitpid(pid, &status, 0) != pid) {
    printf("Forked process did not terminate properly.\n");
    exit(1);
  }

  if (!pass) {
    exit(1);
  }
}

int main() {
  printf("Running level test on current process...\n");
  int value = test_level_one(1, 2, 3, 4, verify_level_backtrace);
  if (value == 0) {
    printf("This should never happen.\n");
    exit(1);
  }
  printf("  Passed.\n");

  printf("Running max level test on current process...\n");
  value = test_recursive_call(MAX_BACKTRACE_FRAMES+10, verify_max_backtrace);
  if (value == 0) {
    printf("This should never happen.\n");
    exit(1);
  }
  printf("  Passed.\n");

  printf("Running level test on process...\n");
  pid_t pid;
  if ((pid = fork()) == 0) {
    value = test_level_one(1, 2, 3, 4, NULL);
    if (value == 0) {
      printf("This should never happen.\n");
    }
    exit(1);
  }
  verify_proc_test(pid, verify_level_backtrace);
  printf("  Passed.\n");

  printf("Running max frame test on process...\n");
  if ((pid = fork()) == 0) {
    value = test_recursive_call(MAX_BACKTRACE_FRAMES+10, NULL);
    if (value == 0) {
      printf("This should never happen.\n");
    }
    exit(1);
  }
  verify_proc_test(pid, verify_max_backtrace);
  printf("  Passed.\n");

  printf("All tests passed.\n");
  return 0;
}