// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/process/launch.h"

#include <fcntl.h>
#include <io.h>

// windows.h must be included before shellapi.h
#include <windows.h>

#include <psapi.h>
#include <shellapi.h>
#include <userenv.h>

#include <algorithm>
#include <ios>
#include <limits>
#include <string>
#include <string_view>

#include "base/containers/heap_array.h"
#include "base/containers/span.h"
#include "base/debug/alias.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/functional/function_ref.h"
#include "base/logging.h"
#include "base/metrics/histogram.h"
#include "base/process/environment_internal.h"
#include "base/process/kill.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/system/sys_info.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/threading/scoped_thread_priority.h"
#include "base/time/time.h"
#include "base/timer/elapsed_timer.h"
#include "base/trace_event/trace_event.h"
#include "base/win/scoped_handle.h"
#include "base/win/scoped_process_information.h"
#include "base/win/startup_information.h"
#include "base/win/windows_version.h"

namespace base {

namespace {

bool GetAppOutputInternal(
    CommandLine::StringViewType cl,
    bool include_stderr,
    std::string* output,
    int* exit_code,
    TimeDelta timeout = TimeDelta::Max(),
    LaunchOptions options = {},
    FunctionRef<void(const Process&, std::string_view)> still_waiting =
        [](const Process& process, std::string_view partial_output) {},
    TerminationStatus* final_status = nullptr) {
  TRACE_EVENT0("base", "GetAppOutput");

  if (final_status) {
    *final_status = TERMINATION_STATUS_LAUNCH_FAILED;
  }
  HANDLE out_read = nullptr;
  HANDLE out_write = nullptr;

  // Create the pipe for the child process's STDOUT.
  if (!CreatePipe(&out_read, &out_write, nullptr, 0)) {
    DPLOG(ERROR) << "Failed to create pipe";
    return false;
  }

  // Ensure we don't leak the handles.
  win::ScopedHandle scoped_out_read(out_read);
  win::ScopedHandle scoped_out_write(out_write);

  // The std output (and std error if `include_stderr` is `true`) handles should
  // not be specified, since this function overrides them.
  CHECK(!options.stdout_handle);
  options.stdout_handle = out_write;
  if (include_stderr) {
    CHECK(!options.stderr_handle);
    options.stderr_handle = out_write;
  }
  options.handles_to_inherit.push_back(out_write);

  // Create the child process.
  base::Process process =
      base::LaunchProcess(CommandLine::StringType(cl), options);
  if (!process.IsValid()) {
    return false;
  }
  still_waiting(process, {});

  // Close our writing end of pipe now. Otherwise later read would not be able
  // to detect end of child's output.
  scoped_out_write.Close();

  const ElapsedTimer timer;

  bool process_exited = false;
  do {
    {
      // It is okay to allow this process to wait on the launched process as a
      // process launched with GetAppOutput*() shouldn't wait back on the
      // process that launched it.
      internal::GetAppOutputScopedAllowBaseSyncPrimitives allow_wait;
      ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                              BlockingType::MAY_BLOCK);
      process_exited = process.WaitForExitWithTimeout(Seconds(1), exit_code);
    }

    // Read output from the child process's pipe for STDOUT
    const DWORD kBufferSize = 1024 * 4;
    char buffer[kBufferSize];
    for (DWORD bytes_available = 0; PeekNamedPipe(out_read, nullptr, 0, nullptr,
                                                  &bytes_available, nullptr) &&
                                    bytes_available;) {
      for (DWORD bytes_read = 0; bytes_available;
           bytes_available -= bytes_read) {
        const DWORD bytes_to_read = std::min(kBufferSize, bytes_available);
        if (const BOOL success =
                ReadFile(out_read, buffer, bytes_to_read, &bytes_read, nullptr);
            !success || !bytes_read) {
          break;
        }
        CHECK_LE(bytes_read, bytes_to_read);
        std::string_view buffer_view(buffer, bytes_read);
        still_waiting(process, buffer_view);
        if (output) {
          output->append(buffer_view);
        }
      }

      if (!process_exited) {
        // Loop back to the wait.
        break;
      }

      // The process ended, so continue reading as long as there is data
      // available.
    }
  } while (!process_exited && (timer.Elapsed() < timeout));

