// Copyright 2016 The Crashpad Authors. All rights reserved.
//
// 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 <stdlib.h>
#include <windows.h>
#include <tlhelp32.h>

#include "base/files/file_path.h"
#include "base/logging.h"
#include "client/crashpad_client.h"
#include "test/paths.h"
#include "test/win/child_launcher.h"
#include "util/file/file_io.h"
#include "util/win/scoped_handle.h"
#include "util/win/xp_compat.h"

namespace crashpad {
namespace test {
namespace {

bool CrashAndDumpTarget(const CrashpadClient& client, HANDLE process) {
  DWORD target_pid = GetProcessId(process);

  HANDLE thread_snap_raw = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
  if (thread_snap_raw == INVALID_HANDLE_VALUE) {
    LOG(ERROR) << "CreateToolhelp32Snapshot";
    return false;
  }
  ScopedFileHANDLE thread_snap(thread_snap_raw);

  THREADENTRY32 te32;
  te32.dwSize = sizeof(THREADENTRY32);
  if (!Thread32First(thread_snap.get(), &te32)) {
    LOG(ERROR) << "Thread32First";
    return false;
  }

  do {
    if (te32.th32OwnerProcessID == target_pid) {
      // We set the thread priority of "Thread1" to a non-default value before
      // going to sleep. Dump and blame this thread. For an explanation of
      // "9", see
      // https://msdn.microsoft.com/en-us/library/windows/desktop/ms685100.aspx.
      if (te32.tpBasePri == 9) {
        ScopedKernelHANDLE thread(
            OpenThread(kXPThreadAllAccess, false, te32.th32ThreadID));
        if (!client.DumpAndCrashTargetProcess(
                process, thread.get(), 0xdeadbea7)) {
          LOG(ERROR) << "DumpAndCrashTargetProcess failed";
          return false;
        }
        return true;
      }
    }
  } while (Thread32Next(thread_snap.get(), &te32));

  return false;
}

int CrashOtherProgram(int argc, wchar_t* argv[]) {
  CrashpadClient client;

  if (argc == 2 || argc == 3) {
    if (!client.SetHandlerIPCPipe(argv[1])) {
      LOG(ERROR) << "SetHandler";
      return EXIT_FAILURE;
    }
  } else {
    fprintf(stderr, "Usage: %ls <server_pipe_name> [noexception]\n", argv[0]);
    return EXIT_FAILURE;
  }

  // Launch another process that hangs.
  base::FilePath test_executable = Paths::Executable();
  std::wstring child_test_executable =
      test_executable.DirName().Append(L"hanging_program.exe").value();
  ChildLauncher child(child_test_executable, argv[1]);
  child.Start();

  // Wait until it's ready.
  char c;
  if (!LoggingReadFile(child.stdout_read_handle(), &c, sizeof(c)) || c != ' ') {
    LOG(ERROR) << "failed child communication";
    return EXIT_FAILURE;
  }

  if (argc == 3 && wcscmp(argv[2], L"noexception") == 0) {
    client.DumpAndCrashTargetProcess(child.process_handle(), 0, 0);
    return EXIT_SUCCESS;
  } else {
    if (CrashAndDumpTarget(client, child.process_handle()))
      return EXIT_SUCCESS;
  }

  return EXIT_FAILURE;
}

}  // namespace
}  // namespace test
}  // namespace crashpad

int wmain(int argc, wchar_t* argv[]) {
  return crashpad::test::CrashOtherProgram(argc, argv);
}
