Handle spaces in the name of the mini_installer.

chrome/installer/mini_installer/mini_installer.cc

 // Copyright (c) 2012 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.
 
 // mini_installer.exe is the first exe that is run when chrome is being
 // installed or upgraded. It is designed to be extremely small (~5KB with no
 // extra resources linked) and it has two main jobs:
 //   1) unpack the resources (possibly decompressing some)
 //   2) run the real installer (setup.exe) with appropriate flags.
 //
@@ skipping 23 matching lines @@
 
 #include <sddl.h>
 #include <shellapi.h>
 #include <stdlib.h>
 #include <stddef.h>
 
 #include "chrome/installer/mini_installer/appid.h"
 #include "chrome/installer/mini_installer/configuration.h"
 #include "chrome/installer/mini_installer/decompress.h"
 #include "chrome/installer/mini_installer/mini_installer_constants.h"
-#include "chrome/installer/mini_installer/mini_string.h"
 #include "chrome/installer/mini_installer/pe_resource.h"
 #include "chrome/installer/mini_installer/regkey.h"
 
 namespace mini_installer {
 
 typedef StackString<MAX_PATH> PathString;
-typedef StackString<MAX_PATH * 4> CommandString;
 
 // This structure passes data back and forth for the processing
 // of resource callbacks.
 struct Context {
   // Input to the call back method. Specifies the dir to save resources.
   const wchar_t* base_path;
   // First output from call back method. Full path of Chrome archive.
   PathString* chrome_resource_path;
   // Second output from call back method. Full path of Setup archive/exe.
   PathString* setup_resource_path;
@@ skipping 150 matching lines @@
     // could return a different object but since we never spawn more than one
     // sub-process at a time that case should never happen.
     return ProcessExitResult(WAIT_FOR_PROCESS_FAILED, ::GetLastError());
   }
 
   ::CloseHandle(pi.hProcess);
 
   return ProcessExitResult(exit_code);
 }
 
