1// Copyright 2013 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 5package org.chromium.base; 6 7import android.text.TextUtils; 8import android.util.Log; 9 10import java.io.File; 11import java.io.FileInputStream; 12import java.io.FileNotFoundException; 13import java.io.IOException; 14import java.io.InputStreamReader; 15import java.io.Reader; 16import java.util.ArrayList; 17import java.util.Arrays; 18import java.util.HashMap; 19import java.util.concurrent.atomic.AtomicReference; 20 21/** 22 * Java mirror of base/command_line.h. 23 * Android applications don't have command line arguments. Instead, they're "simulated" by reading a 24 * file at a specific location early during startup. Applications each define their own files, e.g., 25 * ContentShellActivity.COMMAND_LINE_FILE or ChromiumTestShellApplication.COMMAND_LINE_FILE. 26**/ 27public abstract class CommandLine { 28 // Public abstract interface, implemented in derived classes. 29 // All these methods reflect their native-side counterparts. 30 /** 31 * Returns true if this command line contains the given switch. 32 * (Switch names ARE case-sensitive). 33 */ 34 public abstract boolean hasSwitch(String switchString); 35 36 /** 37 * Return the value associated with the given switch, or null. 38 * @param switchString The switch key to lookup. It should NOT start with '--' ! 39 * @return switch value, or null if the switch is not set or set to empty. 40 */ 41 public abstract String getSwitchValue(String switchString); 42 43 /** 44 * Return the value associated with the given switch, or {@code defaultValue} if the switch 45 * was not specified. 46 * @param switchString The switch key to lookup. It should NOT start with '--' ! 47 * @param defaultValue The default value to return if the switch isn't set. 48 * @return Switch value, or {@code defaultValue} if the switch is not set or set to empty. 49 */ 50 public String getSwitchValue(String switchString, String defaultValue) { 51 String value = getSwitchValue(switchString); 52 return TextUtils.isEmpty(value) ? defaultValue : value; 53 } 54 55 /** 56 * Append a switch to the command line. There is no guarantee 57 * this action happens before the switch is needed. 58 * @param switchString the switch to add. It should NOT start with '--' ! 59 */ 60 public abstract void appendSwitch(String switchString); 61 62 /** 63 * Append a switch and value to the command line. There is no 64 * guarantee this action happens before the switch is needed. 65 * @param switchString the switch to add. It should NOT start with '--' ! 66 * @param value the value for this switch. 67 * For example, --foo=bar becomes 'foo', 'bar'. 68 */ 69 public abstract void appendSwitchWithValue(String switchString, String value); 70 71 /** 72 * Append switch/value items in "command line" format (excluding argv[0] program name). 73 * E.g. { '--gofast', '--username=fred' } 74 * @param array an array of switch or switch/value items in command line format. 75 * Unlike the other append routines, these switches SHOULD start with '--' . 76 * Unlike init(), this does not include the program name in array[0]. 77 */ 78 public abstract void appendSwitchesAndArguments(String[] array); 79 80 /** 81 * Determine if the command line is bound to the native (JNI) implementation. 82 * @return true if the underlying implementation is delegating to the native command line. 83 */ 84 public boolean isNativeImplementation() { 85 return false; 86 } 87 88 private static final AtomicReference<CommandLine> sCommandLine = 89 new AtomicReference<CommandLine>(); 90 91 /** 92 * @returns true if the command line has already been initialized. 93 */ 94 public static boolean isInitialized() { 95 return sCommandLine.get() != null; 96 } 97 98 // Equivalent to CommandLine::ForCurrentProcess in C++. 99 public static CommandLine getInstance() { 100 CommandLine commandLine = sCommandLine.get(); 101 assert commandLine != null; 102 return commandLine; 103 } 104 105 /** 106 * Initialize the singleton instance, must be called exactly once (either directly or 107 * via one of the convenience wrappers below) before using the static singleton instance. 108 * @param args command line flags in 'argv' format: args[0] is the program name. 109 */ 110 public static void init(String[] args) { 111 setInstance(new JavaCommandLine(args)); 112 } 113 114 /** 115 * Initialize the command line from the command-line file. 116 * 117 * @param file The fully qualified command line file. 118 */ 119 public static void initFromFile(String file) { 120 // Arbitrary clamp of 8k on the amount of file we read in. 121 char[] buffer = readUtf8FileFully(file, 8 * 1024); 122 init(buffer == null ? null : tokenizeQuotedAruments(buffer)); 123 } 124 125 /** 126 * Resets both the java proxy and the native command lines. This allows the entire 127 * command line initialization to be re-run including the call to onJniLoaded. 128 */ 129 public static void reset() { 130 setInstance(null); 131 } 132 133 /** 134 * Public for testing (TODO: why are the tests in a different package?) 135 * Parse command line flags from a flat buffer, supporting double-quote enclosed strings 136 * containing whitespace. argv elements are derived by splitting the buffer on whitepace; 137 * double quote characters may enclose tokens containing whitespace; a double-quote literal 138 * may be escaped with back-slash. (Otherwise backslash is taken as a literal). 139 * @param buffer A command line in command line file format as described above. 140 * @return the tokenized arguments, suitable for passing to init(). 141 */ 142 public static String[] tokenizeQuotedAruments(char[] buffer) { 143 ArrayList<String> args = new ArrayList<String>(); 144 StringBuilder arg = null; 145 final char noQuote = '\0'; 146 final char singleQuote = '\''; 147 final char doubleQuote = '"'; 148 char currentQuote = noQuote; 149 for (char c : buffer) { 150 // Detect start or end of quote block. 151 if ((currentQuote == noQuote && (c == singleQuote || c == doubleQuote)) || 152 c == currentQuote) { 153 if (arg != null && arg.length() > 0 && arg.charAt(arg.length() - 1) == '\\') { 154 // Last char was a backslash; pop it, and treat c as a literal. 155 arg.setCharAt(arg.length() - 1, c); 156 } else { 157 currentQuote = currentQuote == noQuote ? c : noQuote; 158 } 159 } else if (currentQuote == noQuote && Character.isWhitespace(c)) { 160 if (arg != null) { 161 args.add(arg.toString()); 162 arg = null; 163 } 164 } else { 165 if (arg == null) arg = new StringBuilder(); 166 arg.append(c); 167 } 168 } 169 if (arg != null) { 170 if (currentQuote != noQuote) { 171 Log.w(TAG, "Unterminated quoted string: " + arg); 172 } 173 args.add(arg.toString()); 174 } 175 return args.toArray(new String[args.size()]); 176 } 177 178 private static final String TAG = "CommandLine"; 179 private static final String SWITCH_PREFIX = "--"; 180 private static final String SWITCH_TERMINATOR = SWITCH_PREFIX; 181 private static final String SWITCH_VALUE_SEPARATOR = "="; 182 183 public static void enableNativeProxy() { 184 // Make a best-effort to ensure we make a clean (atomic) switch over from the old to 185 // the new command line implementation. If another thread is modifying the command line 186 // when this happens, all bets are off. (As per the native CommandLine). 187 sCommandLine.set(new NativeCommandLine()); 188 } 189 190 public static String[] getJavaSwitchesOrNull() { 191 CommandLine commandLine = sCommandLine.get(); 192 if (commandLine != null) { 193 assert !commandLine.isNativeImplementation(); 194 return ((JavaCommandLine) commandLine).getCommandLineArguments(); 195 } 196 return null; 197 } 198 199 private static void setInstance(CommandLine commandLine) { 200 CommandLine oldCommandLine = sCommandLine.getAndSet(commandLine); 201 if (oldCommandLine != null && oldCommandLine.isNativeImplementation()) { 202 nativeReset(); 203 } 204 } 205 206 /** 207 * @param fileName the file to read in. 208 * @param sizeLimit cap on the file size. 209 * @return Array of chars read from the file, or null if the file cannot be read 210 * or if its length exceeds |sizeLimit|. 211 */ 212 private static char[] readUtf8FileFully(String fileName, int sizeLimit) { 213 Reader reader = null; 214 File f = new File(fileName); 215 long fileLength = f.length(); 216 217 if (fileLength == 0) { 218 return null; 219 } 220 221 if (fileLength > sizeLimit) { 222 Log.w(TAG, "File " + fileName + " length " + fileLength + " exceeds limit " 223 + sizeLimit); 224 return null; 225 } 226 227 try { 228 char[] buffer = new char[(int) fileLength]; 229 reader = new InputStreamReader(new FileInputStream(f), "UTF-8"); 230 int charsRead = reader.read(buffer); 231 // Debug check that we've exhausted the input stream (will fail e.g. if the 232 // file grew after we inspected its length). 233 assert !reader.ready(); 234 return charsRead < buffer.length ? Arrays.copyOfRange(buffer, 0, charsRead) : buffer; 235 } catch (FileNotFoundException e) { 236 return null; 237 } catch (IOException e) { 238 return null; 239 } finally { 240 try { 241 if (reader != null) reader.close(); 242 } catch (IOException e) { 243 Log.e(TAG, "Unable to close file reader.", e); 244 } 245 } 246 } 247 248 private CommandLine() {} 249 250 private static class JavaCommandLine extends CommandLine { 251 private HashMap<String, String> mSwitches = new HashMap<String, String>(); 252 private ArrayList<String> mArgs = new ArrayList<String>(); 253 254 // The arguments begin at index 1, since index 0 contains the executable name. 255 private int mArgsBegin = 1; 256 257 JavaCommandLine(String[] args) { 258 if (args == null || args.length == 0 || args[0] == null) { 259 mArgs.add(""); 260 } else { 261 mArgs.add(args[0]); 262 appendSwitchesInternal(args, 1); 263 } 264 // Invariant: we always have the argv[0] program name element. 265 assert mArgs.size() > 0; 266 } 267 268 /** 269 * Returns the switches and arguments passed into the program, with switches and their 270 * values coming before all of the arguments. 271 */ 272 private String[] getCommandLineArguments() { 273 return mArgs.toArray(new String[mArgs.size()]); 274 } 275 276 @Override 277 public boolean hasSwitch(String switchString) { 278 return mSwitches.containsKey(switchString); 279 } 280 281 @Override 282 public String getSwitchValue(String switchString) { 283 // This is slightly round about, but needed for consistency with the NativeCommandLine 284 // version which does not distinguish empty values from key not present. 285 String value = mSwitches.get(switchString); 286 return value == null || value.isEmpty() ? null : value; 287 } 288 289 @Override 290 public void appendSwitch(String switchString) { 291 appendSwitchWithValue(switchString, null); 292 } 293 294 /** 295 * Appends a switch to the current list. 296 * @param switchString the switch to add. It should NOT start with '--' ! 297 * @param value the value for this switch. 298 */ 299 @Override 300 public void appendSwitchWithValue(String switchString, String value) { 301 mSwitches.put(switchString, value == null ? "" : value); 302 303 // Append the switch and update the switches/arguments divider mArgsBegin. 304 String combinedSwitchString = SWITCH_PREFIX + switchString; 305 if (value != null && !value.isEmpty()) 306 combinedSwitchString += SWITCH_VALUE_SEPARATOR + value; 307 308 mArgs.add(mArgsBegin++, combinedSwitchString); 309 } 310 311 @Override 312 public void appendSwitchesAndArguments(String[] array) { 313 appendSwitchesInternal(array, 0); 314 } 315 316 // Add the specified arguments, but skipping the first |skipCount| elements. 317 private void appendSwitchesInternal(String[] array, int skipCount) { 318 boolean parseSwitches = true; 319 for (String arg : array) { 320 if (skipCount > 0) { 321 --skipCount; 322 continue; 323 } 324 325 if (arg.equals(SWITCH_TERMINATOR)) { 326 parseSwitches = false; 327 } 328 329 if (parseSwitches && arg.startsWith(SWITCH_PREFIX)) { 330 String[] parts = arg.split(SWITCH_VALUE_SEPARATOR, 2); 331 String value = parts.length > 1 ? parts[1] : null; 332 appendSwitchWithValue(parts[0].substring(SWITCH_PREFIX.length()), value); 333 } else { 334 mArgs.add(arg); 335 } 336 } 337 } 338 } 339 340 private static class NativeCommandLine extends CommandLine { 341 @Override 342 public boolean hasSwitch(String switchString) { 343 return nativeHasSwitch(switchString); 344 } 345 346 @Override 347 public String getSwitchValue(String switchString) { 348 return nativeGetSwitchValue(switchString); 349 } 350 351 @Override 352 public void appendSwitch(String switchString) { 353 nativeAppendSwitch(switchString); 354 } 355 356 @Override 357 public void appendSwitchWithValue(String switchString, String value) { 358 nativeAppendSwitchWithValue(switchString, value); 359 } 360 361 @Override 362 public void appendSwitchesAndArguments(String[] array) { 363 nativeAppendSwitchesAndArguments(array); 364 } 365 366 @Override 367 public boolean isNativeImplementation() { 368 return true; 369 } 370 } 371 372 private static native void nativeReset(); 373 private static native boolean nativeHasSwitch(String switchString); 374 private static native String nativeGetSwitchValue(String switchString); 375 private static native void nativeAppendSwitch(String switchString); 376 private static native void nativeAppendSwitchWithValue(String switchString, String value); 377 private static native void nativeAppendSwitchesAndArguments(String[] array); 378} 379