  if (final_status) {
    *final_status = process_exited ? TERMINATION_STATUS_NORMAL_TERMINATION
                                   : TERMINATION_STATUS_STILL_RUNNING;
  }
  return process_exited;
}

Process LaunchElevatedProcess(const CommandLine& cmdline,
                              bool start_hidden,
                              bool wait) {
  TRACE_EVENT0("base", "LaunchElevatedProcess");
  const FilePath::StringType file = cmdline.GetProgram().value();
  const CommandLine::StringType arguments = cmdline.GetArgumentsString();

  SHELLEXECUTEINFO shex_info = {};
  shex_info.cbSize = sizeof(shex_info);
  shex_info.fMask = SEE_MASK_NOCLOSEPROCESS;
  shex_info.hwnd = GetActiveWindow();
  shex_info.lpVerb = L"runas";
  shex_info.lpFile = file.c_str();
  shex_info.lpParameters = arguments.c_str();
  shex_info.lpDirectory = nullptr;
  shex_info.nShow = start_hidden ? SW_HIDE : SW_SHOWNORMAL;
  shex_info.hInstApp = nullptr;

  if (!ShellExecuteEx(&shex_info)) {
    DPLOG(ERROR);
    return Process();
  }

  if (wait) {
    ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK);
    WaitForSingleObject(shex_info.hProcess, INFINITE);
  }

  return Process(shex_info.hProcess);
}

}  // namespace

void RouteStdioToConsole(bool create_console_if_not_found) {
  // Don't change anything if stdout or stderr already point to a
  // valid stream.
  //
  // If we are running under Buildbot or under Cygwin's default
  // terminal (mintty), stderr and stderr will be pipe handles.  In
  // that case, we don't want to open CONOUT$, because its output
  // likely does not go anywhere.
  //
  // We don't use GetStdHandle() to check stdout/stderr here because
  // it can return dangling IDs of handles that were never inherited
  // by this process.  These IDs could have been reused by the time
  // this function is called.  The CRT checks the validity of
  // stdout/stderr on startup (before the handle IDs can be reused).
  // _fileno(stdout) will return -2 (_NO_CONSOLE_FILENO) if stdout was
  // invalid.
  if (_fileno(stdout) >= 0 || _fileno(stderr) >= 0) {
    // _fileno was broken for SUBSYSTEM:WINDOWS from VS2010 to VS2012/2013.
    // http://crbug.com/358267. Confirm that the underlying HANDLE is valid
    // before aborting.

    intptr_t stdout_handle = _get_osfhandle(_fileno(stdout));
    intptr_t stderr_handle = _get_osfhandle(_fileno(stderr));
    if (stdout_handle >= 0 || stderr_handle >= 0) {
      return;
    }
  }

  if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
    unsigned int result = GetLastError();
    // Was probably already attached.
    if (result == ERROR_ACCESS_DENIED) {
      return;
    }
    // Don't bother creating a new console for each child process if the
    // parent process is invalid (eg: crashed).
    if (result == ERROR_GEN_FAILURE) {
      return;
    }
    if (create_console_if_not_found) {
      // Make a new console if attaching to parent fails with any other error.
      // It should be ERROR_INVALID_HANDLE at this point, which means the
      // browser was likely not started from a console.
      AllocConsole();
    } else {
      return;
    }
  }

  // Arbitrary byte count to use when buffering output lines.  More
  // means potential waste, less means more risk of interleaved
  // log-lines in output.
  enum { kOutputBufferSize = 64 * 1024 };

  if (freopen("CONOUT$", "w", stdout)) {
    setvbuf(stdout, nullptr, _IOLBF, kOutputBufferSize);
    // Overwrite FD 1 for the benefit of any code that uses this FD
    // directly.  This is safe because the CRT allocates FDs 0, 1 and
    // 2 at startup even if they don't have valid underlying Windows
    // handles.  This means we won't be overwriting an FD created by
    // _open() after startup.
    _dup2(_fileno(stdout), 1);
  }
  if (freopen("CONOUT$", "w", stderr)) {
    setvbuf(stderr, nullptr, _IOLBF, kOutputBufferSize);
    _dup2(_fileno(stderr), 2);
  }

  // Fix all cout, wcout, cin, wcin, cerr, wcerr, clog and wclog.
  std::ios::sync_with_stdio();
}

Process LaunchProcess(const CommandLine& cmdline,
                      const LaunchOptions& options) {
  if (options.elevated) {
    return LaunchElevatedProcess(cmdline, options.start_hidden, options.wait);
  }
  return LaunchProcess(cmdline.GetCommandLineString(), options);
}

