The Tor Browser: security/sandbox/chromium/base/command

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

     1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

     2 // Use of this source code is governed by a BSD-style license that can be

     3 // found in the LICENSE file.

     5 #include "base/command_line.h"

     7 #include <algorithm>

     8 #include <ostream>

    10 #include "base/basictypes.h"

    11 #include "base/files/file_path.h"

    12 #include "base/logging.h"

    13 #include "base/strings/string_split.h"

    14 #include "base/strings/string_util.h"

    15 #include "base/strings/utf_string_conversions.h"

    16 #include "build/build_config.h"

    18 #if defined(OS_WIN)

    19 #include <windows.h>

    20 #include <shellapi.h>

    21 #endif

    23 using base::FilePath;

    25 CommandLine* CommandLine::current_process_commandline_ = NULL;

    27 namespace {

    28 const CommandLine::CharType kSwitchTerminator[] = FILE_PATH_LITERAL("--");

    29 const CommandLine::CharType kSwitchValueSeparator[] = FILE_PATH_LITERAL("=");

    30 // Since we use a lazy match, make sure that longer versions (like "--") are

    31 // listed before shorter versions (like "-") of similar prefixes.

    32 #if defined(OS_WIN)

    33 const CommandLine::CharType* const kSwitchPrefixes[] = {L"--", L"-", L"/"};

    34 #elif defined(OS_POSIX)

    35 // Unixes don't use slash as a switch.

    36 const CommandLine::CharType* const kSwitchPrefixes[] = {"--", "-"};

    37 #endif

    39 size_t GetSwitchPrefixLength(const CommandLine::StringType& string) {

    40   for (size_t i = 0; i < arraysize(kSwitchPrefixes); ++i) {

    41     CommandLine::StringType prefix(kSwitchPrefixes[i]);

    42     if (string.compare(0, prefix.length(), prefix) == 0)

    43       return prefix.length();

    44   }

    45   return 0;

    46 }

    48 // Fills in |switch_string| and |switch_value| if |string| is a switch.

    49 // This will preserve the input switch prefix in the output |switch_string|.

    50 bool IsSwitch(const CommandLine::StringType& string,

    51               CommandLine::StringType* switch_string,

    52               CommandLine::StringType* switch_value) {

    53   switch_string->clear();

    54   switch_value->clear();

    55   size_t prefix_length = GetSwitchPrefixLength(string);

    56   if (prefix_length == 0 || prefix_length == string.length())

    57     return false;

    59   const size_t equals_position = string.find(kSwitchValueSeparator);

    60   *switch_string = string.substr(0, equals_position);

    61   if (equals_position != CommandLine::StringType::npos)

    62     *switch_value = string.substr(equals_position + 1);

    63   return true;

    64 }

    66 // Append switches and arguments, keeping switches before arguments.

    67 void AppendSwitchesAndArguments(CommandLine& command_line,

    68                                 const CommandLine::StringVector& argv) {

    69   bool parse_switches = true;

    70   for (size_t i = 1; i < argv.size(); ++i) {

    71     CommandLine::StringType arg = argv[i];

    72     TrimWhitespace(arg, TRIM_ALL, &arg);

    74     CommandLine::StringType switch_string;

    75     CommandLine::StringType switch_value;

    76     parse_switches &= (arg != kSwitchTerminator);

    77     if (parse_switches && IsSwitch(arg, &switch_string, &switch_value)) {

    78 #if defined(OS_WIN)

    79       command_line.AppendSwitchNative(WideToASCII(switch_string), switch_value);

    80 #elif defined(OS_POSIX)

    81       command_line.AppendSwitchNative(switch_string, switch_value);

    82 #endif

    83     } else {

    84       command_line.AppendArgNative(arg);

    85     }

    86   }

    87 }

    89 // Lowercase switches for backwards compatiblity *on Windows*.

    90 std::string LowerASCIIOnWindows(const std::string& string) {

    91 #if defined(OS_WIN)

    92   return StringToLowerASCII(string);

    93 #elif defined(OS_POSIX)

    94   return string;

    95 #endif

    96 }

    99 #if defined(OS_WIN)

   100 // Quote a string as necessary for CommandLineToArgvW compatiblity *on Windows*.

   101 std::wstring QuoteForCommandLineToArgvW(const std::wstring& arg) {

   102   // We follow the quoting rules of CommandLineToArgvW.

   103   // http://msdn.microsoft.com/en-us/library/17w5ykft.aspx

   104   if (arg.find_first_of(L" \\\"") == std::wstring::npos) {

   105     // No quoting necessary.

   106     return arg;

   107   }

   109   std::wstring out;

   110   out.push_back(L'"');

   111   for (size_t i = 0; i < arg.size(); ++i) {

   112     if (arg[i] == '\\') {

   113       // Find the extent of this run of backslashes.

   114       size_t start = i, end = start + 1;

   115       for (; end < arg.size() && arg[end] == '\\'; ++end)

   116         /* empty */;

   117       size_t backslash_count = end - start;

   119       // Backslashes are escapes only if the run is followed by a double quote.

   120       // Since we also will end the string with a double quote, we escape for

   121       // either a double quote or the end of the string.

   122       if (end == arg.size() || arg[end] == '"') {

   123         // To quote, we need to output 2x as many backslashes.

   124         backslash_count *= 2;

   125       }

   126       for (size_t j = 0; j < backslash_count; ++j)

   127         out.push_back('\\');

   129       // Advance i to one before the end to balance i++ in loop.

   130       i = end - 1;

   131     } else if (arg[i] == '"') {

   132       out.push_back('\\');

   133       out.push_back('"');

   134     } else {

   135       out.push_back(arg[i]);

   136     }

   137   }

   138   out.push_back('"');

   140   return out;

   141 }

   142 #endif

   144 }  // namespace

   146 CommandLine::CommandLine(NoProgram no_program)

   147     : argv_(1),

   148       begin_args_(1) {

   149 }

   151 CommandLine::CommandLine(const FilePath& program)

   152     : argv_(1),

   153       begin_args_(1) {

   154   SetProgram(program);

   155 }

   157 CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv)

   158     : argv_(1),

   159       begin_args_(1) {

   160   InitFromArgv(argc, argv);

   161 }

   163 CommandLine::CommandLine(const StringVector& argv)

   164     : argv_(1),

   165       begin_args_(1) {

   166   InitFromArgv(argv);

   167 }

   169 CommandLine::~CommandLine() {

   170 }

   172 // static

   173 bool CommandLine::Init(int argc, const char* const* argv) {

   174   if (current_process_commandline_) {

   175     // If this is intentional, Reset() must be called first. If we are using

   176     // the shared build mode, we have to share a single object across multiple

   177     // shared libraries.

   178     return false;

   179   }

   181   current_process_commandline_ = new CommandLine(NO_PROGRAM);

   182 #if defined(OS_WIN)

   183   current_process_commandline_->ParseFromString(::GetCommandLineW());

   184 #elif defined(OS_POSIX)

   185   current_process_commandline_->InitFromArgv(argc, argv);

   186 #endif

   188   return true;

   189 }

   191 // static

   192 void CommandLine::Reset() {

   193   DCHECK(current_process_commandline_);

   194   delete current_process_commandline_;

   195   current_process_commandline_ = NULL;

   196 }

   198 // static

   199 CommandLine* CommandLine::ForCurrentProcess() {

   200   DCHECK(current_process_commandline_);

   201   return current_process_commandline_;

   202 }

   204 // static

   205 bool CommandLine::InitializedForCurrentProcess() {

   206   return !!current_process_commandline_;

   207 }

   209 #if defined(OS_WIN)

   210 // static

   211 CommandLine CommandLine::FromString(const std::wstring& command_line) {

   212   CommandLine cmd(NO_PROGRAM);

   213   cmd.ParseFromString(command_line);

   214   return cmd;

   215 }

   216 #endif

   218 void CommandLine::InitFromArgv(int argc,

   219                                const CommandLine::CharType* const* argv) {

   220   StringVector new_argv;

   221   for (int i = 0; i < argc; ++i)

   222     new_argv.push_back(argv[i]);

   223   InitFromArgv(new_argv);

   224 }

   226 void CommandLine::InitFromArgv(const StringVector& argv) {

   227   argv_ = StringVector(1);

   228   switches_.clear();

   229   begin_args_ = 1;

   230   SetProgram(argv.empty() ? FilePath() : FilePath(argv[0]));

   231   AppendSwitchesAndArguments(*this, argv);

   232 }

   234 CommandLine::StringType CommandLine::GetCommandLineString() const {

   235   StringType string(argv_[0]);

   236 #if defined(OS_WIN)

   237   string = QuoteForCommandLineToArgvW(string);

   238 #endif

   239   StringType params(GetArgumentsString());

   240   if (!params.empty()) {

   241     string.append(StringType(FILE_PATH_LITERAL(" ")));

   242     string.append(params);

   243   }

   244   return string;

   245 }

   247 CommandLine::StringType CommandLine::GetArgumentsString() const {

   248   StringType params;

   249   // Append switches and arguments.

   250   bool parse_switches = true;

   251   for (size_t i = 1; i < argv_.size(); ++i) {

   252     StringType arg = argv_[i];

   253     StringType switch_string;

   254     StringType switch_value;

   255     parse_switches &= arg != kSwitchTerminator;

   256     if (i > 1)

   257       params.append(StringType(FILE_PATH_LITERAL(" ")));

   258     if (parse_switches && IsSwitch(arg, &switch_string, &switch_value)) {

   259       params.append(switch_string);

   260       if (!switch_value.empty()) {

   261 #if defined(OS_WIN)

   262         switch_value = QuoteForCommandLineToArgvW(switch_value);

   263 #endif

   264         params.append(kSwitchValueSeparator + switch_value);

   265       }

   266     }

   267     else {

   268 #if defined(OS_WIN)

   269       arg = QuoteForCommandLineToArgvW(arg);

   270 #endif

   271       params.append(arg);

   272     }

   273   }

   274   return params;

   275 }

   277 FilePath CommandLine::GetProgram() const {

   278   return FilePath(argv_[0]);

   279 }

   281 void CommandLine::SetProgram(const FilePath& program) {

   282   TrimWhitespace(program.value(), TRIM_ALL, &argv_[0]);

   283 }

   285 bool CommandLine::HasSwitch(const std::string& switch_string) const {

   286   return switches_.find(LowerASCIIOnWindows(switch_string)) != switches_.end();

   287 }

   289 std::string CommandLine::GetSwitchValueASCII(

   290     const std::string& switch_string) const {

   291   StringType value = GetSwitchValueNative(switch_string);

   292   if (!IsStringASCII(value)) {

   293     DLOG(WARNING) << "Value of switch (" << switch_string << ") must be ASCII.";

   294     return std::string();

   295   }

   296 #if defined(OS_WIN)

   297   return WideToASCII(value);

   298 #else

   299   return value;

   300 #endif

   301 }

   303 FilePath CommandLine::GetSwitchValuePath(

   304     const std::string& switch_string) const {

   305   return FilePath(GetSwitchValueNative(switch_string));

   306 }

   308 CommandLine::StringType CommandLine::GetSwitchValueNative(

   309     const std::string& switch_string) const {

   310   SwitchMap::const_iterator result = switches_.end();

   311   result = switches_.find(LowerASCIIOnWindows(switch_string));

   312   return result == switches_.end() ? StringType() : result->second;

   313 }

   315 void CommandLine::AppendSwitch(const std::string& switch_string) {

   316   AppendSwitchNative(switch_string, StringType());

   317 }

   319 void CommandLine::AppendSwitchPath(const std::string& switch_string,

   320                                    const FilePath& path) {

   321   AppendSwitchNative(switch_string, path.value());

   322 }

   324 void CommandLine::AppendSwitchNative(const std::string& switch_string,

   325                                      const CommandLine::StringType& value) {

   326   std::string switch_key(LowerASCIIOnWindows(switch_string));

   327 #if defined(OS_WIN)

   328   StringType combined_switch_string(ASCIIToWide(switch_key));

   329 #elif defined(OS_POSIX)

   330   StringType combined_switch_string(switch_string);

   331 #endif

   332   size_t prefix_length = GetSwitchPrefixLength(combined_switch_string);

   333   switches_[switch_key.substr(prefix_length)] = value;

   334   // Preserve existing switch prefixes in |argv_|; only append one if necessary.

   335   if (prefix_length == 0)

   336     combined_switch_string = kSwitchPrefixes[0] + combined_switch_string;

   337   if (!value.empty())

   338     combined_switch_string += kSwitchValueSeparator + value;

   339   // Append the switch and update the switches/arguments divider |begin_args_|.

   340   argv_.insert(argv_.begin() + begin_args_++, combined_switch_string);

   341 }

   343 void CommandLine::AppendSwitchASCII(const std::string& switch_string,

   344                                     const std::string& value_string) {

   345 #if defined(OS_WIN)

   346   AppendSwitchNative(switch_string, ASCIIToWide(value_string));

   347 #elif defined(OS_POSIX)

   348   AppendSwitchNative(switch_string, value_string);

   349 #endif

   350 }

   352 void CommandLine::CopySwitchesFrom(const CommandLine& source,

   353                                    const char* const switches[],

   354                                    size_t count) {

   355   for (size_t i = 0; i < count; ++i) {

   356     if (source.HasSwitch(switches[i]))

   357       AppendSwitchNative(switches[i], source.GetSwitchValueNative(switches[i]));

   358   }

   359 }

   361 CommandLine::StringVector CommandLine::GetArgs() const {

   362   // Gather all arguments after the last switch (may include kSwitchTerminator).

   363   StringVector args(argv_.begin() + begin_args_, argv_.end());

   364   // Erase only the first kSwitchTerminator (maybe "--" is a legitimate page?)

   365   StringVector::iterator switch_terminator =

   366       std::find(args.begin(), args.end(), kSwitchTerminator);

   367   if (switch_terminator != args.end())

   368     args.erase(switch_terminator);

   369   return args;

   370 }

   372 void CommandLine::AppendArg(const std::string& value) {

   373 #if defined(OS_WIN)

   374   DCHECK(IsStringUTF8(value));

   375   AppendArgNative(UTF8ToWide(value));

   376 #elif defined(OS_POSIX)

   377   AppendArgNative(value);

   378 #endif

   379 }

   381 void CommandLine::AppendArgPath(const FilePath& path) {

   382   AppendArgNative(path.value());

   383 }

   385 void CommandLine::AppendArgNative(const CommandLine::StringType& value) {

   386   argv_.push_back(value);

   387 }

   389 void CommandLine::AppendArguments(const CommandLine& other,

   390                                   bool include_program) {

   391   if (include_program)

   392     SetProgram(other.GetProgram());

   393   AppendSwitchesAndArguments(*this, other.argv());

   394 }

   396 void CommandLine::PrependWrapper(const CommandLine::StringType& wrapper) {

   397   if (wrapper.empty())

   398     return;

   399   // The wrapper may have embedded arguments (like "gdb --args"). In this case,

   400   // we don't pretend to do anything fancy, we just split on spaces.

   401   StringVector wrapper_argv;

   402   base::SplitString(wrapper, FILE_PATH_LITERAL(' '), &wrapper_argv);

   403   // Prepend the wrapper and update the switches/arguments |begin_args_|.

   404   argv_.insert(argv_.begin(), wrapper_argv.begin(), wrapper_argv.end());

   405   begin_args_ += wrapper_argv.size();

   406 }

   408 #if defined(OS_WIN)

   409 void CommandLine::ParseFromString(const std::wstring& command_line) {

   410   std::wstring command_line_string;

   411   TrimWhitespace(command_line, TRIM_ALL, &command_line_string);

   412   if (command_line_string.empty())

   413     return;

   415   int num_args = 0;

   416   wchar_t** args = NULL;

   417   args = ::CommandLineToArgvW(command_line_string.c_str(), &num_args);

   419   DPLOG_IF(FATAL, !args) << "CommandLineToArgvW failed on command line: "

   420                          << command_line;

   421   InitFromArgv(num_args, args);

   422   LocalFree(args);

   423 }

   424 #endif

The Tor Browser / file revision

security/sandbox/chromium/base/command_line.cc@6474c204b198

security/sandbox/chromium/base/command_line.cc