Function resolve_command_string

src/platform/windows/misc.cpp:744–938

* @brief Resolve the given raw command into a proper command string for CreateProcess(). * @details This converts URLs and non-executable file paths into a runnable command like ShellExecute(). * @param raw_cmd The raw command provided by the user. * @param working_dir The working directory for the new process. * @param token The user token currently being impersonated or `nullptr` if

   * @return A command string suitable for use by CreateProcess().
   */
  std::wstring resolve_command_string(const std::string &raw_cmd, const std::wstring &working_dir, HANDLE token, DWORD &creation_flags) {
    std::wstring raw_cmd_w = from_utf8(raw_cmd);

    // First, convert the given command into parts so we can get the executable/file/URL without parameters
    auto raw_cmd_parts = boost::program_options::split_winmain(raw_cmd_w);
    if (raw_cmd_parts.empty()) {
      // This is highly unexpected, but we'll just return the raw string and hope for the best.
      BOOST_LOG(warning) << "Failed to split command string: "sv << raw_cmd;
      return from_utf8(raw_cmd);
    }

    auto raw_target = raw_cmd_parts.at(0);
    if (PathIsURLW(raw_target.c_str())) {
      // If the target is a URL, handle it directly with rundll32.exe
      std::wstring cmd = L"rundll32.exe url.dll,FileProtocolHandler " + raw_target;
      return cmd;
    }

    // If the target is not a URL, assume it's a regular file path
    auto extension = PathFindExtensionW(raw_target.c_str());
    if (extension == nullptr || *extension == 0) {
      // If the file has no extension, assume it's a command and allow CreateProcess()
      // to try to find it via PATH
      return from_utf8(raw_cmd);
    }
    else if (boost::iequals(extension, L".exe")) {
      // If the file has an .exe extension, we will bypass the resolution here and
      // directly pass the unmodified command string to CreateProcess(). The argument
      // escaping rules are subtly different between CreateProcess() and ShellExecute(),
      // and we want to preserve backwards compatibility with older configs.
      return from_utf8(raw_cmd);
    }

    // For regular files, the class is found using the file extension (including the dot)
    std::wstring lookup_string = extension;
    HRESULT res;

    std::array<WCHAR, MAX_PATH> shell_command_string;
    bool needs_cmd_escaping = false;
    {
      // Overriding these predefined keys affects process-wide state, so serialize all calls
      // to ensure the handle state is consistent while we perform the command query.
      static std::mutex per_user_key_mutex;
      auto lg = std::lock_guard(per_user_key_mutex);

      // Override HKEY_CLASSES_ROOT and HKEY_CURRENT_USER to ensure we query the correct class info
      if (!override_per_user_predefined_keys(token)) {
        return from_utf8(raw_cmd);
      }

      // Find the command string for the specified class
      DWORD out_len = shell_command_string.size();
      res = AssocQueryStringW(ASSOCF_NOTRUNCATE, ASSOCSTR_COMMAND, lookup_string.c_str(), L"open", shell_command_string.data(), &out_len);

      // In some cases (UWP apps), we might not have a command for this target. If that happens,
      // we'll have to launch via cmd.exe. This prevents proper job tracking, but that was already
      // broken for UWP apps anyway due to how they are started by Windows. Even 'start /wait'
      // doesn't work properly for UWP, so really no termination tracking seems to work at all.