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.
4
5#include "base/command_line.h"
6
7#include <algorithm>
8#include <ostream>
9
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"
17
18#if defined(OS_WIN)
19#include <windows.h>
20#include <shellapi.h>
21#endif
22
23using base::FilePath;
24
25CommandLine* CommandLine::current_process_commandline_ = NULL;
26
27namespace {
28const CommandLine::CharType kSwitchTerminator[] = FILE_PATH_LITERAL("--");
29const 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)
33const CommandLine::CharType* const kSwitchPrefixes[] = {L"--", L"-", L"/"};
34#elif defined(OS_POSIX)
35// Unixes don't use slash as a switch.
36const CommandLine::CharType* const kSwitchPrefixes[] = {"--", "-"};
37#endif
38
39size_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}
47
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|.
50bool 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;
58
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}
65
66// Append switches and arguments, keeping switches before arguments.
67void 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);
73
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}
88
89// Lowercase switches for backwards compatiblity *on Windows*.
90std::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}
97
98
99#if defined(OS_WIN)
100// Quote a string as necessary for CommandLineToArgvW compatiblity *on Windows*.
101std::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  }
108
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;
118
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('\\');
128
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('"');
139
140  return out;
141}
142#endif
143
144}  // namespace
145
146CommandLine::CommandLine(NoProgram no_program)
147    : argv_(1),
148      begin_args_(1) {
149}
150
151CommandLine::CommandLine(const FilePath& program)
152    : argv_(1),
153      begin_args_(1) {
154  SetProgram(program);
155}
156
157CommandLine::CommandLine(int argc, const CommandLine::CharType* const* argv)
158    : argv_(1),
159      begin_args_(1) {
160  InitFromArgv(argc, argv);
161}
162
163CommandLine::CommandLine(const StringVector& argv)
164    : argv_(1),
165      begin_args_(1) {
166  InitFromArgv(argv);
167}
168
169CommandLine::~CommandLine() {
170}
171
172// static
173bool 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  }
180
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
187
188  return true;
189}
190
191// static
192void CommandLine::Reset() {
193  DCHECK(current_process_commandline_);
194  delete current_process_commandline_;
195  current_process_commandline_ = NULL;
196}
197
198// static
199CommandLine* CommandLine::ForCurrentProcess() {
200  DCHECK(current_process_commandline_);
201  return current_process_commandline_;
202}
203
204// static
205bool CommandLine::InitializedForCurrentProcess() {
206  return !!current_process_commandline_;
207}
208
209#if defined(OS_WIN)
210// static
211CommandLine CommandLine::FromString(const std::wstring& command_line) {
212  CommandLine cmd(NO_PROGRAM);
213  cmd.ParseFromString(command_line);
214  return cmd;
215}
216#endif
217
218void 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}
225
226void 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}
233
234CommandLine::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}
246
247CommandLine::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}
276
277FilePath CommandLine::GetProgram() const {
278  return FilePath(argv_[0]);
279}
280
281void CommandLine::SetProgram(const FilePath& program) {
282  TrimWhitespace(program.value(), TRIM_ALL, &argv_[0]);
283}
284
285bool CommandLine::HasSwitch(const std::string& switch_string) const {
286  return switches_.find(LowerASCIIOnWindows(switch_string)) != switches_.end();
287}
288
289std::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}
302
303FilePath CommandLine::GetSwitchValuePath(
304    const std::string& switch_string) const {
305  return FilePath(GetSwitchValueNative(switch_string));
306}
307
308CommandLine::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}
314
315void CommandLine::AppendSwitch(const std::string& switch_string) {
316  AppendSwitchNative(switch_string, StringType());
317}
318
319void CommandLine::AppendSwitchPath(const std::string& switch_string,
320                                   const FilePath& path) {
321  AppendSwitchNative(switch_string, path.value());
322}
323
324void 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}
342
343void 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}
351
352void 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}
360
361CommandLine::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}
371
372void 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}
380
381void CommandLine::AppendArgPath(const FilePath& path) {
382  AppendArgNative(path.value());
383}
384
385void CommandLine::AppendArgNative(const CommandLine::StringType& value) {
386  argv_.push_back(value);
387}
388
389void CommandLine::AppendArguments(const CommandLine& other,
390                                  bool include_program) {
391  if (include_program)
392    SetProgram(other.GetProgram());
393  AppendSwitchesAndArguments(*this, other.argv());
394}
395
396void 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}
407
408#if defined(OS_WIN)
409void 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;
414
415  int num_args = 0;
416  wchar_t** args = NULL;
417  args = ::CommandLineToArgvW(command_line_string.c_str(), &num_args);
418
419  DPLOG_IF(FATAL, !args) << "CommandLineToArgvW failed on command line: "
420                         << command_line;
421  InitFromArgv(num_args, args);
422  LocalFree(args);
423}
424#endif
425