Process LaunchProcess(const CommandLine::StringType& cmdline,
                      const LaunchOptions& options) {
  // Retain the command line on the stack for investigating shutdown hangs
  // tracked in https://crbug.com/1431378
  DEBUG_ALIAS_FOR_WCHARCSTR(cmdline_for_debugging, cmdline.c_str(), 200);

  if (options.elevated) {
    return LaunchElevatedProcess(base::CommandLine::FromString(cmdline),
                                 options.start_hidden, options.wait);
  }
  TRACE_EVENT0("base", "LaunchProcess");
  // Mitigate the issues caused by loading DLLs on a background thread
  // (http://crbug/973868).
  SCOPED_MAY_LOAD_LIBRARY_AT_BACKGROUND_PRIORITY();

  // |process_mitigations| must outlive |startup_info_wrapper|.
  DWORD64 process_mitigations[2]{0, 0};
  win::StartupInformation startup_info_wrapper;
  STARTUPINFO* startup_info = startup_info_wrapper.startup_info();
  DWORD flags = 0;

  // Count extended attributes before reserving space.
  DWORD attribute_count = 0;
  // Count PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY.
  if (options.disable_cetcompat &&
      base::win::GetVersion() >= base::win::Version::WIN10_20H1) {
    ++attribute_count;
  }

  // Count PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
  if (!options.handles_to_inherit.empty()) {
    ++attribute_count;
  }

  // Reserve space for attributes.
  if (attribute_count > 0) {
    if (!startup_info_wrapper.InitializeProcThreadAttributeList(
            attribute_count)) {
      DPLOG(ERROR);
      return Process();
    }
    flags |= EXTENDED_STARTUPINFO_PRESENT;
  }

  // Set PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY.
  if (options.disable_cetcompat &&
      base::win::GetVersion() >= base::win::Version::WIN10_20H1) {
    DCHECK_GT(attribute_count, 0u);
    process_mitigations[1] |=
        PROCESS_CREATION_MITIGATION_POLICY2_CET_USER_SHADOW_STACKS_ALWAYS_OFF;
    if (!startup_info_wrapper.UpdateProcThreadAttribute(
            PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY, &process_mitigations[0],
            sizeof(process_mitigations))) {
      return Process();
    }
  }

  // Set PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
  bool inherit_handles = options.inherit_mode == LaunchOptions::Inherit::kAll;
  if (!options.handles_to_inherit.empty()) {
    DCHECK_GT(attribute_count, 0u);
    DCHECK_EQ(options.inherit_mode, LaunchOptions::Inherit::kSpecific);

    if (options.handles_to_inherit.size() >
        std::numeric_limits<DWORD>::max() / sizeof(HANDLE)) {
      DLOG(ERROR) << "Too many handles to inherit.";
      return Process();
    }

    // Ensure the handles can be inherited.
    for (HANDLE handle : options.handles_to_inherit) {
      BOOL result = SetHandleInformation(handle, HANDLE_FLAG_INHERIT,
                                         HANDLE_FLAG_INHERIT);
      PCHECK(result);
    }

    if (!startup_info_wrapper.UpdateProcThreadAttribute(
            PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
            const_cast<HANDLE*>(&options.handles_to_inherit[0]),
            static_cast<DWORD>(options.handles_to_inherit.size() *
                               sizeof(HANDLE)))) {
      DPLOG(ERROR);
      return Process();
    }

    inherit_handles = true;
  }

  if (options.feedback_cursor_off) {
    startup_info->dwFlags |= STARTF_FORCEOFFFEEDBACK;
  }
  if (options.empty_desktop_name) {
    startup_info->lpDesktop = const_cast<wchar_t*>(L"");
  }
  startup_info->dwFlags |= STARTF_USESHOWWINDOW;
  startup_info->wShowWindow = options.start_hidden ? SW_HIDE : SW_SHOWNORMAL;

  if (options.stdin_handle || options.stdout_handle || options.stderr_handle) {
    DCHECK(inherit_handles);
    // If an explicit handle inheritance list is not set, require that all
    // stdio handle values be explicitly specified.
    if (options.handles_to_inherit.empty()) {
      CHECK(options.stdin_handle);
      CHECK(options.stdout_handle);
      CHECK(options.stderr_handle);
    }
    startup_info->dwFlags |= STARTF_USESTDHANDLES;
    startup_info->hStdInput = options.stdin_handle;
    startup_info->hStdOutput = options.stdout_handle;
    startup_info->hStdError = options.stderr_handle;
  }

  if (options.force_breakaway_from_job_) {
    flags |= CREATE_BREAKAWAY_FROM_JOB;
  }

  PROCESS_INFORMATION temp_process_info = {};

  LPCTSTR current_directory = options.current_directory.empty()
                                  ? nullptr
                                  : options.current_directory.value().c_str();

  auto writable_cmdline(cmdline);
  DCHECK(!(flags & CREATE_SUSPENDED))
      << "Creating a suspended process can lead to hung processes if the "
      << "launching process is killed before it assigns the process to the"
      << "job. https://crbug.com/820996";
  if (options.as_user) {
    flags |= CREATE_UNICODE_ENVIRONMENT;
    void* environment_block = nullptr;

    if (!CreateEnvironmentBlock(&environment_block, options.as_user, FALSE)) {
      DPLOG(ERROR);
      return Process();
    }

    // Environment options are not implemented for use with |as_user|.
    DCHECK(!options.clear_environment);
    DCHECK(options.environment.empty());

    BOOL launched = CreateProcessAsUser(
        options.as_user, nullptr, data(writable_cmdline), nullptr, nullptr,
        inherit_handles, flags, environment_block, current_directory,
        startup_info, &temp_process_info);
    DestroyEnvironmentBlock(environment_block);
    if (!launched) {
      DPLOG(ERROR) << "Command line:" << std::endl
                   << WideToUTF8(cmdline) << std::endl;
      return Process();
    }
  } else {
    wchar_t* new_environment = nullptr;
    std::wstring env_storage;
    if (options.clear_environment || !options.environment.empty()) {
      if (options.clear_environment) {
        static const wchar_t kEmptyEnvironment[] = {0};
        env_storage =
            internal::AlterEnvironment(kEmptyEnvironment, options.environment);
      } else {
        wchar_t* old_environment = GetEnvironmentStrings();
        if (!old_environment) {
          DPLOG(ERROR);
          return Process();
        }
        env_storage =
            internal::AlterEnvironment(old_environment, options.environment);
        FreeEnvironmentStrings(old_environment);
      }
      new_environment = data(env_storage);
      flags |= CREATE_UNICODE_ENVIRONMENT;
    }

    if (!CreateProcess(nullptr, data(writable_cmdline), nullptr, nullptr,
                       inherit_handles, flags, new_environment,
                       current_directory, startup_info, &temp_process_info)) {
      DPLOG(ERROR) << "Command line:" << std::endl << cmdline << std::endl;
      return Process();
    }
  }
  win::ScopedProcessInformation process_info(temp_process_info);

  if (options.job_handle &&
      !AssignProcessToJobObject(options.job_handle,
                                process_info.process_handle())) {
    DPLOG(ERROR) << "Could not AssignProcessToObject";
    Process scoped_process(process_info.TakeProcessHandle());
    scoped_process.Terminate(win::kProcessKilledExitCode, true);
    return Process();
  }

  if (options.grant_foreground_privilege &&
      !AllowSetForegroundWindow(GetProcId(process_info.process_handle()))) {
    DPLOG(ERROR) << "Failed to grant foreground privilege to launched process";
  }

  if (options.wait) {
    ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK);
    WaitForSingleObject(process_info.process_handle(), INFINITE);
  }

  return Process(process_info.TakeProcessHandle());
}

bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags) {
  JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info = {};
  limit_info.BasicLimitInformation.LimitFlags = limit_flags;
  return 0 != SetInformationJobObject(job_object,
                                      JobObjectExtendedLimitInformation,
                                      &limit_info, sizeof(limit_info));
}

bool GetAppOutput(const CommandLine& cl, std::string* output) {
  return GetAppOutput(cl.GetCommandLineString(), output);
}

bool GetAppOutputAndError(const CommandLine& cl, std::string* output) {
  int exit_code;
  return GetAppOutputInternal(cl.GetCommandLineString(), true, output,
                              &exit_code) &&
         !exit_code;
}

bool GetAppOutputWithExitCode(const CommandLine& cl,
                              std::string* output,
                              int* exit_code) {
  return GetAppOutputInternal(cl.GetCommandLineString(), false, output,
                              exit_code);
}

bool GetAppOutputWithExitCodeAndTimeout(
    CommandLine::StringViewType cl,
    bool include_stderr,
    std::string* output,
    int* exit_code,
    TimeDelta timeout,
    const LaunchOptions& options,
    FunctionRef<void(const Process&, std::string_view)> still_waiting,
    TerminationStatus* final_status) {
  return GetAppOutputInternal(cl, include_stderr, output, exit_code, timeout,
                              options, still_waiting, final_status);
}

bool GetAppOutput(CommandLine::StringViewType cl, std::string* output) {
  int exit_code;
  return GetAppOutputInternal(cl, false, output, &exit_code) && !exit_code;
}

void RaiseProcessToHighPriority() {
  SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
}

}  // namespace base