Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2025-present The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <util/exec.h>
       6                 :             : 
       7                 :             : #include <util/fs.h>
       8                 :             : #ifdef WIN32
       9                 :             : #include <util/subprocess.h>
      10                 :             : #endif
      11                 :             : 
      12                 :             : #include <cstdlib>
      13                 :             : #include <string>
      14                 :             : #include <system_error>
      15                 :             : 
      16                 :             : #ifdef WIN32
      17                 :             : #include <process.h>
      18                 :             : #include <windows.h>
      19                 :             : #else
      20                 :             : #include <unistd.h>
      21                 :             : #endif
      22                 :             : 
      23                 :             : namespace util {
      24                 :           0 : int ExecVp(const char* file, char* const argv[])
      25                 :             : {
      26                 :             : #ifndef WIN32
      27                 :           0 :     return execvp(file, argv);
      28                 :             : #else
      29                 :             :     std::vector<std::string> escaped_args;
      30                 :             :     for (char* const* arg_ptr{argv}; *arg_ptr; ++arg_ptr) {
      31                 :             :         subprocess::util::quote_argument(std::string{*arg_ptr}, escaped_args.emplace_back(), /*force=*/false);
      32                 :             :     }
      33                 :             : 
      34                 :             :     std::vector<const char*> new_argv;
      35                 :             :     new_argv.reserve(escaped_args.size() + 1);
      36                 :             :     for (const auto& s : escaped_args) new_argv.push_back(s.c_str());
      37                 :             :     new_argv.push_back(nullptr);
      38                 :             :     return _execvp(file, new_argv.data());
      39                 :             : #endif
      40                 :             : }
      41                 :             : 
      42                 :           0 : fs::path GetExePath(std::string_view argv0)
      43                 :             : {
      44                 :             :     // Try to figure out where executable is located. This does a simplified
      45                 :             :     // search that won't work perfectly on every platform and doesn't need to,
      46                 :             :     // as it is only currently being used in a convenience wrapper binary to try
      47                 :             :     // to prioritize locally built or installed executables over system
      48                 :             :     // executables.
      49         [ #  # ]:           0 :     const fs::path argv0_path{fs::PathFromString(std::string{argv0})};
      50         [ #  # ]:           0 :     fs::path path{argv0_path};
      51                 :           0 :     std::error_code ec;
      52                 :             : #ifndef WIN32
      53                 :             :     // If argv0 doesn't contain a path separator, it was invoked from the system
      54                 :             :     // PATH and can be searched for there.
      55         [ #  # ]:           0 :     if (!argv0_path.has_parent_path()) {
      56         [ #  # ]:           0 :         if (const char* path_env = std::getenv("PATH")) {
      57                 :           0 :             size_t start{0}, end{0};
      58         [ #  # ]:           0 :             for (std::string_view paths{path_env}; end != std::string_view::npos; start = end + 1) {
      59                 :           0 :                 end = paths.find(':', start);
      60   [ #  #  #  # ]:           0 :                 fs::path candidate = fs::path(paths.substr(start, end - start)) / argv0_path;
      61         [ #  # ]:           0 :                 if (fs::is_regular_file(candidate, ec)) {
      62         [ #  # ]:           0 :                     path = candidate;
      63                 :           0 :                     break;
      64                 :             :                 }
      65                 :           0 :             }
      66                 :             :         }
      67                 :             :     }
      68                 :             : #else
      69                 :             :     wchar_t module_path[MAX_PATH];
      70                 :             :     if (GetModuleFileNameW(nullptr, module_path, MAX_PATH) > 0) {
      71                 :             :         path = fs::path{module_path};
      72                 :             :     }
      73                 :             : #endif
      74                 :           0 :     return path;
      75                 :           0 : }
      76                 :             : 
      77                 :             : } // namespace util