The Tor Browser: webapprt/win/webapprt.cpp@8bccb770b82d (annotated)

webapprt/win/webapprt.cpp@8bccb770b82d (annotated)

webapprt/win/webapprt.cpp

Wed, 31 Dec 2014 13:27:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 13:27:57 +0100
branch: TOR_BUG_3246
changeset 6: 8bccb770b82d
permissions: -rw-r--r--

Ignore runtime configuration files generated during quality assurance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 // System headers (alphabetical)
 #include <fcntl.h>
 #include <io.h>
 #include <share.h>
 #include <sys/stat.h>
 #include <windows.h>
 // Mozilla headers (alphabetical)
 #include "nsIFile.h"
 #include "nsINIParser.h"
 #include "nsWindowsWMain.cpp"   // we want a wmain entry point
 #include "nsXPCOMGlue.h"
 #include "nsXPCOMPrivate.h"     // for MAXPATHLEN and XPCOM_DLL
 #include "nsXULAppAPI.h"
 #include "mozilla/AppData.h"
 using namespace mozilla;
 XRE_GetFileFromPathType XRE_GetFileFromPath;
 XRE_CreateAppDataType XRE_CreateAppData;
 XRE_FreeAppDataType XRE_FreeAppData;
 XRE_mainType XRE_main;
 namespace {
   const char kAPP_INI[] = "application.ini";
   const char kWEBAPP_INI[] = "webapp.ini";
   const char kWEBAPPRT_INI[] = "webapprt.ini";
   const char kWEBAPPRT_PATH[] = "webapprt";
   const char kAPP_ENV_PREFIX[] = "XUL_APP_FILE=";
   const char kAPP_RT[] = "webapprt-stub.exe";
   const wchar_t kAPP_RT_BACKUP[] = L"webapprt.old";
   wchar_t curExePath[MAXPATHLEN];
   wchar_t backupFilePath[MAXPATHLEN];
   wchar_t iconPath[MAXPATHLEN];
   char profile[MAXPATHLEN];
   bool isProfileOverridden = false;
   int* pargc;
   char*** pargv;
   nsresult
   joinPath(char* const dest,
            char const* const dir,
            char const* const leaf,
            size_t bufferSize)
   {
     size_t dirLen = strlen(dir);
     size_t leafLen = strlen(leaf);
     bool needsSeparator = (dirLen != 0
                         && dir[dirLen-1] != '\\'
                         && leafLen != 0
                         && leaf[0] != '\\');
     if (dirLen + (needsSeparator? 1 : 0) + leafLen >= bufferSize) {
       return NS_ERROR_FAILURE;
     }
     strncpy(dest, dir, bufferSize);
     char* destEnd = dest + dirLen;
     if (needsSeparator) {
       *(destEnd++) = '\\';
     }
     strncpy(destEnd, leaf, leafLen);
     return NS_OK;
   }
   /**
    * A helper class which calls NS_LogInit/NS_LogTerm in its scope.
    */
   class ScopedLogging
   {
     public:
       ScopedLogging() { NS_LogInit(); }
       ~ScopedLogging() { NS_LogTerm(); }
   };
   /**
    * A helper class for scope-guarding nsXREAppData.
    */
   class ScopedXREAppData
   {
     public:
       ScopedXREAppData()
         : mAppData(nullptr) { }
       nsresult
       create(nsIFile* aINIFile)
       {
         return XRE_CreateAppData(aINIFile, &mAppData);
       }
       ~ScopedXREAppData()
       {
         if (nullptr != mAppData) {
           XRE_FreeAppData(mAppData);
         }
       }
       nsXREAppData* const
       operator->()
       {
         return get();
       }
       nsXREAppData
       operator*()
       {
         return *get();
       }
       operator
       nsXREAppData*()
       {
         return get();
       }
     private:
       nsXREAppData* mAppData;
       nsXREAppData* const get() { return mAppData; }
   };
   void
   Output(const wchar_t *fmt, ... )
   {
     va_list ap;
     va_start(ap, fmt);
     wchar_t msg[1024];
     _vsnwprintf_s(msg, _countof(msg), _countof(msg), fmt, ap);
     MessageBoxW(nullptr, msg, L"Web Runtime", MB_OK);
     va_end(ap);
   }
   void
   Output(const char *fmt, ... )
   {
     va_list ap;
     va_start(ap, fmt);
     char msg[1024];
     vsnprintf(msg, sizeof(msg), fmt, ap);
     wchar_t wide_msg[1024];
     MultiByteToWideChar(CP_UTF8,
 ,
                         msg,
                         -1,
                         wide_msg,
                         _countof(wide_msg));
     Output(wide_msg);
     va_end(ap);
   }
   const nsDynamicFunctionLoad kXULFuncs[] = {
       { "XRE_GetFileFromPath", (NSFuncPtr*) &XRE_GetFileFromPath },
       { "XRE_CreateAppData", (NSFuncPtr*) &XRE_CreateAppData },
       { "XRE_FreeAppData", (NSFuncPtr*) &XRE_FreeAppData },
       { "XRE_main", (NSFuncPtr*) &XRE_main },
       { nullptr, nullptr }
   };
   bool
   AttemptCopyAndLaunch(wchar_t* src)
   {
     // Rename the old app executable
     if (FALSE == ::MoveFileExW(curExePath,
                                backupFilePath,
                                MOVEFILE_REPLACE_EXISTING)) {
       return false;
     }
     // Copy webapprt-stub.exe from the Firefox dir to the app's dir
     if (FALSE == ::CopyFileW(src,
                              curExePath,
                              TRUE)) {
       // Try to move the old file back to its original location
       ::MoveFileW(backupFilePath,
                   curExePath);
       return false;
     }
     // XXX: We will soon embed the app's icon in the EXE here
     STARTUPINFOW si;
     PROCESS_INFORMATION pi;
     ::ZeroMemory(&si, sizeof(si));
     si.cb = sizeof(si);
     ::ZeroMemory(&pi, sizeof(pi));
     if (!CreateProcessW(curExePath, // Module name
                         nullptr,    // Command line
                         nullptr,    // Process handle not inheritable
                         nullptr,    // Thread handle not inheritable
                         FALSE,      // Set handle inheritance to FALSE
 ,          // No creation flags
                         nullptr,    // Use parent's environment block
                         nullptr,    // Use parent's starting directory
                         &si,
                         &pi)) {
       return false;
     }
     // Close process and thread handles.
     CloseHandle( pi.hProcess );
     CloseHandle( pi.hThread );
     return true;
   }
   bool
   AttemptCopyAndLaunch(char* srcUtf8)
   {
     wchar_t src[MAXPATHLEN];
     if (0 == MultiByteToWideChar(CP_UTF8,
 ,
                                  srcUtf8,
                                  -1,
                                  src,
                                  MAXPATHLEN)) {
       return false;
     }
     return AttemptCopyAndLaunch(src);
   }
   bool
   AttemptGRELoadAndLaunch(char* greDir)
   {
     nsresult rv;
     char xpcomDllPath[MAXPATHLEN];
     rv = joinPath(xpcomDllPath, greDir, XPCOM_DLL, MAXPATHLEN);
     NS_ENSURE_SUCCESS(rv, false);
     rv = XPCOMGlueStartup(xpcomDllPath);
     NS_ENSURE_SUCCESS(rv, false);
     rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
     NS_ENSURE_SUCCESS(rv, false);
     // NOTE: The GRE has successfully loaded, so we can use XPCOM now
     { // Scope for any XPCOM stuff we create
       ScopedLogging log;
       // Get the path to the runtime.
       char rtPath[MAXPATHLEN];
       rv = joinPath(rtPath, greDir, kWEBAPPRT_PATH, MAXPATHLEN);
       NS_ENSURE_SUCCESS(rv, false);
       // Get the path to the runtime's INI file.
       char rtIniPath[MAXPATHLEN];
       rv = joinPath(rtIniPath, rtPath, kWEBAPPRT_INI, MAXPATHLEN);
       NS_ENSURE_SUCCESS(rv, false);
       // Load the runtime's INI from its path.
       nsCOMPtr<nsIFile> rtINI;
       rv = XRE_GetFileFromPath(rtIniPath, getter_AddRefs(rtINI));
       NS_ENSURE_SUCCESS(rv, false);
       bool exists;
       rv = rtINI->Exists(&exists);
       if (NS_FAILED(rv) || !exists)
         return false;
       ScopedXREAppData webShellAppData;
       rv = webShellAppData.create(rtINI);
       NS_ENSURE_SUCCESS(rv, false);
       if (!isProfileOverridden) {
         SetAllocatedString(webShellAppData->profile, profile);
         SetAllocatedString(webShellAppData->name, profile);
       }
       nsCOMPtr<nsIFile> directory;
       rv = XRE_GetFileFromPath(rtPath, getter_AddRefs(directory));
       NS_ENSURE_SUCCESS(rv, false);
       nsCOMPtr<nsIFile> xreDir;
       rv = XRE_GetFileFromPath(greDir, getter_AddRefs(xreDir));
       NS_ENSURE_SUCCESS(rv, false);
       xreDir.forget(&webShellAppData->xreDirectory);
       NS_IF_RELEASE(webShellAppData->directory);
       directory.forget(&webShellAppData->directory);
       // There is only XUL.
       XRE_main(*pargc, *pargv, webShellAppData, 0);
     }
     return true;
   }
   bool
   AttemptLoadFromDir(char* firefoxDir)
   {
     nsresult rv;
     // Here we're going to open Firefox's application.ini
     char appIniPath[MAXPATHLEN];
     rv = joinPath(appIniPath, firefoxDir, kAPP_INI, MAXPATHLEN);
     NS_ENSURE_SUCCESS(rv, false);
     nsINIParser parser;
     rv = parser.Init(appIniPath);
     NS_ENSURE_SUCCESS(rv, false);
     // Get buildid of FF we're trying to load
     char buildid[MAXPATHLEN]; // This isn't a path, so MAXPATHLEN doesn't
                               // necessarily make sense, but it's a
                               // convenient number to use.
     rv = parser.GetString("App",
                           "BuildID",
                           buildid,
                           MAXPATHLEN);
     NS_ENSURE_SUCCESS(rv, false);
     if (0 == strcmp(buildid, NS_STRINGIFY(GRE_BUILDID))) {
       return AttemptGRELoadAndLaunch(firefoxDir);
     }
     char webAppRTExe[MAXPATHLEN];
     rv = joinPath(webAppRTExe, firefoxDir, kAPP_RT, MAXPATHLEN);
     NS_ENSURE_SUCCESS(rv, false);
     return AttemptCopyAndLaunch(webAppRTExe);
   }
   bool
   GetFirefoxDirFromRegistry(char* firefoxDir)
   {
     HKEY key;
     wchar_t wideGreDir[MAXPATHLEN];
     if (ERROR_SUCCESS !=
                 RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                               L"SOFTWARE\\Microsoft\\Windows"
                               L"\\CurrentVersion\\App paths\\firefox.exe",
 ,
                               KEY_READ,
                               &key)) {
       return false;
     }
     DWORD length = MAXPATHLEN * sizeof(wchar_t);
     // XXX: When Vista/XP64 become our minimum supported client, we can use
     //      RegGetValue instead
     if (ERROR_SUCCESS != RegQueryValueExW(key,
                                           L"Path",
                                           nullptr,
                                           nullptr,
                                           reinterpret_cast<BYTE*>(wideGreDir),
                                           &length)) {
       RegCloseKey(key);
       return false;
     };
     RegCloseKey(key);
     // According to this article, we need to write our own null terminator:
     // http://msdn.microsoft.com/en-us/library/ms724911%28v=vs.85%29.aspx
     length = length / sizeof(wchar_t);
     if (wideGreDir[length] != L'\0') {
       if (length >= MAXPATHLEN) {
         return false;
       }
       wideGreDir[length] = L'\0';
     }
     if (0 == WideCharToMultiByte(CP_UTF8,
 ,
                                  wideGreDir,
                                  -1,
                                  firefoxDir,
                                  MAXPATHLEN,
                                  nullptr,
                                  nullptr)) {
       return false;
     }
     return true;
   }
 };
 //////////////////////////////////////////////////////////////////////////////
 // main
 //
 // Note: XPCOM cannot be used until AttemptGRELoad has returned successfully.
 int
 main(int argc, char* argv[])
 {
   pargc = &argc;
   pargv = &argv;
   nsresult rv;
   char buffer[MAXPATHLEN];
   wchar_t wbuffer[MAXPATHLEN];
   // Set up curEXEPath
   if (!GetModuleFileNameW(0, wbuffer, MAXPATHLEN)) {
     Output("Couldn't calculate the application directory.");
     return 255;
   }
   wcsncpy(curExePath, wbuffer, MAXPATHLEN);
   // Get the current directory into wbuffer
   wchar_t* lastSlash = wcsrchr(wbuffer, L'\\');
   if (!lastSlash) {
     Output("Application directory format not understood.");
     return 255;
   }
   *(++lastSlash) = L'\0';
   // Set up backup file path
   if (wcslen(wbuffer) + _countof(kAPP_RT_BACKUP) >= MAXPATHLEN) {
     Output("Application directory path is too long (couldn't set up backup file path).");
   }
   wcsncpy(lastSlash, kAPP_RT_BACKUP, _countof(kAPP_RT_BACKUP));
   wcsncpy(backupFilePath, wbuffer, MAXPATHLEN);
   *lastSlash = L'\0';
   // Convert current directory to utf8 and stuff it in buffer
   if (0 == WideCharToMultiByte(CP_UTF8,
 ,
                                wbuffer,
                                -1,
                                buffer,
                                MAXPATHLEN,
                                nullptr,
                                nullptr)) {
     Output("Application directory could not be processed.");
     return 255;
   }
   // Check if the runtime was executed with the "-profile" argument
   for (int i = 1; i < argc; i++) {
     if (!strcmp(argv[i], "-profile")) {
       isProfileOverridden = true;
       break;
     }
   }
   // First attempt at loading Firefox binaries:
   //   Check if the webapprt is in the same directory as the Firefox binary.
   //   This is the case during WebappRT chrome and content tests.
   if (AttemptLoadFromDir(buffer)) {
     return 0;
   }
   // Set up appIniPath with path to webapp.ini.
   // This should be in the same directory as the running executable.
   char appIniPath[MAXPATHLEN];
   if (NS_FAILED(joinPath(appIniPath, buffer, kWEBAPP_INI, MAXPATHLEN))) {
     Output("Path to webapp.ini could not be processed.");
     return 255;
   }
   // Open webapp.ini as an INI file (as opposed to using the
   // XRE webapp.ini-specific processing we do later)
   nsINIParser parser;
   if (NS_FAILED(parser.Init(appIniPath))) {
     Output("Could not open webapp.ini");
     return 255;
   }
   // Set up our environment to know where webapp.ini was loaded from.
   char appEnv[MAXPATHLEN + _countof(kAPP_ENV_PREFIX)];
   strcpy(appEnv, kAPP_ENV_PREFIX);
   strcpy(appEnv + _countof(kAPP_ENV_PREFIX) - 1, appIniPath);
   if (putenv(appEnv)) {
     Output("Couldn't set up app environment");
     return 255;
   }
   if (!isProfileOverridden) {
     // Get profile dir from webapp.ini
     if (NS_FAILED(parser.GetString("Webapp",
                                    "Profile",
                                    profile,
                                    MAXPATHLEN))) {
       Output("Unable to retrieve profile from web app INI file");
       return 255;
     }
   }
   char firefoxDir[MAXPATHLEN];
   // Second attempt at loading Firefox binaries:
   //   Get the location of Firefox from our webapp.ini
   // XXX: This string better be UTF-8...
   rv = parser.GetString("WebappRT",
                         "InstallDir",
                         firefoxDir,
                         MAXPATHLEN);
   if (NS_SUCCEEDED(rv)) {
     if (AttemptLoadFromDir(firefoxDir)) {
       return 0;
     }
   }
   // Third attempt at loading Firefox binaries:
   //   Get the location of Firefox from the registry
   if (GetFirefoxDirFromRegistry(firefoxDir)) {
     if (AttemptLoadFromDir(firefoxDir)) {
       // XXX: Write gre dir location to webapp.ini
       return 0;
     }
   }
   // We've done all we know how to do to try to find and launch FF
   Output("This app requires that Firefox version 16 or above is installed."
          " Firefox 16+ has not been detected.");
   return 255;
 }

The Tor Browser / annotate

webapprt/win/webapprt.cpp@8bccb770b82d (annotated)

webapprt/win/webapprt.cpp