The Tor Browser: comparison webapprt/win/webapprt.cpp

--1:000000000000
+:a8bfc0987b8c
+/* -*- 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,
+0,
+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
+0,          // 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,
+0,
+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",
+0,
+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,
+0,
+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,
+0,
+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 / file comparison

comparison: webapprt/win/webapprt.cpp

webapprt/win/webapprt.cpp