-// Appends any command line params passed to mini_installer to the given buffer
-// so that they can be passed on to setup.exe.
-// |buffer| is unchanged in case of error.
-void AppendCommandLineFlags(const Configuration& configuration,
+void AppendCommandLineFlags(const wchar_t* command_line,
                             CommandString* buffer) {
-  PathString full_exe_path;
-  size_t len = ::GetModuleFileName(
-      NULL, full_exe_path.get(), static_cast<DWORD>(full_exe_path.capacity()));
-  if (!len || len >= full_exe_path.capacity())
+  // The program name (the first argument parsed by CommandLineToArgvW) is
+  // delimited by whitespace or a double quote based on the first character of
+  // the full command line string. Use the same logic here to scan past the
+  // program name in the program's command line (obtained during startup from
+  // GetCommandLine). See
+  // http://www.windowsinspired.com/how-a-windows-programs-splits-its-command-line-into-individual-arguments/
+  // for gory details regarding how CommandLineToArgvW works.
+  wchar_t a_char = 0;
+  if (*command_line == L'"') {
+    // Scan forward past the closing double quote.
+    ++command_line;
+    while (true) {
+      a_char = *command_line;
+      if (!a_char)
+        break;
+      ++command_line;
+      if (a_char == L'"') {
+        a_char = *command_line;
+        break;
+      }
+    }  // postcondition: |a_char| contains the character at *command_line.
+  } else {
+    // Scan forward for the first space or tab character.
+    while (true) {
+      a_char = *command_line;
+      if (!a_char || a_char == L' ' || a_char == L'\t')
+        break;
+      ++command_line;
+    }  // postcondition: |a_char| contains the character at *command_line.
+  }
+
+  if (!a_char)
     return;
 
-  const wchar_t* exe_name =
-      GetNameFromPathExt(full_exe_path.get(), static_cast<DWORD>(len));
-
-  // - configuration.program() returns the first command line argument
-  //   passed into the program (that the user probably typed in this case).
-  //       "mini_installer.exe"
-  //       "mini_installer"
-  //       "out\Release\mini_installer"
-  // - |exe_name| is the executable file of the current process.
-  //       "mini_installer.exe"
-  //
-  // Note that there are three possibilities to handle here.
-  // Receive a cmdline containing:
-  // 1) executable name WITH extension
-  // 2) executable name with NO extension
-  // 3) NO executable name as part of cmdline
-  const wchar_t* cmd_to_append = L"";
-  const wchar_t* arg0 = configuration.program();
-  if (!arg0)
+  // Append a space if |command_line| doesn't begin with one.
+  if (a_char != ' ' && a_char != '\t' && !buffer->append(L" "))
     return;
-  const wchar_t* arg0_base_name = GetNameFromPathExt(arg0, ::lstrlen(arg0));
-  if (!StrStartsWith(exe_name, arg0_base_name)) {
-    // State 3: NO executable name as part of cmdline.
-    buffer->append(L" ");
-    cmd_to_append = configuration.command_line();
-  } else if (configuration.argument_count() > 1) {
-    // State 1 or 2: Executable name is in cmdline.
-    // - Append everything AFTER the executable name.
-    //   (Using arg0_base_name here to make sure to match with or without
-    //   extension.  Then move to the space following the token.)
-    const wchar_t* tmp = SearchStringI(configuration.command_line(),
-                                       arg0_base_name);
-    tmp = SearchStringI(tmp, L" ");
-    cmd_to_append = tmp;
-  }
-
-  buffer->append(cmd_to_append);
+  buffer->append(command_line);
 }
 
-
 // Windows defined callback used in the EnumResourceNames call. For each
 // matching resource found, the callback is invoked and at this point we write
 // it to disk. We expect resource names to start with 'chrome' or 'setup'. Any
 // other name is treated as an error.
 BOOL CALLBACK OnResourceFound(HMODULE module, const wchar_t* type,
                               wchar_t* name, LONG_PTR context) {
   if (NULL == context)
     return FALSE;
 
   Context* ctx = reinterpret_cast<Context*>(context);
@@ skipping 104 matching lines @@
           !cmd_line.append(kCmdNewSetupExe) ||
           !cmd_line.append(L"=\"") ||
           !cmd_line.append(setup_dest_path.get()) ||
           !cmd_line.append(L"\"")) {
         exit_code = ProcessExitResult(COMMAND_STRING_OVERFLOW);
       }
     }
 
     // Get any command line option specified for mini_installer and pass them
     // on to setup.exe.
-    AppendCommandLineFlags(configuration, &cmd_line);
+    AppendCommandLineFlags(configuration.command_line(), &cmd_line);
 
     if (exit_code.IsSuccess())
       exit_code = RunProcessAndWait(exe_path.get(), cmd_line.get());
 
     if (!exit_code.IsSuccess())
       DeleteFile(setup_path->get());
     else if (!setup_path->assign(setup_dest_path.get()))
       exit_code = ProcessExitResult(PATH_STRING_OVERFLOW);
 
     return exit_code;
@@ skipping 78 matching lines @@
       (!cmd_line.append(L" --") ||
        !cmd_line.append(kCmdPreviousVersion) ||
        !cmd_line.append(L"=\"") ||
        !cmd_line.append(configuration.previous_version()) ||
        !cmd_line.append(L"\""))) {
     return ProcessExitResult(COMMAND_STRING_OVERFLOW);
   }
 
   // Get any command line option specified for mini_installer and pass them
   // on to setup.exe
-  AppendCommandLineFlags(configuration, &cmd_line);
+  AppendCommandLineFlags(configuration.command_line(), &cmd_line);
 
   return RunProcessAndWait(NULL, cmd_line.get());
 }
 
 // Deletes given files and working dir.
 void DeleteExtractedFiles(const wchar_t* base_path,
                           const wchar_t* archive_path,
                           const wchar_t* setup_path) {
   ::DeleteFile(archive_path);
   ::DeleteFile(setup_path);
@@ skipping 358 matching lines @@
     DeleteExtractedFiles(base_path.get(), archive_path.get(), setup_path.get());
 
 #if defined(GOOGLE_CHROME_BUILD)
   WriteInstallResults(configuration, exit_code);
 #endif
 
   return exit_code;
 }
 
 }  // namespace mini_installer