The Tor Browser: ipc/chromium/src/base/process_util

ipc/chromium/src/base/process_util_mac.mm@6474c204b198 (annotated)

ipc/chromium/src/base/process_util_mac.mm

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "base/process_util.h"
 #import <Cocoa/Cocoa.h>
 #include <crt_externs.h>
 #include <spawn.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <string>
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 namespace base {
 void FreeEnvVarsArray(char* array[], int length)
 {
   for (int i = 0; i < length; i++) {
     free(array[i]);
   }
   delete[] array;
 }
 bool LaunchApp(const std::vector<std::string>& argv,
                const file_handle_mapping_vector& fds_to_remap,
                bool wait, ProcessHandle* process_handle) {
   return LaunchApp(argv, fds_to_remap, environment_map(),
                    wait, process_handle);
 }
 bool LaunchApp(const std::vector<std::string>& argv,
                const file_handle_mapping_vector& fds_to_remap,
                const environment_map& env_vars_to_set,
                bool wait, ProcessHandle* process_handle,
                ProcessArchitecture arch) {
   return LaunchApp(argv, fds_to_remap, env_vars_to_set,
                    PRIVILEGES_INHERIT,
                    wait, process_handle);
 }
 bool LaunchApp(const std::vector<std::string>& argv,
                const file_handle_mapping_vector& fds_to_remap,
                const environment_map& env_vars_to_set,
                ChildPrivileges privs,
                bool wait, ProcessHandle* process_handle,
                ProcessArchitecture arch) {
   bool retval = true;
   char* argv_copy[argv.size() + 1];
   for (size_t i = 0; i < argv.size(); i++) {
     argv_copy[i] = const_cast<char*>(argv[i].c_str());
   }
   argv_copy[argv.size()] = NULL;
   // Make sure we don't leak any FDs to the child process by marking all FDs
   // as close-on-exec.
   SetAllFDsToCloseOnExec();
   // Copy _NSGetEnviron() to a new char array and add the variables
   // in env_vars_to_set.
   // Existing variables are overwritten by env_vars_to_set.
   int pos = 0;
   environment_map combined_env_vars = env_vars_to_set;
   while((*_NSGetEnviron())[pos] != NULL) {
     std::string varString = (*_NSGetEnviron())[pos];
     std::string varName = varString.substr(0, varString.find_first_of('='));
     std::string varValue = varString.substr(varString.find_first_of('=') + 1);
     if (combined_env_vars.find(varName) == combined_env_vars.end()) {
       combined_env_vars[varName] = varValue;
     }
     pos++;
   }
   int varsLen = combined_env_vars.size() + 1;
   char** vars = new char*[varsLen];
   int i = 0;
   for (environment_map::const_iterator it = combined_env_vars.begin();
        it != combined_env_vars.end(); ++it) {
     std::string entry(it->first);
     entry += "=";
     entry += it->second;
     vars[i] = strdup(entry.c_str());
     i++;
   }
   vars[i] = NULL;
   posix_spawn_file_actions_t file_actions;
   if (posix_spawn_file_actions_init(&file_actions) != 0) {
     FreeEnvVarsArray(vars, varsLen);
     return false;
   }
   // Turn fds_to_remap array into a set of dup2 calls.
   for (file_handle_mapping_vector::const_iterator it = fds_to_remap.begin();
        it != fds_to_remap.end();
        ++it) {
     int src_fd = it->first;
     int dest_fd = it->second;
     if (src_fd == dest_fd) {
       int flags = fcntl(src_fd, F_GETFD);
       if (flags != -1) {
         fcntl(src_fd, F_SETFD, flags & ~FD_CLOEXEC);
       }
     } else {
       if (posix_spawn_file_actions_adddup2(&file_actions, src_fd, dest_fd) != 0) {
         posix_spawn_file_actions_destroy(&file_actions);
         FreeEnvVarsArray(vars, varsLen);
         return false;
       }
     }
   }
   // Set up the CPU preference array.
   cpu_type_t cpu_types[1];
   switch (arch) {
     case PROCESS_ARCH_I386:
       cpu_types[0] = CPU_TYPE_X86;
       break;
     case PROCESS_ARCH_X86_64:
       cpu_types[0] = CPU_TYPE_X86_64;
       break;
     case PROCESS_ARCH_PPC:
       cpu_types[0] = CPU_TYPE_POWERPC;
     default:
       cpu_types[0] = CPU_TYPE_ANY;
       break;
   }
   // Initialize spawn attributes.
   posix_spawnattr_t spawnattr;
   if (posix_spawnattr_init(&spawnattr) != 0) {
     FreeEnvVarsArray(vars, varsLen);
     return false;
   }
   // Set spawn attributes.
   size_t attr_count = 1;
   size_t attr_ocount = 0;
   if (posix_spawnattr_setbinpref_np(&spawnattr, attr_count, cpu_types, &attr_ocount) != 0 ||
       attr_ocount != attr_count) {
     FreeEnvVarsArray(vars, varsLen);
     posix_spawnattr_destroy(&spawnattr);
     return false;
   }
   int pid = 0;
   int spawn_succeeded = (posix_spawnp(&pid,
                                       argv_copy[0],
                                       &file_actions,
                                       &spawnattr,
                                       argv_copy,
                                       vars) == 0);
   FreeEnvVarsArray(vars, varsLen);
   posix_spawn_file_actions_destroy(&file_actions);
   posix_spawnattr_destroy(&spawnattr);
   bool process_handle_valid = pid > 0;
   if (!spawn_succeeded || !process_handle_valid) {
     retval = false;
   } else {
     if (wait)
       HANDLE_EINTR(waitpid(pid, 0, 0));
     if (process_handle)
       *process_handle = pid;
   }
   return retval;
 }
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
   // TODO(playmobil): Do we need to respect the start_hidden flag?
   file_handle_mapping_vector no_files;
   return LaunchApp(cl.argv(), no_files, wait, process_handle);
 }
 void SetCurrentProcessPrivileges(ChildPrivileges privs) {
 }
 NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
                                            const ProcessFilter* filter)
   : executable_name_(executable_name),
     index_of_kinfo_proc_(0),
     filter_(filter) {
   // Get a snapshot of all of my processes (yes, as we loop it can go stale, but
   // but trying to find where we were in a constantly changing list is basically
   // impossible.
   int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_UID, int(geteuid()) };
   // Since more processes could start between when we get the size and when
   // we get the list, we do a loop to keep trying until we get it.
   bool done = false;
   int try_num = 1;
   const int max_tries = 10;
   do {
     // Get the size of the buffer
     size_t len = 0;
     if (sysctl(mib, arraysize(mib), NULL, &len, NULL, 0) < 0) {
       CHROMIUM_LOG(ERROR) << "failed to get the size needed for the process list";
       kinfo_procs_.resize(0);
       done = true;
     } else {
       size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
       // Leave some spare room for process table growth (more could show up
       // between when we check and now)
       num_of_kinfo_proc += 4;
       kinfo_procs_.resize(num_of_kinfo_proc);
       len = num_of_kinfo_proc * sizeof(struct kinfo_proc);
       // Load the list of processes
       if (sysctl(mib, arraysize(mib), &kinfo_procs_[0], &len, NULL, 0) < 0) {
         // If we get a mem error, it just means we need a bigger buffer, so
         // loop around again.  Anything else is a real error and give up.
         if (errno != ENOMEM) {
           CHROMIUM_LOG(ERROR) << "failed to get the process list";
           kinfo_procs_.resize(0);
           done = true;
         }
       } else {
         // Got the list, just make sure we're sized exactly right
         size_t num_of_kinfo_proc = len / sizeof(struct kinfo_proc);
         kinfo_procs_.resize(num_of_kinfo_proc);
         done = true;
       }
     }
   } while (!done && (try_num++ < max_tries));
   if (!done) {
     CHROMIUM_LOG(ERROR) << "failed to collect the process list in a few tries";
     kinfo_procs_.resize(0);
   }
 }
 NamedProcessIterator::~NamedProcessIterator() {
 }
 const ProcessEntry* NamedProcessIterator::NextProcessEntry() {
   bool result = false;
   do {
     result = CheckForNextProcess();
   } while (result && !IncludeEntry());
   if (result) {
     return &entry_;
   }
   return NULL;
 }
 bool NamedProcessIterator::CheckForNextProcess() {
   std::string executable_name_utf8(WideToUTF8(executable_name_));
   std::string data;
   std::string exec_name;
   for (; index_of_kinfo_proc_ < kinfo_procs_.size(); ++index_of_kinfo_proc_) {
     kinfo_proc* kinfo = &kinfo_procs_[index_of_kinfo_proc_];
     // Skip processes just awaiting collection
     if ((kinfo->kp_proc.p_pid > 0) && (kinfo->kp_proc.p_stat == SZOMB))
       continue;
     int mib[] = { CTL_KERN, KERN_PROCARGS, kinfo->kp_proc.p_pid };
     // Found out what size buffer we need
     size_t data_len = 0;
     if (sysctl(mib, arraysize(mib), NULL, &data_len, NULL, 0) < 0) {
       CHROMIUM_LOG(ERROR) << "failed to figure out the buffer size for a commandline";
       continue;
     }
     data.resize(data_len);
     if (sysctl(mib, arraysize(mib), &data[0], &data_len, NULL, 0) < 0) {
       CHROMIUM_LOG(ERROR) << "failed to fetch a commandline";
       continue;
     }
     // Data starts w/ the full path null termed, so we have to extract just the
     // executable name from the path.
     size_t exec_name_end = data.find('\0');
     if (exec_name_end == std::string::npos) {
       CHROMIUM_LOG(ERROR) << "command line data didn't match expected format";
       continue;
     }
     size_t last_slash = data.rfind('/', exec_name_end);
     if (last_slash == std::string::npos)
       exec_name = data.substr(0, exec_name_end);
     else
       exec_name = data.substr(last_slash + 1, exec_name_end - last_slash - 1);
     // Check the name
     if (executable_name_utf8 == exec_name) {
       entry_.pid = kinfo->kp_proc.p_pid;
       entry_.ppid = kinfo->kp_eproc.e_ppid;
       base::strlcpy(entry_.szExeFile, exec_name.c_str(),
                     sizeof(entry_.szExeFile));
       // Start w/ the next entry next time through
       ++index_of_kinfo_proc_;
       // Done
       return true;
     }
   }
   return false;
 }
 bool NamedProcessIterator::IncludeEntry() {
   // Don't need to check the name, we did that w/in CheckForNextProcess.
   if (!filter_)
     return true;
   return filter_->Includes(entry_.pid, entry_.ppid);
 }
 }  // namespace base

The Tor Browser / annotate

ipc/chromium/src/base/process_util_mac.mm@6474c204b198 (annotated)

ipc/chromium/src/base/process_util_mac.mm