/* -*- 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/. */ #include "mozilla/dom/ContentParent.h" #include "mozilla/dom/ContentChild.h" #include "mozilla/ipc/GeckoChildProcessHost.h" #include "mozilla/ArrayUtils.h" #include "mozilla/Attributes.h" #include "mozilla/FilePreferences.h" #include "mozilla/ChaosMode.h" #include "mozilla/IOInterposer.h" #include "mozilla/Likely.h" #include "mozilla/MemoryChecking.h" #include "mozilla/Poison.h" #include "mozilla/Preferences.h" #include "mozilla/ScopeExit.h" #include "mozilla/Services.h" #include "mozilla/ServoBindings.h" #include "mozilla/Telemetry.h" #include "nsAppRunner.h" #include "mozilla/AppData.h" #if defined(MOZ_UPDATER) && !defined(MOZ_WIDGET_ANDROID) #include "nsUpdateDriver.h" #endif #include "ProfileReset.h" #ifdef MOZ_INSTRUMENT_EVENT_LOOP #include "EventTracer.h" #endif #ifdef XP_MACOSX #include "nsVersionComparator.h" #include "MacLaunchHelper.h" #include "MacApplicationDelegate.h" #include "MacAutoreleasePool.h" // these are needed for sysctl #include <sys/types.h> #include <sys/sysctl.h> #endif #include "prmem.h" #include "prnetdb.h" #include "prprf.h" #include "prproces.h" #include "prenv.h" #include "prtime.h" #include "nsIAppShellService.h" #include "nsIAppStartup.h" #include "nsIAppStartupNotifier.h" #include "nsIMutableArray.h" #include "nsICategoryManager.h" #include "nsIChromeRegistry.h" #include "nsICommandLineRunner.h" #include "nsIComponentManager.h" #include "nsIComponentRegistrar.h" #include "nsIConsoleService.h" #include "nsIContentHandler.h" #include "nsIDialogParamBlock.h" #include "nsIDOMWindow.h" #include "mozilla/ModuleUtils.h" #include "nsIIOService2.h" #include "nsIObserverService.h" #include "nsINativeAppSupport.h" #include "nsIPlatformInfo.h" #include "nsIProcess.h" #include "nsIProfileUnlocker.h" #include "nsIPromptService.h" #include "nsIServiceManager.h" #include "nsIStringBundle.h" #include "nsISupportsPrimitives.h" #include "nsIToolkitChromeRegistry.h" #include "nsIToolkitProfile.h" #include "nsIToolkitProfileService.h" #include "nsIURI.h" #include "nsIURL.h" #include "nsIWindowCreator.h" #include "nsIWindowMediator.h" #include "nsIWindowWatcher.h" #include "nsIXULAppInfo.h" #include "nsIXULRuntime.h" #include "nsPIDOMWindow.h" #include "nsIBaseWindow.h" #include "nsIWidget.h" #include "nsIDocShell.h" #include "nsAppShellCID.h" #include "mozilla/scache/StartupCache.h" #include "gfxPrefs.h" #include "mozilla/Unused.h" #ifdef XP_WIN #include "nsIWinAppHelper.h" #include <windows.h> #include <intrin.h> #include <math.h> #include "cairo/cairo-features.h" #include "mozilla/mscom/MainThreadRuntime.h" #include "mozilla/widget/AudioSession.h" #ifndef PROCESS_DEP_ENABLE #define PROCESS_DEP_ENABLE 0x1 #endif #endif #ifdef ACCESSIBILITY #include "nsAccessibilityService.h" #if defined(XP_WIN) #include "mozilla/a11y/Compatibility.h" #endif #endif #include "nsCRT.h" #include "nsCOMPtr.h" #include "nsDirectoryServiceDefs.h" #include "nsDirectoryServiceUtils.h" #include "nsEmbedCID.h" #include "nsNetUtil.h" #include "nsReadableUtils.h" #include "nsXPCOM.h" #include "nsXPCOMCIDInternal.h" #include "nsXPIDLString.h" #include "nsPrintfCString.h" #include "nsVersionComparator.h" #include "nsAppDirectoryServiceDefs.h" #include "nsXULAppAPI.h" #include "nsXREDirProvider.h" #include "nsToolkitCompsCID.h" #include "nsINIParser.h" #include "mozilla/Omnijar.h" #include "mozilla/StartupTimeline.h" #include "mozilla/LateWriteChecks.h" #include <stdlib.h> #include <locale.h> #ifdef XP_UNIX #include <sys/stat.h> #include <unistd.h> #include <pwd.h> #endif #ifdef XP_WIN #include <process.h> #include <shlobj.h> #include "nsThreadUtils.h" #include <comdef.h> #include <wbemidl.h> #include "WinUtils.h" #endif #ifdef XP_MACOSX #include "nsILocalFileMac.h" #include "nsCommandLineServiceMac.h" #endif // for X remote support #ifdef MOZ_ENABLE_XREMOTE #include "XRemoteClient.h" #include "nsIRemoteService.h" #include "nsProfileLock.h" #include "SpecialSystemDirectory.h" #include <sched.h> // Time to wait for the remoting service to start #define MOZ_XREMOTE_START_TIMEOUT_SEC 5 #endif #if defined(DEBUG) && defined(XP_WIN32) #include <malloc.h> #endif #if defined (XP_MACOSX) #include <Carbon/Carbon.h> #endif #ifdef DEBUG #include "mozilla/Logging.h" #endif #include "base/command_line.h" #include "GTestRunner.h" #ifdef MOZ_WIDGET_ANDROID #include "GeneratedJNIWrappers.h" #endif extern uint32_t gRestartMode; extern void InstallSignalHandlers(const char *ProgramName); #define FILE_COMPATIBILITY_INFO NS_LITERAL_CSTRING("compatibility.ini") #define FILE_INVALIDATE_CACHES NS_LITERAL_CSTRING(".purgecaches") int gArgc; char **gArgv; static const char gToolkitVersion[] = NS_STRINGIFY(GRE_MILESTONE); static const char gToolkitBuildID[] = NS_STRINGIFY(MOZ_BUILDID); static nsIProfileLock* gProfileLock; int gRestartArgc; char **gRestartArgv; bool gIsGtest = false; nsString gAbsoluteArgv0Path; #if defined(MOZ_WIDGET_GTK) #include <glib.h> #if defined(DEBUG) || defined(NS_BUILD_REFCNT_LOGGING) #define CLEANUP_MEMORY 1 #define PANGO_ENABLE_BACKEND #include <pango/pangofc-fontmap.h> #endif #include <gtk/gtk.h> #ifdef MOZ_X11 #include <gdk/gdkx.h> #endif /* MOZ_X11 */ #include "nsGTKToolkit.h" #include <fontconfig/fontconfig.h> #endif #include "BinaryPath.h" #ifndef MOZ_BUILDID // See comment in Makefile.in why we want to avoid including buildid.h. // Still include it when MOZ_BUILDID is not set, which can happen with some // build backends. #include "buildid.h" #endif #ifdef MOZ_LINKER extern "C" MFBT_API bool IsSignalHandlingBroken(); #endif #ifdef LIBFUZZER #include "LibFuzzerRunner.h" namespace mozilla { LibFuzzerRunner* libFuzzerRunner = 0; } // namespace mozilla extern "C" MOZ_EXPORT void XRE_LibFuzzerSetMain(int argc, char** argv, LibFuzzerMain main) { mozilla::libFuzzerRunner->setParams(argc, argv, main); } #endif namespace mozilla { int (*RunGTest)() = 0; } // namespace mozilla using namespace mozilla; using mozilla::Unused; using mozilla::scache::StartupCache; using mozilla::dom::ContentParent; using mozilla::dom::ContentChild; // Save literal putenv string to environment variable. static void SaveToEnv(const char *putenv) { char *expr = strdup(putenv); if (expr) PR_SetEnv(expr); // We intentionally leak |expr| here since it is required by PR_SetEnv. MOZ_LSAN_INTENTIONALLY_LEAK_OBJECT(expr); } // Tests that an environment variable exists and has a value static bool EnvHasValue(const char *name) { const char *val = PR_GetEnv(name); return (val && *val); } // Save the given word to the specified environment variable. static void SaveWordToEnv(const char *name, const nsACString & word) { char *expr = PR_smprintf("%s=%s", name, PromiseFlatCString(word).get()); if (expr) PR_SetEnv(expr); // We intentionally leak |expr| here since it is required by PR_SetEnv. } // Save the path of the given file to the specified environment variable. static void SaveFileToEnv(const char *name, nsIFile *file) { #ifdef XP_WIN nsAutoString path; file->GetPath(path); SetEnvironmentVariableW(NS_ConvertASCIItoUTF16(name).get(), path.get()); #else nsAutoCString path; file->GetNativePath(path); SaveWordToEnv(name, path); #endif } // Load the path of a file saved with SaveFileToEnv static already_AddRefed<nsIFile> GetFileFromEnv(const char *name) { nsresult rv; nsCOMPtr<nsIFile> file; #ifdef XP_WIN WCHAR path[_MAX_PATH]; if (!GetEnvironmentVariableW(NS_ConvertASCIItoUTF16(name).get(), path, _MAX_PATH)) return nullptr; rv = NS_NewLocalFile(nsDependentString(path), true, getter_AddRefs(file)); if (NS_FAILED(rv)) return nullptr; return file.forget(); #else const char *arg = PR_GetEnv(name); if (!arg || !*arg) return nullptr; rv = NS_NewNativeLocalFile(nsDependentCString(arg), true, getter_AddRefs(file)); if (NS_FAILED(rv)) return nullptr; return file.forget(); #endif } // Save the path of the given word to the specified environment variable // provided the environment variable does not have a value. static void SaveWordToEnvIfUnset(const char *name, const nsACString & word) { if (!EnvHasValue(name)) SaveWordToEnv(name, word); } // Save the path of the given file to the specified environment variable // provided the environment variable does not have a value. static void SaveFileToEnvIfUnset(const char *name, nsIFile *file) { if (!EnvHasValue(name)) SaveFileToEnv(name, file); } static bool strimatch(const char* lowerstr, const char* mixedstr) { while(*lowerstr) { if (!*mixedstr) return false; // mixedstr is shorter if (tolower(*mixedstr) != *lowerstr) return false; // no match ++lowerstr; ++mixedstr; } if (*mixedstr) return false; // lowerstr is shorter return true; } static bool gIsExpectedExit = false; void MozExpectedExit() { gIsExpectedExit = true; } /** * Runs atexit() to catch unexpected exit from 3rd party libraries like the * Intel graphics driver calling exit in an error condition. When they * call exit() to report an error we won't shutdown correctly and wont catch * the issue with our crash reporter. */ static void UnexpectedExit() { if (!gIsExpectedExit) { gIsExpectedExit = true; // Don't risk re-entrency issues when crashing. MOZ_CRASH("Exit called by third party code."); } } /** * Output a string to the user. This method is really only meant to be used to * output last-ditch error messages designed for developers NOT END USERS. * * @param isError * Pass true to indicate severe errors. * @param fmt * printf-style format string followed by arguments. */ static void Output(bool isError, const char *fmt, ... ) { va_list ap; va_start(ap, fmt); #if defined(XP_WIN) && !MOZ_WINCONSOLE char *msg = PR_vsmprintf(fmt, ap); if (msg) { UINT flags = MB_OK; if (isError) flags |= MB_ICONERROR; else flags |= MB_ICONINFORMATION; wchar_t wide_msg[1024]; MultiByteToWideChar(CP_ACP, 0, msg, -1, wide_msg, sizeof(wide_msg) / sizeof(wchar_t)); MessageBoxW(nullptr, wide_msg, L"XULRunner", flags); PR_smprintf_free(msg); } #else vfprintf(stderr, fmt, ap); #endif va_end(ap); } enum RemoteResult { REMOTE_NOT_FOUND = 0, REMOTE_FOUND = 1, REMOTE_ARG_BAD = 2 }; enum ArgResult { ARG_NONE = 0, ARG_FOUND = 1, ARG_BAD = 2 // you wanted a param, but there isn't one }; static void RemoveArg(char **argv) { do { *argv = *(argv + 1); ++argv; } while (*argv); --gArgc; } /** * Check for a commandline flag. If the flag takes a parameter, the * parameter is returned in aParam. Flags may be in the form -arg or * --arg (or /arg on win32). * * @param aArg the parameter to check. Must be lowercase. * @param aCheckOSInt if true returns ARG_BAD if the osint argument is present * when aArg is also present. * @param aParam if non-null, the -arg <data> will be stored in this pointer. * This is *not* allocated, but rather a pointer to the argv data. * @param aRemArg if true, the argument is removed from the gArgv array. */ static ArgResult CheckArg(const char* aArg, bool aCheckOSInt = false, const char **aParam = nullptr, bool aRemArg = true) { MOZ_ASSERT(gArgv, "gArgv must be initialized before CheckArg()"); char **curarg = gArgv + 1; // skip argv[0] ArgResult ar = ARG_NONE; while (*curarg) { char *arg = curarg[0]; if (arg[0] == '-' #if defined(XP_WIN) || *arg == '/' #endif ) { ++arg; if (*arg == '-') ++arg; if (strimatch(aArg, arg)) { if (aRemArg) RemoveArg(curarg); else ++curarg; if (!aParam) { ar = ARG_FOUND; break; } if (*curarg) { if (**curarg == '-' #if defined(XP_WIN) || **curarg == '/' #endif ) return ARG_BAD; *aParam = *curarg; if (aRemArg) RemoveArg(curarg); ar = ARG_FOUND; break; } return ARG_BAD; } } ++curarg; } if (aCheckOSInt && ar == ARG_FOUND) { ArgResult arOSInt = CheckArg("osint"); if (arOSInt == ARG_FOUND) { ar = ARG_BAD; PR_fprintf(PR_STDERR, "Error: argument --osint is invalid\n"); } } return ar; } #if defined(XP_WIN) /** * Check for a commandline flag from the windows shell and remove it from the * argv used when restarting. Flags MUST be in the form -arg. * * @param aArg the parameter to check. Must be lowercase. */ static ArgResult CheckArgShell(const char* aArg) { char **curarg = gRestartArgv + 1; // skip argv[0] while (*curarg) { char *arg = curarg[0]; if (arg[0] == '-') { ++arg; if (strimatch(aArg, arg)) { do { *curarg = *(curarg + 1); ++curarg; } while (*curarg); --gRestartArgc; return ARG_FOUND; } } ++curarg; } return ARG_NONE; } /** * Enabled Native App Support to process DDE messages when the app needs to * restart and the app has been launched by the Windows shell to open an url. * When aWait is false this will process the DDE events manually. This prevents * Windows from displaying an error message due to the DDE message not being * acknowledged. */ static void ProcessDDE(nsINativeAppSupport* aNative, bool aWait) { // When the app is launched by the windows shell the windows shell // expects the app to be available for DDE messages and if it isn't // windows displays an error dialog. To prevent the error the DDE server // is enabled and pending events are processed when the app needs to // restart after it was launched by the shell with the requestpending // argument. The requestpending pending argument is removed to // differentiate it from being launched when an app restart is not // required. ArgResult ar; ar = CheckArgShell("requestpending"); if (ar == ARG_FOUND) { aNative->Enable(); // enable win32 DDE responses if (aWait) { nsIThread *thread = NS_GetCurrentThread(); // This is just a guesstimate based on testing different values. // If count is 8 or less windows will display an error dialog. int32_t count = 20; while(--count >= 0) { NS_ProcessNextEvent(thread); PR_Sleep(PR_MillisecondsToInterval(1)); } } } } #endif /** * Determines if there is support for showing the profile manager * * @return true in all environments */ static bool CanShowProfileManager() { return true; } bool gSafeMode = false; /** * The nsXULAppInfo object implements nsIFactory so that it can be its own * singleton. */ class nsXULAppInfo : public nsIXULAppInfo, public nsIObserver, #ifdef XP_WIN public nsIWinAppHelper, #endif public nsIXULRuntime { public: constexpr nsXULAppInfo() {} NS_DECL_ISUPPORTS_INHERITED NS_DECL_NSIPLATFORMINFO NS_DECL_NSIXULAPPINFO NS_DECL_NSIXULRUNTIME NS_DECL_NSIOBSERVER #ifdef XP_WIN NS_DECL_NSIWINAPPHELPER #endif }; NS_INTERFACE_MAP_BEGIN(nsXULAppInfo) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXULRuntime) NS_INTERFACE_MAP_ENTRY(nsIXULRuntime) NS_INTERFACE_MAP_ENTRY(nsIObserver) #ifdef XP_WIN NS_INTERFACE_MAP_ENTRY(nsIWinAppHelper) #endif NS_INTERFACE_MAP_ENTRY(nsIPlatformInfo) NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIXULAppInfo, gAppData || XRE_IsContentProcess()) NS_INTERFACE_MAP_END NS_IMETHODIMP_(MozExternalRefCountType) nsXULAppInfo::AddRef() { return 1; } NS_IMETHODIMP_(MozExternalRefCountType) nsXULAppInfo::Release() { return 1; } NS_IMETHODIMP nsXULAppInfo::GetVendor(nsACString& aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); aResult = cc->GetAppInfo().vendor; return NS_OK; } aResult.Assign(gAppData->vendor); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetName(nsACString& aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); aResult = cc->GetAppInfo().name; return NS_OK; } aResult.Assign(gAppData->name); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetID(nsACString& aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); aResult = cc->GetAppInfo().ID; return NS_OK; } aResult.Assign(gAppData->ID); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetVersion(nsACString& aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); aResult = cc->GetAppInfo().version; return NS_OK; } aResult.Assign(gAppData->version); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetPlatformVersion(nsACString& aResult) { aResult.Assign(gToolkitVersion); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetAppBuildID(nsACString& aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); aResult = cc->GetAppInfo().buildID; return NS_OK; } aResult.Assign(gAppData->buildID); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetPlatformBuildID(nsACString& aResult) { aResult.Assign(gToolkitBuildID); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetUAName(nsACString& aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); aResult = cc->GetAppInfo().UAName; return NS_OK; } aResult.Assign(gAppData->UAName); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetLogConsoleErrors(bool *aResult) { *aResult = gLogConsoleErrors; return NS_OK; } NS_IMETHODIMP nsXULAppInfo::SetLogConsoleErrors(bool aValue) { gLogConsoleErrors = aValue; return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetInSafeMode(bool *aResult) { *aResult = gSafeMode; return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetOS(nsACString& aResult) { aResult.AssignLiteral(OS_TARGET); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetXPCOMABI(nsACString& aResult) { #ifdef TARGET_XPCOM_ABI aResult.AssignLiteral(TARGET_XPCOM_ABI); return NS_OK; #else return NS_ERROR_NOT_AVAILABLE; #endif } NS_IMETHODIMP nsXULAppInfo::GetWidgetToolkit(nsACString& aResult) { aResult.AssignLiteral(MOZ_WIDGET_TOOLKIT); return NS_OK; } // Ensure that the GeckoProcessType enum, defined in xpcom/build/nsXULAppAPI.h, // is synchronized with the const unsigned longs defined in // xpcom/system/nsIXULRuntime.idl. #define SYNC_ENUMS(a,b) \ static_assert(nsIXULRuntime::PROCESS_TYPE_ ## a == \ static_cast<int>(GeckoProcessType_ ## b), \ "GeckoProcessType in nsXULAppAPI.h not synchronized with nsIXULRuntime.idl"); SYNC_ENUMS(DEFAULT, Default) SYNC_ENUMS(PLUGIN, Plugin) SYNC_ENUMS(CONTENT, Content) SYNC_ENUMS(IPDLUNITTEST, IPDLUnitTest) SYNC_ENUMS(GMPLUGIN, GMPlugin) SYNC_ENUMS(GPU, GPU) // .. and ensure that that is all of them: static_assert(GeckoProcessType_GPU + 1 == GeckoProcessType_End, "Did not find the final GeckoProcessType"); NS_IMETHODIMP nsXULAppInfo::GetProcessType(uint32_t* aResult) { NS_ENSURE_ARG_POINTER(aResult); *aResult = XRE_GetProcessType(); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetProcessID(uint32_t* aResult) { #ifdef XP_WIN *aResult = GetCurrentProcessId(); #else *aResult = getpid(); #endif return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetUniqueProcessID(uint64_t* aResult) { if (XRE_IsContentProcess()) { ContentChild* cc = ContentChild::GetSingleton(); *aResult = cc->GetID(); } else { *aResult = 0; } return NS_OK; } static bool gBrowserTabsRemoteAutostart = false; static uint64_t gBrowserTabsRemoteStatus = 0; static bool gBrowserTabsRemoteAutostartInitialized = false; static bool gMultiprocessBlockPolicyInitialized = false; static uint32_t gMultiprocessBlockPolicy = 0; NS_IMETHODIMP nsXULAppInfo::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) { if (!nsCRT::strcmp(aTopic, "getE10SBlocked")) { nsCOMPtr<nsISupportsPRUint64> ret = do_QueryInterface(aSubject); if (!ret) return NS_ERROR_FAILURE; ret->SetData(gBrowserTabsRemoteStatus); return NS_OK; } return NS_ERROR_FAILURE; } NS_IMETHODIMP nsXULAppInfo::GetBrowserTabsRemoteAutostart(bool* aResult) { *aResult = BrowserTabsRemoteAutostart(); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetMultiprocessBlockPolicy(uint32_t* aResult) { *aResult = MultiprocessBlockPolicy(); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetAccessibilityEnabled(bool* aResult) { #ifdef ACCESSIBILITY *aResult = GetAccService() != nullptr; #else *aResult = false; #endif return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetIs64Bit(bool* aResult) { #ifdef HAVE_64BIT_BUILD *aResult = true; #else *aResult = false; #endif return NS_OK; } NS_IMETHODIMP nsXULAppInfo::EnsureContentProcess() { if (!XRE_IsParentProcess()) return NS_ERROR_NOT_AVAILABLE; RefPtr<ContentParent> unused = ContentParent::GetNewOrUsedBrowserProcess(); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::InvalidateCachesOnRestart() { nsCOMPtr<nsIFile> file; nsresult rv = NS_GetSpecialDirectory(NS_APP_PROFILE_DIR_STARTUP, getter_AddRefs(file)); if (NS_FAILED(rv)) return rv; if (!file) return NS_ERROR_NOT_AVAILABLE; file->AppendNative(FILE_COMPATIBILITY_INFO); nsINIParser parser; rv = parser.Init(file); if (NS_FAILED(rv)) { // This fails if compatibility.ini is not there, so we'll // flush the caches on the next restart anyways. return NS_OK; } nsAutoCString buf; rv = parser.GetString("Compatibility", "InvalidateCaches", buf); if (NS_FAILED(rv)) { PRFileDesc *fd; rv = file->OpenNSPRFileDesc(PR_RDWR | PR_APPEND, 0600, &fd); if (NS_FAILED(rv)) { NS_ERROR("could not create output stream"); return NS_ERROR_NOT_AVAILABLE; } static const char kInvalidationHeader[] = NS_LINEBREAK "InvalidateCaches=1" NS_LINEBREAK; PR_Write(fd, kInvalidationHeader, sizeof(kInvalidationHeader) - 1); PR_Close(fd); } return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetReplacedLockTime(PRTime *aReplacedLockTime) { if (!gProfileLock) return NS_ERROR_NOT_AVAILABLE; gProfileLock->GetReplacedLockTime(aReplacedLockTime); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetLastRunCrashID(nsAString &aLastRunCrashID) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsXULAppInfo::GetIsReleaseOrBeta(bool* aResult) { #ifdef RELEASE_OR_BETA *aResult = true; #else *aResult = false; #endif return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetIsOfficialBranding(bool* aResult) { #ifdef MOZ_OFFICIAL_BRANDING *aResult = true; #else *aResult = false; #endif return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetDefaultUpdateChannel(nsACString& aResult) { aResult.AssignLiteral(NS_STRINGIFY(MOZ_UPDATE_CHANNEL)); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetDistributionID(nsACString& aResult) { aResult.AssignLiteral(MOZ_DISTRIBUTION_ID); return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetIsOfficial(bool* aResult) { #ifdef MC_OFFICIAL *aResult = true; #else *aResult = false; #endif return NS_OK; } NS_IMETHODIMP nsXULAppInfo::GetWindowsDLLBlocklistStatus(bool* aResult) { #if defined(XP_WIN) *aResult = gAppData->flags & NS_XRE_DLL_BLOCKLIST_ENABLED; #else *aResult = false; #endif return NS_OK; } #ifdef XP_WIN // Matches the enum in WinNT.h for the Vista SDK but renamed so that we can // safely build with the Vista SDK and without it. typedef enum { VistaTokenElevationTypeDefault = 1, VistaTokenElevationTypeFull, VistaTokenElevationTypeLimited } VISTA_TOKEN_ELEVATION_TYPE; // avoid collision with TokeElevationType enum in WinNT.h // of the Vista SDK #define VistaTokenElevationType static_cast< TOKEN_INFORMATION_CLASS >( 18 ) NS_IMETHODIMP nsXULAppInfo::GetUserCanElevate(bool *aUserCanElevate) { HANDLE hToken; VISTA_TOKEN_ELEVATION_TYPE elevationType; DWORD dwSize; if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken) || !GetTokenInformation(hToken, VistaTokenElevationType, &elevationType, sizeof(elevationType), &dwSize)) { *aUserCanElevate = false; } else { // The possible values returned for elevationType and their meanings are: // TokenElevationTypeDefault: The token does not have a linked token // (e.g. UAC disabled or a standard user, so they can't be elevated) // TokenElevationTypeFull: The token is linked to an elevated token // (e.g. UAC is enabled and the user is already elevated so they can't // be elevated again) // TokenElevationTypeLimited: The token is linked to a limited token // (e.g. UAC is enabled and the user is not elevated, so they can be // elevated) *aUserCanElevate = (elevationType == VistaTokenElevationTypeLimited); } if (hToken) CloseHandle(hToken); return NS_OK; } #endif static const nsXULAppInfo kAppInfo; static nsresult AppInfoConstructor(nsISupports* aOuter, REFNSIID aIID, void **aResult) { NS_ENSURE_NO_AGGREGATION(aOuter); return const_cast<nsXULAppInfo*>(&kAppInfo)-> QueryInterface(aIID, aResult); } bool gLogConsoleErrors = false; #define NS_ENSURE_TRUE_LOG(x, ret) \ PR_BEGIN_MACRO \ if (MOZ_UNLIKELY(!(x))) { \ NS_WARNING("NS_ENSURE_TRUE(" #x ") failed"); \ gLogConsoleErrors = true; \ return ret; \ } \ PR_END_MACRO #define NS_ENSURE_SUCCESS_LOG(res, ret) \ NS_ENSURE_TRUE_LOG(NS_SUCCEEDED(res), ret) /** * Because we're starting/stopping XPCOM several times in different scenarios, * this class is a stack-based critter that makes sure that XPCOM is shut down * during early returns. */ class ScopedXPCOMStartup { public: ScopedXPCOMStartup() : mServiceManager(nullptr) { } ~ScopedXPCOMStartup(); nsresult Initialize(); nsresult SetWindowCreator(nsINativeAppSupport* native); static nsresult CreateAppSupport(nsISupports* aOuter, REFNSIID aIID, void** aResult); private: nsIServiceManager* mServiceManager; static nsINativeAppSupport* gNativeAppSupport; }; ScopedXPCOMStartup::~ScopedXPCOMStartup() { NS_IF_RELEASE(gNativeAppSupport); if (mServiceManager) { #ifdef XP_MACOSX // On OS X, we need a pool to catch cocoa objects that are autoreleased // during teardown. mozilla::MacAutoreleasePool pool; #endif nsCOMPtr<nsIAppStartup> appStartup (do_GetService(NS_APPSTARTUP_CONTRACTID)); if (appStartup) appStartup->DestroyHiddenWindow(); gDirServiceProvider->DoShutdown(); PROFILER_MARKER("Shutdown early"); WriteConsoleLog(); NS_ShutdownXPCOM(mServiceManager); mServiceManager = nullptr; } } // {95d89e3e-a169-41a3-8e56-719978e15b12} #define APPINFO_CID \ { 0x95d89e3e, 0xa169, 0x41a3, { 0x8e, 0x56, 0x71, 0x99, 0x78, 0xe1, 0x5b, 0x12 } } // {0C4A446C-EE82-41f2-8D04-D366D2C7A7D4} static const nsCID kNativeAppSupportCID = { 0xc4a446c, 0xee82, 0x41f2, { 0x8d, 0x4, 0xd3, 0x66, 0xd2, 0xc7, 0xa7, 0xd4 } }; // {5F5E59CE-27BC-47eb-9D1F-B09CA9049836} static const nsCID kProfileServiceCID = { 0x5f5e59ce, 0x27bc, 0x47eb, { 0x9d, 0x1f, 0xb0, 0x9c, 0xa9, 0x4, 0x98, 0x36 } }; static already_AddRefed<nsIFactory> ProfileServiceFactoryConstructor(const mozilla::Module& module, const mozilla::Module::CIDEntry& entry) { nsCOMPtr<nsIFactory> factory; NS_NewToolkitProfileFactory(getter_AddRefs(factory)); return factory.forget(); } NS_DEFINE_NAMED_CID(APPINFO_CID); static const mozilla::Module::CIDEntry kXRECIDs[] = { { &kAPPINFO_CID, false, nullptr, AppInfoConstructor }, { &kProfileServiceCID, false, ProfileServiceFactoryConstructor, nullptr }, { &kNativeAppSupportCID, false, nullptr, ScopedXPCOMStartup::CreateAppSupport }, { nullptr } }; static const mozilla::Module::ContractIDEntry kXREContracts[] = { { XULAPPINFO_SERVICE_CONTRACTID, &kAPPINFO_CID }, { XULRUNTIME_SERVICE_CONTRACTID, &kAPPINFO_CID }, { NS_PROFILESERVICE_CONTRACTID, &kProfileServiceCID }, { NS_NATIVEAPPSUPPORT_CONTRACTID, &kNativeAppSupportCID }, { nullptr } }; static const mozilla::Module kXREModule = { mozilla::Module::kVersion, kXRECIDs, kXREContracts }; NSMODULE_DEFN(Apprunner) = &kXREModule; nsresult ScopedXPCOMStartup::Initialize() { NS_ASSERTION(gDirServiceProvider, "Should not get here!"); nsresult rv; rv = NS_InitXPCOM2(&mServiceManager, gDirServiceProvider->GetAppDir(), gDirServiceProvider); if (NS_FAILED(rv)) { NS_ERROR("Couldn't start xpcom!"); mServiceManager = nullptr; } else { #ifdef DEBUG nsCOMPtr<nsIComponentRegistrar> reg = do_QueryInterface(mServiceManager); NS_ASSERTION(reg, "Service Manager doesn't QI to Registrar."); #endif } return rv; } /** * This is a little factory class that serves as a singleton-service-factory * for the nativeappsupport object. */ class nsSingletonFactory final : public nsIFactory { public: NS_DECL_ISUPPORTS NS_DECL_NSIFACTORY explicit nsSingletonFactory(nsISupports* aSingleton); private: ~nsSingletonFactory() { } nsCOMPtr<nsISupports> mSingleton; }; nsSingletonFactory::nsSingletonFactory(nsISupports* aSingleton) : mSingleton(aSingleton) { NS_ASSERTION(mSingleton, "Singleton was null!"); } NS_IMPL_ISUPPORTS(nsSingletonFactory, nsIFactory) NS_IMETHODIMP nsSingletonFactory::CreateInstance(nsISupports* aOuter, const nsIID& aIID, void* *aResult) { NS_ENSURE_NO_AGGREGATION(aOuter); return mSingleton->QueryInterface(aIID, aResult); } NS_IMETHODIMP nsSingletonFactory::LockFactory(bool) { return NS_OK; } /** * Set our windowcreator on the WindowWatcher service. */ nsresult ScopedXPCOMStartup::SetWindowCreator(nsINativeAppSupport* native) { nsresult rv; NS_IF_ADDREF(gNativeAppSupport = native); // Inform the chrome registry about OS accessibility nsCOMPtr<nsIToolkitChromeRegistry> cr = mozilla::services::GetToolkitChromeRegistryService(); if (cr) cr->CheckForOSAccessibility(); nsCOMPtr<nsIWindowCreator> creator (do_GetService(NS_APPSTARTUP_CONTRACTID)); if (!creator) return NS_ERROR_UNEXPECTED; nsCOMPtr<nsIWindowWatcher> wwatch (do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); return wwatch->SetWindowCreator(creator); } /* static */ nsresult ScopedXPCOMStartup::CreateAppSupport(nsISupports* aOuter, REFNSIID aIID, void** aResult) { if (aOuter) return NS_ERROR_NO_AGGREGATION; if (!gNativeAppSupport) return NS_ERROR_NOT_INITIALIZED; return gNativeAppSupport->QueryInterface(aIID, aResult); } nsINativeAppSupport* ScopedXPCOMStartup::gNativeAppSupport; static void DumpArbitraryHelp() { nsresult rv; ScopedLogging log; { ScopedXPCOMStartup xpcom; xpcom.Initialize(); nsCOMPtr<nsICommandLineRunner> cmdline (do_CreateInstance("@mozilla.org/toolkit/command-line;1")); if (!cmdline) return; nsCString text; rv = cmdline->GetHelpText(text); if (NS_SUCCEEDED(rv)) printf("%s", text.get()); } } // English text needs to go into a dtd file. // But when this is called we have no components etc. These strings must either be // here, or in a native resource file. static void DumpHelp() { printf("Usage: %s [ options ... ] [URL]\n" " where options include:\n\n", gArgv[0]); #ifdef MOZ_X11 printf("X11 options\n" " --display=DISPLAY X display to use.\n" " --sync Make X calls synchronous.\n"); #endif #ifdef XP_UNIX printf(" --g-fatal-warnings Make all warnings fatal.\n" "\n%s options\n", gAppData->name); #endif printf(" -h or --help Print this message.\n" " -v or --version Print %s version.\n" " -P <profile> Start with <profile>.\n" " --profile <path> Start with profile at <path>.\n" #ifdef MC_BASILISK " --migration Start with migration wizard.\n" #endif " --ProfileManager Start with ProfileManager.\n" " --no-remote Do not accept or send remote commands;\n" " implies --new-instance.\n" " --new-instance Open new instance, not a new window\n" " in running instance.\n" " --UILocale <locale> Start with <locale> resources as UI Locale.\n" " --safe-mode Disables extensions and themes for this session.\n", (const char*) gAppData->name); #if defined(XP_WIN) printf(" --console Start %s with a debugging console.\n", (const char*) gAppData->name); #endif // this works, but only after the components have registered. so if you drop in a new command line handler, --help // won't not until the second run. // out of the bug, because we ship a component.reg file, it works correctly. DumpArbitraryHelp(); } #if defined(DEBUG) && defined(XP_WIN) #ifdef DEBUG_warren #define _CRTDBG_MAP_ALLOC #endif // Set a CRT ReportHook function to capture and format MSCRT // warnings, errors and assertions. // See http://msdn.microsoft.com/en-US/library/74kabxyx(v=VS.80).aspx #include <stdio.h> #include <crtdbg.h> #include "mozilla/mozalloc_abort.h" static int MSCRTReportHook( int aReportType, char *aMessage, int *oReturnValue) { *oReturnValue = 0; // continue execution // Do not use fprintf or other functions which may allocate // memory from the heap which may be corrupted. Instead, // use fputs to output the leading portion of the message // and use mozalloc_abort to emit the remainder of the // message. switch(aReportType) { case 0: fputs("\nWARNING: CRT WARNING", stderr); fputs(aMessage, stderr); fputs("\n", stderr); break; case 1: fputs("\n###!!! ABORT: CRT ERROR ", stderr); mozalloc_abort(aMessage); break; case 2: fputs("\n###!!! ABORT: CRT ASSERT ", stderr); mozalloc_abort(aMessage); break; } // do not invoke the debugger return 1; } #endif static inline void DumpVersion() { if (gAppData->vendor) printf("%s ", gAppData->vendor); printf("%s %s", gAppData->name, gAppData->version); if (gAppData->copyright) printf(", %s", gAppData->copyright); printf("\n"); } #ifdef MOZ_ENABLE_XREMOTE static RemoteResult ParseRemoteCommandLine(nsCString& program, const char** profile, const char** username) { ArgResult ar; ar = CheckArg("p", false, profile, false); if (ar == ARG_BAD) { // Leave it to the normal command line handling to handle this situation. return REMOTE_NOT_FOUND; } const char *temp = nullptr; ar = CheckArg("a", true, &temp); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument -a requires an application name\n"); return REMOTE_ARG_BAD; } else if (ar == ARG_FOUND) { program.Assign(temp); } ar = CheckArg("u", true, username); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument -u requires a username\n"); return REMOTE_ARG_BAD; } return REMOTE_FOUND; } static RemoteResult StartRemoteClient(const char* aDesktopStartupID, nsCString& program, const char* profile, const char* username) { XRemoteClient client; nsresult rv = client.Init(); if (NS_FAILED(rv)) return REMOTE_NOT_FOUND; nsXPIDLCString response; bool success = false; rv = client.SendCommandLine(program.get(), username, profile, gArgc, gArgv, aDesktopStartupID, getter_Copies(response), &success); // did the command fail? if (!success) return REMOTE_NOT_FOUND; // The "command not parseable" error is returned when the // nsICommandLineHandler throws a NS_ERROR_ABORT. if (response.EqualsLiteral("500 command not parseable")) return REMOTE_ARG_BAD; if (NS_FAILED(rv)) return REMOTE_NOT_FOUND; return REMOTE_FOUND; } #endif // MOZ_ENABLE_XREMOTE void XRE_InitOmnijar(nsIFile* greOmni, nsIFile* appOmni) { mozilla::Omnijar::Init(greOmni, appOmni); } nsresult XRE_GetBinaryPath(const char* argv0, nsIFile* *aResult) { return mozilla::BinaryPath::GetFile(argv0, aResult); } #ifdef XP_WIN #include "nsWindowsRestart.cpp" #include <shellapi.h> typedef BOOL (WINAPI* SetProcessDEPPolicyFunc)(DWORD dwFlags); #endif // If aBlankCommandLine is true, then the application will be launched with a // blank command line instead of being launched with the same command line that // it was initially started with. static nsresult LaunchChild(nsINativeAppSupport* aNative, bool aBlankCommandLine = false) { aNative->Quit(); // release DDE mutex, if we're holding it // Restart this process by exec'ing it into the current process // if supported by the platform. Otherwise, use NSPR. if (aBlankCommandLine) { gRestartArgc = 1; gRestartArgv[gRestartArgc] = nullptr; } SaveToEnv("MOZ_LAUNCHED_CHILD=1"); #if defined(MOZ_WIDGET_ANDROID) java::GeckoAppShell::ScheduleRestart(); #else #if defined(XP_MACOSX) CommandLineServiceMac::SetupMacCommandLine(gRestartArgc, gRestartArgv, true); LaunchChildMac(gRestartArgc, gRestartArgv); #else nsCOMPtr<nsIFile> lf; nsresult rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf)); if (NS_FAILED(rv)) return rv; #if defined(XP_WIN) nsAutoString exePath; rv = lf->GetPath(exePath); if (NS_FAILED(rv)) return rv; if (!WinLaunchChild(exePath.get(), gRestartArgc, gRestartArgv)) return NS_ERROR_FAILURE; #else nsAutoCString exePath; rv = lf->GetNativePath(exePath); if (NS_FAILED(rv)) return rv; #if defined(XP_UNIX) if (execv(exePath.get(), gRestartArgv) == -1) return NS_ERROR_FAILURE; #else PRProcess* process = PR_CreateProcess(exePath.get(), gRestartArgv, nullptr, nullptr); if (!process) return NS_ERROR_FAILURE; int32_t exitCode; PRStatus failed = PR_WaitProcess(process, &exitCode); if (failed || exitCode) return NS_ERROR_FAILURE; #endif // XP_UNIX #endif // WP_WIN #endif // WP_MACOSX #endif // MOZ_WIDGET_ANDROID return NS_ERROR_LAUNCHED_CHILD_PROCESS; } static const char kProfileProperties[] = "chrome://mozapps/locale/profile/profileSelection.properties"; namespace { /** * This class, instead of a raw nsresult, should be the return type of any * function called by SelectProfile that initializes XPCOM. */ class ReturnAbortOnError { public: MOZ_IMPLICIT ReturnAbortOnError(nsresult aRv) { mRv = ConvertRv(aRv); } operator nsresult() { return mRv; } private: inline nsresult ConvertRv(nsresult aRv) { if (NS_SUCCEEDED(aRv) || aRv == NS_ERROR_LAUNCHED_CHILD_PROCESS) { return aRv; } return NS_ERROR_ABORT; } nsresult mRv; }; } // namespace static ReturnAbortOnError ProfileLockedDialog(nsIFile* aProfileDir, nsIFile* aProfileLocalDir, nsIProfileUnlocker* aUnlocker, nsINativeAppSupport* aNative, nsIProfileLock* *aResult) { nsresult rv; ScopedXPCOMStartup xpcom; rv = xpcom.Initialize(); NS_ENSURE_SUCCESS(rv, rv); mozilla::Telemetry::WriteFailedProfileLock(aProfileDir); rv = xpcom.SetWindowCreator(aNative); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); { //extra scoping is needed so we release these components before xpcom shutdown nsCOMPtr<nsIStringBundleService> sbs = mozilla::services::GetStringBundleService(); NS_ENSURE_TRUE(sbs, NS_ERROR_FAILURE); nsCOMPtr<nsIStringBundle> sb; sbs->CreateBundle(kProfileProperties, getter_AddRefs(sb)); NS_ENSURE_TRUE_LOG(sbs, NS_ERROR_FAILURE); NS_ConvertUTF8toUTF16 appName(gAppData->name); const char16_t* params[] = {appName.get(), appName.get()}; nsXPIDLString killMessage; #ifndef XP_MACOSX sb->FormatStringFromName(aUnlocker ? u"restartMessageUnlocker" : u"restartMessageNoUnlocker", params, 2, getter_Copies(killMessage)); #else sb->FormatStringFromName(aUnlocker ? u"restartMessageUnlockerMac" : u"restartMessageNoUnlockerMac", params, 2, getter_Copies(killMessage)); #endif nsXPIDLString killTitle; sb->FormatStringFromName(u"restartTitle", params, 1, getter_Copies(killTitle)); if (!killMessage || !killTitle) return NS_ERROR_FAILURE; nsCOMPtr<nsIPromptService> ps (do_GetService(NS_PROMPTSERVICE_CONTRACTID)); NS_ENSURE_TRUE(ps, NS_ERROR_FAILURE); if (aUnlocker) { int32_t button; #ifdef MOZ_WIDGET_ANDROID java::GeckoAppShell::KillAnyZombies(); button = 0; #else const uint32_t flags = (nsIPromptService::BUTTON_TITLE_IS_STRING * nsIPromptService::BUTTON_POS_0) + (nsIPromptService::BUTTON_TITLE_CANCEL * nsIPromptService::BUTTON_POS_1); bool checkState = false; rv = ps->ConfirmEx(nullptr, killTitle, killMessage, flags, killTitle, nullptr, nullptr, nullptr, &checkState, &button); NS_ENSURE_SUCCESS_LOG(rv, rv); #endif if (button == 0) { rv = aUnlocker->Unlock(nsIProfileUnlocker::FORCE_QUIT); if (NS_FAILED(rv)) { return rv; } SaveFileToEnv("XRE_PROFILE_PATH", aProfileDir); SaveFileToEnv("XRE_PROFILE_LOCAL_PATH", aProfileLocalDir); return LaunchChild(aNative); } } else { #ifdef MOZ_WIDGET_ANDROID if (java::GeckoAppShell::UnlockProfile()) { return NS_LockProfilePath(aProfileDir, aProfileLocalDir, nullptr, aResult); } #else rv = ps->Alert(nullptr, killTitle, killMessage); NS_ENSURE_SUCCESS_LOG(rv, rv); #endif } return NS_ERROR_ABORT; } } static nsresult ProfileMissingDialog(nsINativeAppSupport* aNative) { nsresult rv; ScopedXPCOMStartup xpcom; rv = xpcom.Initialize(); NS_ENSURE_SUCCESS(rv, rv); rv = xpcom.SetWindowCreator(aNative); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); { //extra scoping is needed so we release these components before xpcom shutdown nsCOMPtr<nsIStringBundleService> sbs = mozilla::services::GetStringBundleService(); NS_ENSURE_TRUE(sbs, NS_ERROR_FAILURE); nsCOMPtr<nsIStringBundle> sb; sbs->CreateBundle(kProfileProperties, getter_AddRefs(sb)); NS_ENSURE_TRUE_LOG(sbs, NS_ERROR_FAILURE); NS_ConvertUTF8toUTF16 appName(gAppData->name); const char16_t* params[] = {appName.get(), appName.get()}; nsXPIDLString missingMessage; // profileMissing sb->FormatStringFromName(u"profileMissing", params, 2, getter_Copies(missingMessage)); nsXPIDLString missingTitle; sb->FormatStringFromName(u"profileMissingTitle", params, 1, getter_Copies(missingTitle)); if (missingMessage && missingTitle) { nsCOMPtr<nsIPromptService> ps (do_GetService(NS_PROMPTSERVICE_CONTRACTID)); NS_ENSURE_TRUE(ps, NS_ERROR_FAILURE); ps->Alert(nullptr, missingTitle, missingMessage); } return NS_ERROR_ABORT; } } static nsresult ProfileLockedDialog(nsIToolkitProfile* aProfile, nsIProfileUnlocker* aUnlocker, nsINativeAppSupport* aNative, nsIProfileLock* *aResult) { nsCOMPtr<nsIFile> profileDir; nsresult rv = aProfile->GetRootDir(getter_AddRefs(profileDir)); if (NS_FAILED(rv)) return rv; bool exists; profileDir->Exists(&exists); if (!exists) { return ProfileMissingDialog(aNative); } nsCOMPtr<nsIFile> profileLocalDir; rv = aProfile->GetLocalDir(getter_AddRefs(profileLocalDir)); if (NS_FAILED(rv)) return rv; return ProfileLockedDialog(profileDir, profileLocalDir, aUnlocker, aNative, aResult); } static const char kProfileManagerURL[] = "chrome://mozapps/content/profile/profileSelection.xul"; static ReturnAbortOnError ShowProfileManager(nsIToolkitProfileService* aProfileSvc, nsINativeAppSupport* aNative) { if (!CanShowProfileManager()) { return NS_ERROR_NOT_IMPLEMENTED; } nsresult rv; nsCOMPtr<nsIFile> profD, profLD; char16_t* profileNamePtr; nsAutoCString profileName; { ScopedXPCOMStartup xpcom; rv = xpcom.Initialize(); NS_ENSURE_SUCCESS(rv, rv); // Initialize the graphics prefs, some of the paths need them before // any other graphics is initialized (e.g., showing the profile chooser.) gfxPrefs::GetSingleton(); rv = xpcom.SetWindowCreator(aNative); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); #ifdef XP_MACOSX CommandLineServiceMac::SetupMacCommandLine(gRestartArgc, gRestartArgv, true); #endif #ifdef XP_WIN // we don't have to wait here because profile manager window will pump // and DDE message will be handled ProcessDDE(aNative, false); #endif { //extra scoping is needed so we release these components before xpcom shutdown nsCOMPtr<nsIWindowWatcher> windowWatcher (do_GetService(NS_WINDOWWATCHER_CONTRACTID)); nsCOMPtr<nsIDialogParamBlock> ioParamBlock (do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID)); nsCOMPtr<nsIMutableArray> dlgArray (do_CreateInstance(NS_ARRAY_CONTRACTID)); NS_ENSURE_TRUE(windowWatcher && ioParamBlock && dlgArray, NS_ERROR_FAILURE); ioParamBlock->SetObjects(dlgArray); nsCOMPtr<nsIAppStartup> appStartup (do_GetService(NS_APPSTARTUP_CONTRACTID)); NS_ENSURE_TRUE(appStartup, NS_ERROR_FAILURE); nsCOMPtr<mozIDOMWindowProxy> newWindow; rv = windowWatcher->OpenWindow(nullptr, kProfileManagerURL, "_blank", "centerscreen,chrome,modal,titlebar", ioParamBlock, getter_AddRefs(newWindow)); NS_ENSURE_SUCCESS_LOG(rv, rv); aProfileSvc->Flush(); int32_t dialogConfirmed; rv = ioParamBlock->GetInt(0, &dialogConfirmed); if (NS_FAILED(rv) || dialogConfirmed == 0) return NS_ERROR_ABORT; nsCOMPtr<nsIProfileLock> lock; rv = dlgArray->QueryElementAt(0, NS_GET_IID(nsIProfileLock), getter_AddRefs(lock)); NS_ENSURE_SUCCESS_LOG(rv, rv); rv = lock->GetDirectory(getter_AddRefs(profD)); NS_ENSURE_SUCCESS(rv, rv); rv = lock->GetLocalDirectory(getter_AddRefs(profLD)); NS_ENSURE_SUCCESS(rv, rv); rv = ioParamBlock->GetString(0, &profileNamePtr); NS_ENSURE_SUCCESS(rv, rv); CopyUTF16toUTF8(profileNamePtr, profileName); free(profileNamePtr); lock->Unlock(); } } SaveFileToEnv("XRE_PROFILE_PATH", profD); SaveFileToEnv("XRE_PROFILE_LOCAL_PATH", profLD); SaveWordToEnv("XRE_PROFILE_NAME", profileName); bool offline = false; aProfileSvc->GetStartOffline(&offline); if (offline) { SaveToEnv("XRE_START_OFFLINE=1"); } return LaunchChild(aNative); } /** * Get the currently running profile using its root directory. * * @param aProfileSvc The profile service * @param aCurrentProfileRoot The root directory of the current profile. * @param aProfile Out-param that returns the profile object. * @return an error if aCurrentProfileRoot is not found */ static nsresult GetCurrentProfile(nsIToolkitProfileService* aProfileSvc, nsIFile* aCurrentProfileRoot, nsIToolkitProfile** aProfile) { NS_ENSURE_ARG_POINTER(aProfileSvc); NS_ENSURE_ARG_POINTER(aProfile); nsCOMPtr<nsISimpleEnumerator> profiles; nsresult rv = aProfileSvc->GetProfiles(getter_AddRefs(profiles)); if (NS_FAILED(rv)) return rv; bool foundMatchingProfile = false; nsCOMPtr<nsISupports> supports; rv = profiles->GetNext(getter_AddRefs(supports)); while (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIToolkitProfile> profile = do_QueryInterface(supports); nsCOMPtr<nsIFile> profileRoot; profile->GetRootDir(getter_AddRefs(profileRoot)); profileRoot->Equals(aCurrentProfileRoot, &foundMatchingProfile); if (foundMatchingProfile) { profile.forget(aProfile); return NS_OK; } rv = profiles->GetNext(getter_AddRefs(supports)); } return rv; } static bool gDoMigration = false; static bool gDoProfileReset = false; static nsAutoCString gResetOldProfileName; // Pick a profile. We need to end up with a profile lock. // // 1) check for --profile <path> // 2) check for -P <name> // 3) check for --ProfileManager // 4) use the default profile, if there is one // 5) if there are *no* profiles, set up profile-migration // 6) display the profile-manager UI static nsresult SelectProfile(nsIProfileLock* *aResult, nsIToolkitProfileService* aProfileSvc, nsINativeAppSupport* aNative, bool* aStartOffline, nsACString* aProfileName) { StartupTimeline::Record(StartupTimeline::SELECT_PROFILE); nsresult rv; ArgResult ar; const char* arg; *aResult = nullptr; *aStartOffline = false; ar = CheckArg("offline", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --offline is invalid when argument --osint is specified\n"); return NS_ERROR_FAILURE; } if (ar || EnvHasValue("XRE_START_OFFLINE")) *aStartOffline = true; if (EnvHasValue("MOZ_RESET_PROFILE_RESTART")) { gDoProfileReset = true; gDoMigration = true; SaveToEnv("MOZ_RESET_PROFILE_RESTART="); } // reset-profile and migration args need to be checked before any profiles are chosen below. ar = CheckArg("reset-profile", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --reset-profile is invalid when argument --osint is specified\n"); return NS_ERROR_FAILURE; } else if (ar == ARG_FOUND) { gDoProfileReset = true; } ar = CheckArg("migration", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --migration is invalid when argument --osint is specified\n"); return NS_ERROR_FAILURE; } else if (ar == ARG_FOUND) { gDoMigration = true; } nsCOMPtr<nsIFile> lf = GetFileFromEnv("XRE_PROFILE_PATH"); if (lf) { nsCOMPtr<nsIFile> localDir = GetFileFromEnv("XRE_PROFILE_LOCAL_PATH"); if (!localDir) { localDir = lf; } arg = PR_GetEnv("XRE_PROFILE_NAME"); if (arg && *arg && aProfileName) { aProfileName->Assign(nsDependentCString(arg)); if (gDoProfileReset) { gResetOldProfileName.Assign(*aProfileName); } } // Clear out flags that we handled (or should have handled!) last startup. const char *dummy; CheckArg("p", false, &dummy); CheckArg("profile", false, &dummy); CheckArg("profilemanager"); if (gDoProfileReset) { // If we're resetting a profile, create a new one and use it to startup. nsCOMPtr<nsIToolkitProfile> newProfile; rv = CreateResetProfile(aProfileSvc, gResetOldProfileName, getter_AddRefs(newProfile)); if (NS_SUCCEEDED(rv)) { rv = newProfile->GetRootDir(getter_AddRefs(lf)); NS_ENSURE_SUCCESS(rv, rv); SaveFileToEnv("XRE_PROFILE_PATH", lf); rv = newProfile->GetLocalDir(getter_AddRefs(localDir)); NS_ENSURE_SUCCESS(rv, rv); SaveFileToEnv("XRE_PROFILE_LOCAL_PATH", localDir); rv = newProfile->GetName(*aProfileName); if (NS_FAILED(rv)) aProfileName->Truncate(0); SaveWordToEnv("XRE_PROFILE_NAME", *aProfileName); } else { NS_WARNING("Profile reset failed."); gDoProfileReset = false; } } return NS_LockProfilePath(lf, localDir, nullptr, aResult); } ar = CheckArg("profile", true, &arg); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --profile requires a path\n"); return NS_ERROR_FAILURE; } if (ar) { if (gDoProfileReset) { NS_WARNING("Profile reset is not supported in conjunction with --profile."); gDoProfileReset = false; } nsCOMPtr<nsIFile> lf; rv = XRE_GetFileFromPath(arg, getter_AddRefs(lf)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIProfileUnlocker> unlocker; // Check if the profile path exists and it's a directory. bool exists; lf->Exists(&exists); if (!exists) { rv = lf->Create(nsIFile::DIRECTORY_TYPE, 0700); NS_ENSURE_SUCCESS(rv, rv); } // If a profile path is specified directory on the command line, then // assume that the temp directory is the same as the given directory. rv = NS_LockProfilePath(lf, lf, getter_AddRefs(unlocker), aResult); if (NS_SUCCEEDED(rv)) return rv; return ProfileLockedDialog(lf, lf, unlocker, aNative, aResult); } ar = CheckArg("createprofile", true, &arg); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --createprofile requires a profile name\n"); return NS_ERROR_FAILURE; } if (ar) { nsCOMPtr<nsIToolkitProfile> profile; const char* delim = strchr(arg, ' '); if (delim) { nsCOMPtr<nsIFile> lf; rv = NS_NewNativeLocalFile(nsDependentCString(delim + 1), true, getter_AddRefs(lf)); if (NS_FAILED(rv)) { PR_fprintf(PR_STDERR, "Error: profile path not valid.\n"); return rv; } // As with --profile, assume that the given path will be used for the // main profile directory. rv = aProfileSvc->CreateProfile(lf, nsDependentCSubstring(arg, delim), getter_AddRefs(profile)); } else { rv = aProfileSvc->CreateProfile(nullptr, nsDependentCString(arg), getter_AddRefs(profile)); } // Some pathological arguments can make it this far if (NS_FAILED(rv)) { PR_fprintf(PR_STDERR, "Error creating profile.\n"); return rv; } rv = NS_ERROR_ABORT; aProfileSvc->Flush(); // XXXben need to ensure prefs.js exists here so the tinderboxes will // not go orange. nsCOMPtr<nsIFile> prefsJSFile; profile->GetRootDir(getter_AddRefs(prefsJSFile)); prefsJSFile->AppendNative(NS_LITERAL_CSTRING("prefs.js")); nsAutoCString pathStr; prefsJSFile->GetNativePath(pathStr); PR_fprintf(PR_STDERR, "Success: created profile '%s' at '%s'\n", arg, pathStr.get()); bool exists; prefsJSFile->Exists(&exists); if (!exists) { // Ignore any errors; we're about to return NS_ERROR_ABORT anyway. Unused << prefsJSFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644); } // XXXdarin perhaps 0600 would be better? return rv; } uint32_t count; rv = aProfileSvc->GetProfileCount(&count); NS_ENSURE_SUCCESS(rv, rv); ar = CheckArg("p", false, &arg); if (ar == ARG_BAD) { ar = CheckArg("osint"); if (ar == ARG_FOUND) { PR_fprintf(PR_STDERR, "Error: argument -p is invalid when argument --osint is specified\n"); return NS_ERROR_FAILURE; } if (CanShowProfileManager()) { return ShowProfileManager(aProfileSvc, aNative); } } if (ar) { ar = CheckArg("osint"); if (ar == ARG_FOUND) { PR_fprintf(PR_STDERR, "Error: argument -p is invalid when argument --osint is specified\n"); return NS_ERROR_FAILURE; } nsCOMPtr<nsIToolkitProfile> profile; rv = aProfileSvc->GetProfileByName(nsDependentCString(arg), getter_AddRefs(profile)); if (NS_SUCCEEDED(rv)) { if (gDoProfileReset) { { // Check that the source profile is not in use by temporarily acquiring its lock. nsIProfileLock* tempProfileLock; nsCOMPtr<nsIProfileUnlocker> unlocker; rv = profile->Lock(getter_AddRefs(unlocker), &tempProfileLock); if (NS_FAILED(rv)) return ProfileLockedDialog(profile, unlocker, aNative, &tempProfileLock); } nsresult gotName = profile->GetName(gResetOldProfileName); if (NS_SUCCEEDED(gotName)) { nsCOMPtr<nsIToolkitProfile> newProfile; rv = CreateResetProfile(aProfileSvc, gResetOldProfileName, getter_AddRefs(newProfile)); if (NS_FAILED(rv)) { NS_WARNING("Failed to create a profile to reset to."); gDoProfileReset = false; } else { profile = newProfile; } } else { NS_WARNING("Failed to get the name of the profile we're resetting, so aborting reset."); gResetOldProfileName.Truncate(0); gDoProfileReset = false; } } nsCOMPtr<nsIProfileUnlocker> unlocker; rv = profile->Lock(getter_AddRefs(unlocker), aResult); if (NS_SUCCEEDED(rv)) { if (aProfileName) aProfileName->Assign(nsDependentCString(arg)); return NS_OK; } return ProfileLockedDialog(profile, unlocker, aNative, aResult); } if (CanShowProfileManager()) { return ShowProfileManager(aProfileSvc, aNative); } } ar = CheckArg("profilemanager", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --profilemanager is invalid when argument --osint is specified\n"); return NS_ERROR_FAILURE; } else if (ar == ARG_FOUND && CanShowProfileManager()) { return ShowProfileManager(aProfileSvc, aNative); } #ifndef MOZ_DEV_EDITION // If the only existing profile is the dev-edition-profile and this is not // Developer Edition, then no valid profiles were found. if (count == 1) { nsCOMPtr<nsIToolkitProfile> deProfile; // GetSelectedProfile will auto-select the only profile if there's just one aProfileSvc->GetSelectedProfile(getter_AddRefs(deProfile)); nsAutoCString profileName; deProfile->GetName(profileName); if (profileName.EqualsLiteral("dev-edition-default")) { count = 0; } } #endif if (!count) { gDoMigration = true; gDoProfileReset = false; // create a default profile nsCOMPtr<nsIToolkitProfile> profile; nsresult rv = aProfileSvc->CreateProfile(nullptr, // choose a default dir for us #ifdef MOZ_DEV_EDITION NS_LITERAL_CSTRING("dev-edition-default"), #else NS_LITERAL_CSTRING("default"), #endif getter_AddRefs(profile)); if (NS_SUCCEEDED(rv)) { #ifndef MOZ_DEV_EDITION aProfileSvc->SetDefaultProfile(profile); #endif aProfileSvc->Flush(); rv = profile->Lock(nullptr, aResult); if (NS_SUCCEEDED(rv)) { if (aProfileName) #ifdef MOZ_DEV_EDITION aProfileName->AssignLiteral("dev-edition-default"); #else aProfileName->AssignLiteral("default"); #endif return NS_OK; } } } bool useDefault = true; if (count > 1 && CanShowProfileManager()) { aProfileSvc->GetStartWithLastProfile(&useDefault); } if (useDefault) { nsCOMPtr<nsIToolkitProfile> profile; // GetSelectedProfile will auto-select the only profile if there's just one aProfileSvc->GetSelectedProfile(getter_AddRefs(profile)); if (profile) { // If we're resetting a profile, create a new one and use it to startup. if (gDoProfileReset) { { // Check that the source profile is not in use by temporarily acquiring its lock. nsIProfileLock* tempProfileLock; nsCOMPtr<nsIProfileUnlocker> unlocker; rv = profile->Lock(getter_AddRefs(unlocker), &tempProfileLock); if (NS_FAILED(rv)) return ProfileLockedDialog(profile, unlocker, aNative, &tempProfileLock); } nsresult gotName = profile->GetName(gResetOldProfileName); if (NS_SUCCEEDED(gotName)) { nsCOMPtr<nsIToolkitProfile> newProfile; rv = CreateResetProfile(aProfileSvc, gResetOldProfileName, getter_AddRefs(newProfile)); if (NS_FAILED(rv)) { NS_WARNING("Failed to create a profile to reset to."); gDoProfileReset = false; } else { profile = newProfile; } } else { NS_WARNING("Failed to get the name of the profile we're resetting, so aborting reset."); gResetOldProfileName.Truncate(0); gDoProfileReset = false; } } // If you close Firefox and very quickly reopen it, the old Firefox may // still be closing down. Rather than immediately showing the // "Firefox is running but is not responding" message, we spend a few // seconds retrying first. static const int kLockRetrySeconds = 5; static const int kLockRetrySleepMS = 100; nsCOMPtr<nsIProfileUnlocker> unlocker; const TimeStamp start = TimeStamp::Now(); do { rv = profile->Lock(getter_AddRefs(unlocker), aResult); if (NS_SUCCEEDED(rv)) { StartupTimeline::Record(StartupTimeline::AFTER_PROFILE_LOCKED); // Try to grab the profile name. if (aProfileName) { rv = profile->GetName(*aProfileName); if (NS_FAILED(rv)) aProfileName->Truncate(0); } return NS_OK; } PR_Sleep(kLockRetrySleepMS); } while (TimeStamp::Now() - start < TimeDuration::FromSeconds(kLockRetrySeconds)); return ProfileLockedDialog(profile, unlocker, aNative, aResult); } } if (!CanShowProfileManager()) { return NS_ERROR_FAILURE; } return ShowProfileManager(aProfileSvc, aNative); } /** * Checks the compatibility.ini file to see if we have updated our application * or otherwise invalidated our caches. If the application has been updated, * we return false; otherwise, we return true. We also write the status * of the caches (valid/invalid) into the return param aCachesOK. The aCachesOK * is always invalid if the application has been updated. */ static bool CheckCompatibility(nsIFile* aProfileDir, const nsCString& aVersion, const nsCString& aOSABI, nsIFile* aXULRunnerDir, nsIFile* aAppDir, nsIFile* aFlagFile, bool* aCachesOK) { *aCachesOK = false; nsCOMPtr<nsIFile> file; aProfileDir->Clone(getter_AddRefs(file)); if (!file) return false; file->AppendNative(FILE_COMPATIBILITY_INFO); nsINIParser parser; nsresult rv = parser.Init(file); if (NS_FAILED(rv)) return false; nsAutoCString buf; rv = parser.GetString("Compatibility", "LastVersion", buf); if (NS_FAILED(rv) || !aVersion.Equals(buf)) return false; rv = parser.GetString("Compatibility", "LastOSABI", buf); if (NS_FAILED(rv) || !aOSABI.Equals(buf)) return false; rv = parser.GetString("Compatibility", "LastPlatformDir", buf); if (NS_FAILED(rv)) return false; nsCOMPtr<nsIFile> lf; rv = NS_NewNativeLocalFile(buf, false, getter_AddRefs(lf)); if (NS_FAILED(rv)) return false; bool eq; rv = lf->Equals(aXULRunnerDir, &eq); if (NS_FAILED(rv) || !eq) return false; if (aAppDir) { rv = parser.GetString("Compatibility", "LastAppDir", buf); if (NS_FAILED(rv)) return false; rv = NS_NewNativeLocalFile(buf, false, getter_AddRefs(lf)); if (NS_FAILED(rv)) return false; rv = lf->Equals(aAppDir, &eq); if (NS_FAILED(rv) || !eq) return false; } // If we see this flag, caches are invalid. rv = parser.GetString("Compatibility", "InvalidateCaches", buf); *aCachesOK = (NS_FAILED(rv) || !buf.EqualsLiteral("1")); bool purgeCaches = false; if (aFlagFile) { aFlagFile->Exists(&purgeCaches); } *aCachesOK = !purgeCaches && *aCachesOK; return true; } static void BuildVersion(nsCString &aBuf) { aBuf.Assign(gAppData->version); aBuf.Append('_'); aBuf.Append(gAppData->buildID); aBuf.Append('/'); aBuf.Append(gToolkitBuildID); } static void WriteVersion(nsIFile* aProfileDir, const nsCString& aVersion, const nsCString& aOSABI, nsIFile* aXULRunnerDir, nsIFile* aAppDir, bool invalidateCache) { nsCOMPtr<nsIFile> file; aProfileDir->Clone(getter_AddRefs(file)); if (!file) return; file->AppendNative(FILE_COMPATIBILITY_INFO); nsAutoCString platformDir; aXULRunnerDir->GetNativePath(platformDir); nsAutoCString appDir; if (aAppDir) aAppDir->GetNativePath(appDir); PRFileDesc *fd; nsresult rv = file->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 0600, &fd); if (NS_FAILED(rv)) { NS_ERROR("could not create output stream"); return; } static const char kHeader[] = "[Compatibility]" NS_LINEBREAK "LastVersion="; PR_Write(fd, kHeader, sizeof(kHeader) - 1); PR_Write(fd, aVersion.get(), aVersion.Length()); static const char kOSABIHeader[] = NS_LINEBREAK "LastOSABI="; PR_Write(fd, kOSABIHeader, sizeof(kOSABIHeader) - 1); PR_Write(fd, aOSABI.get(), aOSABI.Length()); static const char kPlatformDirHeader[] = NS_LINEBREAK "LastPlatformDir="; PR_Write(fd, kPlatformDirHeader, sizeof(kPlatformDirHeader) - 1); PR_Write(fd, platformDir.get(), platformDir.Length()); static const char kAppDirHeader[] = NS_LINEBREAK "LastAppDir="; if (aAppDir) { PR_Write(fd, kAppDirHeader, sizeof(kAppDirHeader) - 1); PR_Write(fd, appDir.get(), appDir.Length()); } static const char kInvalidationHeader[] = NS_LINEBREAK "InvalidateCaches=1"; if (invalidateCache) PR_Write(fd, kInvalidationHeader, sizeof(kInvalidationHeader) - 1); static const char kNL[] = NS_LINEBREAK; PR_Write(fd, kNL, sizeof(kNL) - 1); PR_Close(fd); } /** * Returns true if the startup cache file was successfully removed. * Returns false if file->Clone fails at any point (OOM) or if unable * to remove the startup cache file. Note in particular the return value * is unaffected by a failure to remove extensions.ini */ static bool RemoveComponentRegistries(nsIFile* aProfileDir, nsIFile* aLocalProfileDir, bool aRemoveEMFiles) { nsCOMPtr<nsIFile> file; aProfileDir->Clone(getter_AddRefs(file)); if (!file) return false; if (aRemoveEMFiles) { file->SetNativeLeafName(NS_LITERAL_CSTRING("extensions.ini")); file->Remove(false); } aLocalProfileDir->Clone(getter_AddRefs(file)); if (!file) return false; #if defined(XP_UNIX) || defined(XP_BEOS) #define PLATFORM_FASL_SUFFIX ".mfasl" #elif defined(XP_WIN) #define PLATFORM_FASL_SUFFIX ".mfl" #endif file->AppendNative(NS_LITERAL_CSTRING("XUL" PLATFORM_FASL_SUFFIX)); file->Remove(false); file->SetNativeLeafName(NS_LITERAL_CSTRING("XPC" PLATFORM_FASL_SUFFIX)); file->Remove(false); file->SetNativeLeafName(NS_LITERAL_CSTRING("startupCache")); nsresult rv = file->Remove(true); return NS_SUCCEEDED(rv) || rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST; } // To support application initiated restart via nsIAppStartup.quit, we // need to save various environment variables, and then restore them // before re-launching the application. static struct SavedVar { const char *name; char *value; } gSavedVars[] = { {"XUL_APP_FILE", nullptr} }; static void SaveStateForAppInitiatedRestart() { for (size_t i = 0; i < ArrayLength(gSavedVars); ++i) { const char *s = PR_GetEnv(gSavedVars[i].name); if (s) gSavedVars[i].value = PR_smprintf("%s=%s", gSavedVars[i].name, s); } } static void RestoreStateForAppInitiatedRestart() { for (size_t i = 0; i < ArrayLength(gSavedVars); ++i) { if (gSavedVars[i].value) PR_SetEnv(gSavedVars[i].value); } } const nsXREAppData* gAppData = nullptr; #ifdef MOZ_WIDGET_GTK static void MOZ_gdk_display_close(GdkDisplay *display) { #if CLEANUP_MEMORY // XXX wallpaper for bug 417163: don't close the Display if we're using the // Qt theme because we crash (in Qt code) when using jemalloc. bool skip_display_close = false; GtkSettings* settings = gtk_settings_get_for_screen(gdk_display_get_default_screen(display)); gchar *theme_name; g_object_get(settings, "gtk-theme-name", &theme_name, nullptr); if (theme_name) { skip_display_close = strcmp(theme_name, "Qt") == 0; if (skip_display_close) NS_WARNING("wallpaper bug 417163 for Qt theme"); g_free(theme_name); } #if (MOZ_WIDGET_GTK == 3) // A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=703257 if (gtk_check_version(3,9,8) != NULL) skip_display_close = true; #endif // Get a (new) Pango context that holds a reference to the fontmap that // GTK has been using. gdk_pango_context_get() must be called while GTK // has a default display. PangoContext *pangoContext = gdk_pango_context_get(); bool buggyCairoShutdown = cairo_version() < CAIRO_VERSION_ENCODE(1, 4, 0); if (!buggyCairoShutdown) { // We should shut down GDK before we shut down libraries it depends on // like Pango and cairo. But if cairo shutdown is buggy, we should // shut down cairo first otherwise it may crash because of dangling // references to Display objects (see bug 469831). if (!skip_display_close) gdk_display_close(display); } // Clean up PangoCairo's default fontmap. // This pango_fc_font_map_shutdown call (and the associated code to // get the font map) really shouldn't be needed anymore, except that // it's needed to avoid having cairo_debug_reset_static_data fatally // assert if we've leaked other things that hold on to the fontmap, // which is something that currently happens in mochitest-plugins. // Even if it didn't happen in mochitest-plugins, we probably want to // avoid the crash-on-leak problem since it makes it harder to use // many of our leak tools to debug leaks. // This doesn't take a reference. PangoFontMap *fontmap = pango_context_get_font_map(pangoContext); // Do some shutdown of the fontmap, which releases the fonts, clearing a // bunch of circular references from the fontmap through the fonts back to // itself. The shutdown that this does is much less than what's done by // the fontmap's finalize, though. if (PANGO_IS_FC_FONT_MAP(fontmap)) pango_fc_font_map_shutdown(PANGO_FC_FONT_MAP(fontmap)); g_object_unref(pangoContext); // Tell PangoCairo to release its default fontmap. pango_cairo_font_map_set_default(nullptr); // cairo_debug_reset_static_data() is prototyped through cairo.h included // by gtk.h. #ifdef cairo_debug_reset_static_data #error "Looks like we're including Mozilla's cairo instead of system cairo" #endif cairo_debug_reset_static_data(); // FIXME: Do we need to call this in non-GTK2 cases as well? FcFini(); if (buggyCairoShutdown) { if (!skip_display_close) gdk_display_close(display); } #else // not CLEANUP_MEMORY // Don't do anything to avoid running into driver bugs under XCloseDisplay(). // See bug 973192. (void) display; #endif } static const char* detectDisplay(void) { bool tryX11 = false; bool tryWayland = false; bool tryBroadway = false; // Honor user backend selection const char *backend = PR_GetEnv("GDK_BACKEND"); if (!backend || strstr(backend, "*")) { // Try all backends tryX11 = true; tryWayland = true; tryBroadway = true; } else if (backend) { if (strstr(backend, "x11")) tryX11 = true; if (strstr(backend, "wayland")) tryWayland = true; if (strstr(backend, "broadway")) tryBroadway = true; } const char *display_name; if (tryX11 && (display_name = PR_GetEnv("DISPLAY"))) { return display_name; } else if (tryWayland && (display_name = PR_GetEnv("WAYLAND_DISPLAY"))) { return display_name; } else if (tryBroadway && (display_name = PR_GetEnv("BROADWAY_DISPLAY"))) { return display_name; } PR_fprintf(PR_STDERR, "Error: GDK_BACKEND does not match available displays\n"); return nullptr; } #endif // MOZ_WIDGET_GTK /** * NSPR will search for the "nspr_use_zone_allocator" symbol throughout * the process and use it to determine whether the application defines its own * memory allocator or not. * * Since most applications (e.g. Firefox and Thunderbird) don't use any special * allocators and therefore don't define this symbol, NSPR must search the * entire process, which reduces startup performance. * * By defining the symbol here, we can avoid the wasted lookup and hopefully * improve startup performance. */ NS_VISIBILITY_DEFAULT PRBool nspr_use_zone_allocator = PR_FALSE; #ifdef CAIRO_HAS_DWRITE_FONT #include <dwrite.h> #ifdef DEBUG_DWRITE_STARTUP #define LOGREGISTRY(msg) LogRegistryEvent(msg) // for use when monitoring process static void LogRegistryEvent(const wchar_t *msg) { HKEY dummyKey; HRESULT hr; wchar_t buf[512]; wsprintf(buf, L" log %s", msg); hr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, buf, 0, KEY_READ, &dummyKey); if (SUCCEEDED(hr)) { RegCloseKey(dummyKey); } } #else #define LOGREGISTRY(msg) #endif static DWORD WINAPI InitDwriteBG(LPVOID lpdwThreadParam) { SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_BEGIN); LOGREGISTRY(L"loading dwrite.dll"); HMODULE dwdll = LoadLibraryW(L"dwrite.dll"); if (dwdll) { decltype(DWriteCreateFactory)* createDWriteFactory = (decltype(DWriteCreateFactory)*) GetProcAddress(dwdll, "DWriteCreateFactory"); if (createDWriteFactory) { LOGREGISTRY(L"creating dwrite factory"); IDWriteFactory *factory; HRESULT hr = createDWriteFactory( DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&factory)); if (SUCCEEDED(hr)) { LOGREGISTRY(L"dwrite factory done"); factory->Release(); LOGREGISTRY(L"freed factory"); } else { LOGREGISTRY(L"failed to create factory"); } } } SetThreadPriority(GetCurrentThread(), THREAD_MODE_BACKGROUND_END); return 0; } #endif #ifdef USE_GLX_TEST bool fire_glxtest_process(); #endif #include "GeckoProfiler.h" // Encapsulates startup and shutdown state for XRE_main class XREMain { public: XREMain() : mStartOffline(false) , mShuttingDown(false) #ifdef MOZ_ENABLE_XREMOTE , mDisableRemote(false) #endif #if defined(MOZ_WIDGET_GTK) , mGdkDisplay(nullptr) #endif {}; ~XREMain() { mScopedXPCOM = nullptr; mAppData = nullptr; } int XRE_main(int argc, char* argv[], const nsXREAppData* aAppData); int XRE_mainInit(bool* aExitFlag); int XRE_mainStartup(bool* aExitFlag); nsresult XRE_mainRun(); nsCOMPtr<nsINativeAppSupport> mNativeApp; nsCOMPtr<nsIToolkitProfileService> mProfileSvc; nsCOMPtr<nsIFile> mProfD; nsCOMPtr<nsIFile> mProfLD; nsCOMPtr<nsIProfileLock> mProfileLock; #ifdef MOZ_ENABLE_XREMOTE nsCOMPtr<nsIRemoteService> mRemoteService; nsProfileLock mRemoteLock; nsCOMPtr<nsIFile> mRemoteLockDir; #endif UniquePtr<ScopedXPCOMStartup> mScopedXPCOM; nsAutoPtr<mozilla::ScopedAppData> mAppData; nsXREDirProvider mDirProvider; nsAutoCString mProfileName; nsAutoCString mDesktopStartupID; bool mStartOffline; bool mShuttingDown; #ifdef MOZ_ENABLE_XREMOTE bool mDisableRemote; #endif #if defined(MOZ_WIDGET_GTK) GdkDisplay* mGdkDisplay; #endif }; /* * XRE_mainInit - Initial setup and command line parameter processing. * Main() will exit early if either return value != 0 or if aExitFlag is * true. */ int XREMain::XRE_mainInit(bool* aExitFlag) { if (!aExitFlag) return 1; *aExitFlag = false; atexit(UnexpectedExit); auto expectedShutdown = mozilla::MakeScopeExit([&] { MozExpectedExit(); }); StartupTimeline::Record(StartupTimeline::MAIN); if (PR_GetEnv("MOZ_CHAOSMODE")) { ChaosFeature feature = ChaosFeature::Any; long featureInt = strtol(PR_GetEnv("MOZ_CHAOSMODE"), nullptr, 16); if (featureInt) { // NOTE: MOZ_CHAOSMODE=0 or a non-hex value maps to Any feature. feature = static_cast<ChaosFeature>(featureInt); } ChaosMode::SetChaosFeature(feature); } if (ChaosMode::isActive(ChaosFeature::Any)) { printf_stderr("*** You are running in chaos test mode. See ChaosMode.h. ***\n"); } nsresult rv; ArgResult ar; #ifdef DEBUG if (PR_GetEnv("XRE_MAIN_BREAK")) NS_BREAK(); #endif #ifdef USE_GLX_TEST // bug 639842 - it's very important to fire this process BEFORE we set up // error handling. indeed, this process is expected to be crashy, and we // don't want the user to see its crashes. That's the whole reason for // doing this in a separate process. // // This call will cause a fork and the fork will terminate itself separately // from the usual shutdown sequence fire_glxtest_process(); #endif SetupErrorHandling(gArgv[0]); #ifdef CAIRO_HAS_DWRITE_FONT { // Bug 602792 - when DWriteCreateFactory is called the dwrite client dll // starts the FntCache service if it isn't already running (it's set // to manual startup by default in Windows 7 RTM). Subsequent DirectWrite // calls cause the IDWriteFactory object to communicate with the FntCache // service with a timeout; if there's no response after the timeout, the // DirectWrite client library will assume the service isn't around and do // manual font file I/O on _all_ system fonts. To avoid this, load the // dwrite library and create a factory as early as possible so that the // FntCache service is ready by the time it's needed. CreateThread(nullptr, 0, &InitDwriteBG, nullptr, 0, nullptr); } #endif #ifdef XP_UNIX const char *home = PR_GetEnv("HOME"); if (!home || !*home) { struct passwd *pw = getpwuid(geteuid()); if (!pw || !pw->pw_dir) { Output(true, "Could not determine HOME directory"); return 1; } SaveWordToEnv("HOME", nsDependentCString(pw->pw_dir)); } #endif #ifdef MOZ_ACCESSIBILITY_ATK // Suppress atk-bridge init at startup, until mozilla accessibility is // initialized. This works after gnome 2.24.2. SaveToEnv("NO_AT_BRIDGE=1"); #endif // Check for application.ini overrides const char* override = nullptr; ar = CheckArg("override", true, &override); if (ar == ARG_BAD) { Output(true, "Incorrect number of arguments passed to --override"); return 1; } else if (ar == ARG_FOUND) { nsCOMPtr<nsIFile> overrideLF; rv = XRE_GetFileFromPath(override, getter_AddRefs(overrideLF)); if (NS_FAILED(rv)) { Output(true, "Error: unrecognized override.ini path.\n"); return 1; } rv = XRE_ParseAppData(overrideLF, mAppData.get()); if (NS_FAILED(rv)) { Output(true, "Couldn't read override.ini"); return 1; } } // Check sanity and correctness of app data. if (!mAppData->name) { Output(true, "Error: App:Name not specified in application.ini\n"); return 1; } if (!mAppData->buildID) { Output(true, "Error: App:BuildID not specified in application.ini\n"); return 1; } // XXX Originally ScopedLogging was here? Now it's in XRE_main above // XRE_mainInit. if (!mAppData->xreDirectory) { nsCOMPtr<nsIFile> lf; rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf)); if (NS_FAILED(rv)) return 2; nsCOMPtr<nsIFile> greDir; rv = lf->GetParent(getter_AddRefs(greDir)); if (NS_FAILED(rv)) return 2; #ifdef XP_MACOSX nsCOMPtr<nsIFile> parent; greDir->GetParent(getter_AddRefs(parent)); greDir = parent.forget(); greDir->AppendNative(NS_LITERAL_CSTRING("Resources")); #endif greDir.forget(&mAppData->xreDirectory); } if (!mAppData->directory) { NS_IF_ADDREF(mAppData->directory = mAppData->xreDirectory); } if (mAppData->size > offsetof(nsXREAppData, minVersion)) { if (!mAppData->minVersion) { Output(true, "Error: Gecko:MinVersion not specified in application.ini\n"); return 1; } if (!mAppData->maxVersion) { // If no maxVersion is specified, we assume the app is only compatible // with the initial preview release. Do not increment this number ever! SetAllocatedString(mAppData->maxVersion, "1.*"); } if (mozilla::Version(mAppData->minVersion) > gToolkitVersion || mozilla::Version(mAppData->maxVersion) < gToolkitVersion) { Output(true, "Error: Platform version '%s' is not compatible with\n" "minVersion >= %s\nmaxVersion <= %s\n", gToolkitVersion, mAppData->minVersion, mAppData->maxVersion); return 1; } } rv = mDirProvider.Initialize(mAppData->directory, mAppData->xreDirectory); if (NS_FAILED(rv)) return 1; #ifdef XP_MACOSX // Set up ability to respond to system (Apple) events. This must occur before // ProcessUpdates to ensure that links clicked in external applications aren't // lost when updates are pending. SetupMacApplicationDelegate(); if (EnvHasValue("MOZ_LAUNCHED_CHILD")) { // This is needed, on relaunch, to force the OS to use the "Cocoa Dock // API". Otherwise the call to ReceiveNextEvent() below will make it // use the "Carbon Dock API". For more info see bmo bug 377166. EnsureUseCocoaDockAPI(); // When the app relaunches, the original process exits. This causes // the dock tile to stop bouncing, lose the "running" triangle, and // if the tile does not permanently reside in the Dock, even disappear. // This can be confusing to the user, who is expecting the app to launch. // Calling ReceiveNextEvent without requesting any event is enough to // cause a dock tile for the child process to appear. const EventTypeSpec kFakeEventList[] = { { INT_MAX, INT_MAX } }; EventRef event; ::ReceiveNextEvent(GetEventTypeCount(kFakeEventList), kFakeEventList, kEventDurationNoWait, false, &event); } if (CheckArg("foreground")) { // The original process communicates that it was in the foreground by // adding this argument. This new process, which is taking over for // the old one, should make itself the active application. ProcessSerialNumber psn; if (::GetCurrentProcess(&psn) == noErr) ::SetFrontProcess(&psn); } #endif SaveToEnv("MOZ_LAUNCHED_CHILD="); gRestartArgc = gArgc; gRestartArgv = (char**) malloc(sizeof(char*) * (gArgc + 1 + (override ? 2 : 0))); if (!gRestartArgv) { return 1; } int i; for (i = 0; i < gArgc; ++i) { gRestartArgv[i] = gArgv[i]; } // Add the -override argument back (it is removed automatically be CheckArg) if there is one if (override) { gRestartArgv[gRestartArgc++] = const_cast<char*>("-override"); gRestartArgv[gRestartArgc++] = const_cast<char*>(override); } gRestartArgv[gRestartArgc] = nullptr; if (EnvHasValue("MOZ_SAFE_MODE_RESTART")) { gSafeMode = true; // unset the env variable SaveToEnv("MOZ_SAFE_MODE_RESTART="); } ar = CheckArg("safe-mode", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --safe-mode is invalid when argument --osint is specified\n"); return 1; } else if (ar == ARG_FOUND) { gSafeMode = true; } #ifdef XP_WIN // If the shift key is pressed and the ctrl and / or alt keys are not pressed // during startup start in safe mode. GetKeyState returns a short and the high // order bit will be 1 if the key is pressed. By masking the returned short // with 0x8000 the result will be 0 if the key is not pressed and non-zero // otherwise. if ((GetKeyState(VK_SHIFT) & 0x8000) && !(GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_MENU) & 0x8000) && !EnvHasValue("MOZ_DISABLE_SAFE_MODE_KEY")) { gSafeMode = true; } #endif #ifdef XP_MACOSX if ((GetCurrentEventKeyModifiers() & optionKey) && !EnvHasValue("MOZ_DISABLE_SAFE_MODE_KEY")) gSafeMode = true; #endif #ifdef XP_WIN { // Add CPU microcode version to the crash report as "CPUMicrocodeVersion". // It feels like this code may belong in nsSystemInfo instead. int cpuUpdateRevision = -1; HKEY key; static const WCHAR keyName[] = L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"; if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key) == ERROR_SUCCESS) { DWORD updateRevision[2]; DWORD len = sizeof(updateRevision); DWORD vtype; // Windows 7 uses "Update Signature", 8 uses "Update Revision". // For AMD CPUs, "CurrentPatchLevel" is sometimes used. // Take the first one we find. LPCWSTR choices[] = {L"Update Signature", L"Update Revision", L"CurrentPatchLevel"}; for (size_t oneChoice=0; oneChoice<ArrayLength(choices); oneChoice++) { if (RegQueryValueExW(key, choices[oneChoice], 0, &vtype, reinterpret_cast<LPBYTE>(updateRevision), &len) == ERROR_SUCCESS) { if (vtype == REG_BINARY && len == sizeof(updateRevision)) { // The first word is unused cpuUpdateRevision = static_cast<int>(updateRevision[1]); break; } else if (vtype == REG_DWORD && len == sizeof(updateRevision[0])) { cpuUpdateRevision = static_cast<int>(updateRevision[0]); break; } } } } } #endif // Handle --no-remote and --new-instance command line arguments. Setup // the environment to better accommodate other components and various // restart scenarios. ar = CheckArg("no-remote", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --no-remote is invalid when argument --osint is specified\n"); return 1; } else if (ar == ARG_FOUND) { SaveToEnv("MOZ_NO_REMOTE=1"); } ar = CheckArg("new-instance", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --new-instance is invalid when argument --osint is specified\n"); return 1; } else if (ar == ARG_FOUND) { SaveToEnv("MOZ_NEW_INSTANCE=1"); } // Handle --help and --version command line arguments. // They should return quickly, so we deal with them here. if (CheckArg("h") || CheckArg("help") || CheckArg("?")) { DumpHelp(); *aExitFlag = true; return 0; } if (CheckArg("v") || CheckArg("version")) { DumpVersion(); *aExitFlag = true; return 0; } rv = XRE_InitCommandLine(gArgc, gArgv); NS_ENSURE_SUCCESS(rv, 1); // Check for --register, which registers chrome and then exits immediately. ar = CheckArg("register", true); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --register is invalid when argument --osint is specified\n"); return 1; } else if (ar == ARG_FOUND) { ScopedXPCOMStartup xpcom; rv = xpcom.Initialize(); NS_ENSURE_SUCCESS(rv, 1); { nsCOMPtr<nsIChromeRegistry> chromeReg = mozilla::services::GetChromeRegistryService(); NS_ENSURE_TRUE(chromeReg, 1); chromeReg->CheckForNewChrome(); } *aExitFlag = true; return 0; } return 0; } namespace mozilla { ShutdownChecksMode gShutdownChecks = SCM_NOTHING; } // namespace mozilla static void SetShutdownChecks() { // Set default first. On debug builds we crash. On nightly and local // builds we record. Nightlies will then send the info via telemetry, // but it is usefull to have the data in about:telemetry in local builds // too. #ifdef DEBUG gShutdownChecks = SCM_CRASH; #else const char* releaseChannel = NS_STRINGIFY(MOZ_UPDATE_CHANNEL); if (strcmp(releaseChannel, "nightly") == 0 || strcmp(releaseChannel, "default") == 0) { gShutdownChecks = SCM_RECORD; } else { gShutdownChecks = SCM_NOTHING; } #endif // We let an environment variable override the default so that addons // authors can use it for debugging shutdown with released firefox versions. const char* mozShutdownChecksEnv = PR_GetEnv("MOZ_SHUTDOWN_CHECKS"); if (mozShutdownChecksEnv) { if (strcmp(mozShutdownChecksEnv, "crash") == 0) { gShutdownChecks = SCM_CRASH; } else if (strcmp(mozShutdownChecksEnv, "record") == 0) { gShutdownChecks = SCM_RECORD; } else if (strcmp(mozShutdownChecksEnv, "nothing") == 0) { gShutdownChecks = SCM_NOTHING; } } } /* * XRE_mainStartup - Initializes the profile and various other services. * Main() will exit early if either return value != 0 or if aExitFlag is * true. */ int XREMain::XRE_mainStartup(bool* aExitFlag) { nsresult rv; if (!aExitFlag) return 1; *aExitFlag = false; SetShutdownChecks(); // Enable Telemetry IO Reporting on DEBUG, nightly and local builds #ifdef DEBUG mozilla::Telemetry::InitIOReporting(gAppData->xreDirectory); #else { const char* releaseChannel = NS_STRINGIFY(MOZ_UPDATE_CHANNEL); if (strcmp(releaseChannel, "nightly") == 0 || strcmp(releaseChannel, "default") == 0) { mozilla::Telemetry::InitIOReporting(gAppData->xreDirectory); } } #endif /* DEBUG */ #if defined(MOZ_WIDGET_GTK) || defined(MOZ_ENABLE_XREMOTE) // Stash DESKTOP_STARTUP_ID in malloc'ed memory because gtk_init will clear it. #define HAVE_DESKTOP_STARTUP_ID const char* desktopStartupIDEnv = PR_GetEnv("DESKTOP_STARTUP_ID"); if (desktopStartupIDEnv) { mDesktopStartupID.Assign(desktopStartupIDEnv); } #endif #if defined(MOZ_WIDGET_GTK) // setup for private colormap. Ideally we'd like to do this // in nsAppShell::Create, but we need to get in before gtk // has been initialized to make sure everything is running // consistently. #if (MOZ_WIDGET_GTK == 2) if (CheckArg("install")) gdk_rgb_set_install(TRUE); #endif // Set program name to the one defined in application.ini. { nsAutoCString program(gAppData->name); ToLowerCase(program); g_set_prgname(program.get()); } // Initialize GTK here for splash. #if (MOZ_WIDGET_GTK == 3) && defined(MOZ_X11) // Disable XInput2 support due to focus bugginess. See bugs 1182700, 1170342. const char* useXI2 = PR_GetEnv("MOZ_USE_XINPUT2"); if (!useXI2 || (*useXI2 == '0')) gdk_disable_multidevice(); #endif // Open the display ourselves instead of using gtk_init, so that we can // close it without fear that one day gtk might clean up the display it // opens. if (!gtk_parse_args(&gArgc, &gArgv)) return 1; #endif /* MOZ_WIDGET_GTK */ #ifdef LIBFUZZER if (PR_GetEnv("LIBFUZZER")) { *aExitFlag = true; return mozilla::libFuzzerRunner->Run(); } #endif if (PR_GetEnv("MOZ_RUN_GTEST")) { int result; #ifdef XP_WIN UseParentConsole(); #endif // RunGTest will only be set if we're in xul-unit if (mozilla::RunGTest) { gIsGtest = true; result = mozilla::RunGTest(); gIsGtest = false; } else { result = 1; printf("TEST-UNEXPECTED-FAIL | gtest | Not compiled with enable-tests\n"); } *aExitFlag = true; return result; } #if defined(MOZ_WIDGET_GTK) // display_name is owned by gdk. const char *display_name = gdk_get_display_arg_name(); bool saveDisplayArg = false; if (display_name) { saveDisplayArg = true; } else { display_name = detectDisplay(); if (!display_name) { return 1; } } #endif /* MOZ_WIDGET_GTK */ #ifdef MOZ_X11 // Init X11 in thread-safe mode. Must be called prior to the first call to XOpenDisplay // (called inside gdk_display_open). This is a requirement for off main tread compositing. XInitThreads(); #endif #if defined(MOZ_WIDGET_GTK) mGdkDisplay = gdk_display_open(display_name); if (!mGdkDisplay) { PR_fprintf(PR_STDERR, "Error: cannot open display: %s\n", display_name); return 1; } gdk_display_manager_set_default_display (gdk_display_manager_get(), mGdkDisplay); if (GDK_IS_X11_DISPLAY(mGdkDisplay)) { if (saveDisplayArg) { SaveWordToEnv("DISPLAY", nsDependentCString(display_name)); } } else { mDisableRemote = true; } #endif #ifdef MOZ_ENABLE_XREMOTE // handle --remote now that xpcom is fired up bool newInstance; { char *e = PR_GetEnv("MOZ_NO_REMOTE"); mDisableRemote = (mDisableRemote || (e && *e)); if (mDisableRemote) { newInstance = true; } else { e = PR_GetEnv("MOZ_NEW_INSTANCE"); newInstance = (e && *e); } } if (!newInstance) { nsAutoCString program(gAppData->remotingName); ToLowerCase(program); const char* username = getenv("LOGNAME"); const char* profile = nullptr; RemoteResult rr = ParseRemoteCommandLine(program, &profile, &username); if (rr == REMOTE_ARG_BAD) { return 1; } if (!username) { struct passwd *pw = getpwuid(geteuid()); if (pw && pw->pw_name) { // Beware that another call to getpwent/getpwname/getpwuid will overwrite // pw, but we don't have such another call between here and when username // is used last. username = pw->pw_name; } } nsCOMPtr<nsIFile> mutexDir; rv = GetSpecialSystemDirectory(OS_TemporaryDirectory, getter_AddRefs(mutexDir)); if (NS_SUCCEEDED(rv)) { nsAutoCString mutexPath = program + NS_LITERAL_CSTRING("_"); // In the unlikely even that LOGNAME is not set and getpwuid failed, just // don't put the username in the mutex directory. It will conflict with // other users mutex, but the worst that can happen is that they wait for // MOZ_XREMOTE_START_TIMEOUT_SEC during startup in that case. if (username) { mutexPath.Append(username); } if (profile) { mutexPath.Append(NS_LITERAL_CSTRING("_") + nsDependentCString(profile)); } mutexDir->AppendNative(mutexPath); rv = mutexDir->Create(nsIFile::DIRECTORY_TYPE, 0700); if (NS_SUCCEEDED(rv) || rv == NS_ERROR_FILE_ALREADY_EXISTS) { mRemoteLockDir = mutexDir; } } if (mRemoteLockDir) { const TimeStamp epoch = mozilla::TimeStamp::Now(); do { rv = mRemoteLock.Lock(mRemoteLockDir, nullptr); if (NS_SUCCEEDED(rv)) break; sched_yield(); } while ((TimeStamp::Now() - epoch) < TimeDuration::FromSeconds(MOZ_XREMOTE_START_TIMEOUT_SEC)); if (NS_FAILED(rv)) { NS_WARNING("Cannot lock XRemote start mutex"); } } // Try to remote the entire command line. If this fails, start up normally. const char* desktopStartupIDPtr = mDesktopStartupID.IsEmpty() ? nullptr : mDesktopStartupID.get(); rr = StartRemoteClient(desktopStartupIDPtr, program, profile, username); if (rr == REMOTE_FOUND) { *aExitFlag = true; return 0; } else if (rr == REMOTE_ARG_BAD) { return 1; } } #endif #if defined(MOZ_WIDGET_GTK) g_set_application_name(mAppData->name); gtk_window_set_auto_startup_notification(false); #if (MOZ_WIDGET_GTK == 2) gtk_widget_set_default_colormap(gdk_rgb_get_colormap()); #endif /* (MOZ_WIDGET_GTK == 2) */ #endif /* defined(MOZ_WIDGET_GTK) */ #ifdef MOZ_X11 // Do this after initializing GDK, or GDK will install its own handler. XRE_InstallX11ErrorHandler(); #endif rv = NS_CreateNativeAppSupport(getter_AddRefs(mNativeApp)); if (NS_FAILED(rv)) return 1; bool canRun = false; rv = mNativeApp->Start(&canRun); if (NS_FAILED(rv) || !canRun) { return 1; } #if defined(HAVE_DESKTOP_STARTUP_ID) && defined(MOZ_WIDGET_GTK) // DESKTOP_STARTUP_ID is cleared now, // we recover it in case we need a restart. if (!mDesktopStartupID.IsEmpty()) { nsAutoCString desktopStartupEnv; desktopStartupEnv.AssignLiteral("DESKTOP_STARTUP_ID="); desktopStartupEnv.Append(mDesktopStartupID); // Leak it with extreme prejudice! PR_SetEnv(ToNewCString(desktopStartupEnv)); } #endif #if defined(MOZ_UPDATER) && !defined(MOZ_WIDGET_ANDROID) // Check for and process any available updates nsCOMPtr<nsIFile> updRoot; bool persistent; rv = mDirProvider.GetFile(XRE_UPDATE_ROOT_DIR, &persistent, getter_AddRefs(updRoot)); // XRE_UPDATE_ROOT_DIR may fail. Fallback to appDir if failed if (NS_FAILED(rv)) updRoot = mDirProvider.GetAppDir(); // If the MOZ_TEST_PROCESS_UPDATES environment variable already exists, then // we are being called from the callback application. if (EnvHasValue("MOZ_TEST_PROCESS_UPDATES")) { // If the caller has asked us to log our arguments, do so. This is used // to make sure that the maintenance service successfully launches the // callback application. const char *logFile = nullptr; if (ARG_FOUND == CheckArg("dump-args", false, &logFile)) { FILE* logFP = fopen(logFile, "wb"); if (logFP) { for (int i = 1; i < gRestartArgc; ++i) { fprintf(logFP, "%s\n", gRestartArgv[i]); } fclose(logFP); } } *aExitFlag = true; return 0; } // Support for processing an update and exiting. The MOZ_TEST_PROCESS_UPDATES // environment variable will be part of the updater's environment and the // application that is relaunched by the updater. When the application is // relaunched by the updater it will be removed below and the application // will exit. if (CheckArg("test-process-updates")) { SaveToEnv("MOZ_TEST_PROCESS_UPDATES=1"); } nsCOMPtr<nsIFile> exeFile, exeDir; rv = mDirProvider.GetFile(XRE_EXECUTABLE_FILE, &persistent, getter_AddRefs(exeFile)); NS_ENSURE_SUCCESS(rv, 1); rv = exeFile->GetParent(getter_AddRefs(exeDir)); NS_ENSURE_SUCCESS(rv, 1); ProcessUpdates(mDirProvider.GetGREDir(), exeDir, updRoot, gRestartArgc, gRestartArgv, mAppData->version); if (EnvHasValue("MOZ_TEST_PROCESS_UPDATES")) { SaveToEnv("MOZ_TEST_PROCESS_UPDATES="); *aExitFlag = true; return 0; } #endif rv = NS_NewToolkitProfileService(getter_AddRefs(mProfileSvc)); if (rv == NS_ERROR_FILE_ACCESS_DENIED) { PR_fprintf(PR_STDERR, "Error: Access was denied while trying to open files in " \ "your profile directory.\n"); } if (NS_FAILED(rv)) { // We failed to choose or create profile - notify user and quit ProfileMissingDialog(mNativeApp); return 1; } rv = SelectProfile(getter_AddRefs(mProfileLock), mProfileSvc, mNativeApp, &mStartOffline, &mProfileName); if (rv == NS_ERROR_LAUNCHED_CHILD_PROCESS || rv == NS_ERROR_ABORT) { *aExitFlag = true; return 0; } if (NS_FAILED(rv)) { // We failed to choose or create profile - notify user and quit ProfileMissingDialog(mNativeApp); return 1; } gProfileLock = mProfileLock; rv = mProfileLock->GetDirectory(getter_AddRefs(mProfD)); NS_ENSURE_SUCCESS(rv, 1); rv = mProfileLock->GetLocalDirectory(getter_AddRefs(mProfLD)); NS_ENSURE_SUCCESS(rv, 1); rv = mDirProvider.SetProfile(mProfD, mProfLD); NS_ENSURE_SUCCESS(rv, 1); //////////////////////// NOW WE HAVE A PROFILE //////////////////////// mozilla::Telemetry::SetProfileDir(mProfD); nsAutoCString version; BuildVersion(version); #ifdef TARGET_OS_ABI NS_NAMED_LITERAL_CSTRING(osABI, TARGET_OS_ABI); #else // No TARGET_XPCOM_ABI, but at least the OS is known NS_NAMED_LITERAL_CSTRING(osABI, OS_TARGET "_UNKNOWN"); #endif // Check for version compatibility with the last version of the app this // profile was started with. The format of the version stamp is defined // by the BuildVersion function. // Also check to see if something has happened to invalidate our // fastload caches, like an extension upgrade or installation. // If we see .purgecaches, that means someone did a make. // Re-register components to catch potential changes. nsCOMPtr<nsIFile> flagFile; rv = NS_ERROR_FILE_NOT_FOUND; nsCOMPtr<nsIFile> fFlagFile; if (mAppData->directory) { rv = mAppData->directory->Clone(getter_AddRefs(fFlagFile)); } flagFile = do_QueryInterface(fFlagFile); if (flagFile) { flagFile->AppendNative(FILE_INVALIDATE_CACHES); } bool cachesOK; bool versionOK = CheckCompatibility(mProfD, version, osABI, mDirProvider.GetGREDir(), mAppData->directory, flagFile, &cachesOK); if (CheckArg("purgecaches")) { cachesOK = false; } if (PR_GetEnv("MOZ_PURGE_CACHES")) { cachesOK = false; } // Every time a profile is loaded by a build with a different version, // it updates the compatibility.ini file saying what version last wrote // the fastload caches. On subsequent launches if the version matches, // there is no need for re-registration. If the user loads the same // profile in different builds the component registry must be // re-generated to prevent mysterious component loading failures. // bool startupCacheValid = true; if (gSafeMode) { startupCacheValid = RemoveComponentRegistries(mProfD, mProfLD, false); WriteVersion(mProfD, NS_LITERAL_CSTRING("Safe Mode"), osABI, mDirProvider.GetGREDir(), mAppData->directory, !startupCacheValid); } else if (versionOK) { if (!cachesOK) { // Remove caches, forcing component re-registration. // The new list of additional components directories is derived from // information in "extensions.ini". startupCacheValid = RemoveComponentRegistries(mProfD, mProfLD, false); // Rewrite compatibility.ini to remove the flag WriteVersion(mProfD, version, osABI, mDirProvider.GetGREDir(), mAppData->directory, !startupCacheValid); } // Nothing need be done for the normal startup case. } else { // Remove caches, forcing component re-registration // with the default set of components (this disables any potentially // troublesome incompatible XPCOM components). startupCacheValid = RemoveComponentRegistries(mProfD, mProfLD, true); // Write out version WriteVersion(mProfD, version, osABI, mDirProvider.GetGREDir(), mAppData->directory, !startupCacheValid); } if (!startupCacheValid) StartupCache::IgnoreDiskCache(); if (flagFile) { flagFile->Remove(true); } return 0; } /* * XRE_mainRun - Command line startup, profile migration, and * the calling of appStartup->Run(). */ nsresult XREMain::XRE_mainRun() { nsresult rv = NS_OK; NS_ASSERTION(mScopedXPCOM, "Scoped xpcom not initialized."); #ifdef NS_FUNCTION_TIMER // initialize some common services, so we don't pay the cost for these at odd times later on; // SetWindowCreator -> ChromeRegistry -> IOService -> SocketTransportService -> (nspr wspm init), Prefs { nsCOMPtr<nsISupports> comp; comp = do_GetService("@mozilla.org/preferences-service;1"); comp = do_GetService("@mozilla.org/network/socket-transport-service;1"); comp = do_GetService("@mozilla.org/network/dns-service;1"); comp = do_GetService("@mozilla.org/network/io-service;1"); comp = do_GetService("@mozilla.org/chrome/chrome-registry;1"); comp = do_GetService("@mozilla.org/focus-event-suppressor-service;1"); } #endif rv = mScopedXPCOM->SetWindowCreator(mNativeApp); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); if (mStartOffline) { nsCOMPtr<nsIIOService2> io (do_GetService("@mozilla.org/network/io-service;1")); NS_ENSURE_TRUE(io, NS_ERROR_FAILURE); io->SetManageOfflineStatus(false); io->SetOffline(true); } { nsCOMPtr<nsIObserver> startupNotifier (do_CreateInstance(NS_APPSTARTUPNOTIFIER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); startupNotifier->Observe(nullptr, APPSTARTUP_TOPIC, nullptr); } nsCOMPtr<nsIAppStartup> appStartup (do_GetService(NS_APPSTARTUP_CONTRACTID)); NS_ENSURE_TRUE(appStartup, NS_ERROR_FAILURE); if (gDoMigration) { nsCOMPtr<nsIFile> file; mDirProvider.GetAppDir()->Clone(getter_AddRefs(file)); file->AppendNative(NS_LITERAL_CSTRING("override.ini")); nsINIParser parser; nsresult rv = parser.Init(file); // if override.ini doesn't exist, also check for distribution.ini if (NS_FAILED(rv)) { bool persistent; mDirProvider.GetFile(XRE_APP_DISTRIBUTION_DIR, &persistent, getter_AddRefs(file)); file->AppendNative(NS_LITERAL_CSTRING("distribution.ini")); rv = parser.Init(file); } if (NS_SUCCEEDED(rv)) { nsAutoCString buf; rv = parser.GetString("XRE", "EnableProfileMigrator", buf); if (NS_SUCCEEDED(rv)) { if (buf[0] == '0' || buf[0] == 'f' || buf[0] == 'F') { gDoMigration = false; } } } } { nsCOMPtr<nsIToolkitProfile> profileBeingReset; bool profileWasSelected = false; if (gDoProfileReset) { if (gResetOldProfileName.IsEmpty()) { NS_WARNING("Not resetting profile as the profile has no name."); gDoProfileReset = false; } else { rv = mProfileSvc->GetProfileByName(gResetOldProfileName, getter_AddRefs(profileBeingReset)); if (NS_FAILED(rv)) { gDoProfileReset = false; return NS_ERROR_FAILURE; } nsCOMPtr<nsIToolkitProfile> defaultProfile; // This can fail if there is no default profile. // That shouldn't stop reset from proceeding. nsresult gotSelected = mProfileSvc->GetSelectedProfile(getter_AddRefs(defaultProfile)); if (NS_SUCCEEDED(gotSelected)) { profileWasSelected = defaultProfile == profileBeingReset; } } } // Profile Migration if (mAppData->flags & NS_XRE_ENABLE_PROFILE_MIGRATOR && gDoMigration) { gDoMigration = false; nsCOMPtr<nsIProfileMigrator> pm(do_CreateInstance(NS_PROFILEMIGRATOR_CONTRACTID)); if (pm) { nsAutoCString aKey; if (gDoProfileReset) { // Automatically migrate from the current application if we just // reset the profile. // For Basilisk and Pale Moon: // Hard-code MOZ_APP_NAME to firefox because of hard-coded type in migrator. aKey = (((MOZ_APP_NAME == "basilisk") || (MOZ_APP_NAME == "palemoon")) ? "firefox" : MOZ_APP_NAME); } pm->Migrate(&mDirProvider, aKey, gResetOldProfileName); } } if (gDoProfileReset) { nsresult backupCreated = ProfileResetCleanup(profileBeingReset); if (NS_FAILED(backupCreated)) NS_WARNING("Could not cleanup the profile that was reset"); nsCOMPtr<nsIToolkitProfile> newProfile; rv = GetCurrentProfile(mProfileSvc, mProfD, getter_AddRefs(newProfile)); if (NS_SUCCEEDED(rv)) { newProfile->SetName(gResetOldProfileName); mProfileName.Assign(gResetOldProfileName); // Set the new profile as the default after we're done cleaning up the old profile, // iff that profile was already the default if (profileWasSelected) { rv = mProfileSvc->SetDefaultProfile(newProfile); if (NS_FAILED(rv)) NS_WARNING("Could not set current profile as the default"); } } else { NS_WARNING("Could not find current profile to set as default / change name."); } // Need to write out the fact that the profile has been removed, the new profile // renamed, and potentially that the selected/default profile changed. mProfileSvc->Flush(); } } mDirProvider.DoStartup(); // As FilePreferences need the profile directory, we must initialize right here. mozilla::FilePreferences::InitDirectoriesWhitelist(); mozilla::FilePreferences::InitPrefs(); OverrideDefaultLocaleIfNeeded(); appStartup->GetShuttingDown(&mShuttingDown); nsCOMPtr<nsICommandLineRunner> cmdLine; nsCOMPtr<nsIFile> workingDir; rv = NS_GetSpecialDirectory(NS_OS_CURRENT_WORKING_DIR, getter_AddRefs(workingDir)); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); if (!mShuttingDown) { cmdLine = do_CreateInstance("@mozilla.org/toolkit/command-line;1"); NS_ENSURE_TRUE(cmdLine, NS_ERROR_FAILURE); rv = cmdLine->Init(gArgc, gArgv, workingDir, nsICommandLine::STATE_INITIAL_LAUNCH); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); /* Special-case services that need early access to the command line. */ nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService(); if (obsService) { obsService->NotifyObservers(cmdLine, "command-line-startup", nullptr); } } #ifdef XP_WIN // Hack to sync up the various environment storages. XUL_APP_FILE is special // in that it comes from a different CRT (firefox.exe's static-linked copy). // Ugly details in http://bugzil.la/1175039#c27 char appFile[MAX_PATH]; if (GetEnvironmentVariableA("XUL_APP_FILE", appFile, sizeof(appFile))) { char* saved = PR_smprintf("XUL_APP_FILE=%s", appFile); PR_SetEnv(saved); PR_smprintf_free(saved); } #endif SaveStateForAppInitiatedRestart(); // clear out any environment variables which may have been set // during the relaunch process now that we know we won't be relaunching. SaveToEnv("XRE_PROFILE_PATH="); SaveToEnv("XRE_PROFILE_LOCAL_PATH="); SaveToEnv("XRE_PROFILE_NAME="); SaveToEnv("XRE_START_OFFLINE="); SaveToEnv("NO_EM_RESTART="); SaveToEnv("XUL_APP_FILE="); SaveToEnv("XRE_BINARY_PATH="); if (!mShuttingDown) { rv = appStartup->CreateHiddenWindow(); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); #ifdef MOZ_STYLO // We initialize Servo here so that the hidden DOM window is available, // since initializing Servo calls style struct constructors, and the // HackilyFindDeviceContext stuff we have right now depends on the hidden // DOM window. When we fix that, this should move back to // nsLayoutStatics.cpp Servo_Initialize(); #endif #if defined(HAVE_DESKTOP_STARTUP_ID) && defined(MOZ_WIDGET_GTK) nsGTKToolkit* toolkit = nsGTKToolkit::GetToolkit(); if (toolkit && !mDesktopStartupID.IsEmpty()) { toolkit->SetDesktopStartupID(mDesktopStartupID); } // Clear the environment variable so it won't be inherited by // child processes and confuse things. g_unsetenv ("DESKTOP_STARTUP_ID"); #endif #ifdef XP_MACOSX // we re-initialize the command-line service and do appleevents munging // after we are sure that we're not restarting cmdLine = do_CreateInstance("@mozilla.org/toolkit/command-line;1"); NS_ENSURE_TRUE(cmdLine, NS_ERROR_FAILURE); CommandLineServiceMac::SetupMacCommandLine(gArgc, gArgv, false); rv = cmdLine->Init(gArgc, gArgv, workingDir, nsICommandLine::STATE_INITIAL_LAUNCH); NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); #endif nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService(); if (obsService) obsService->NotifyObservers(nullptr, "final-ui-startup", nullptr); (void)appStartup->DoneStartingUp(); appStartup->GetShuttingDown(&mShuttingDown); } if (!mShuttingDown) { rv = cmdLine->Run(); NS_ENSURE_SUCCESS_LOG(rv, NS_ERROR_FAILURE); appStartup->GetShuttingDown(&mShuttingDown); } if (!mShuttingDown) { #ifdef MOZ_ENABLE_XREMOTE // if we have X remote support, start listening for requests on the // proxy window. if (!mDisableRemote) mRemoteService = do_GetService("@mozilla.org/toolkit/remote-service;1"); if (mRemoteService) mRemoteService->Startup(mAppData->remotingName, mProfileName.get()); if (mRemoteLockDir) { mRemoteLock.Unlock(); mRemoteLockDir->Remove(false); } #endif /* MOZ_ENABLE_XREMOTE */ mNativeApp->Enable(); } #ifdef MOZ_INSTRUMENT_EVENT_LOOP if (PR_GetEnv("MOZ_INSTRUMENT_EVENT_LOOP")) { bool logToConsole = true; mozilla::InitEventTracing(logToConsole); } #endif /* MOZ_INSTRUMENT_EVENT_LOOP */ { rv = appStartup->Run(); if (NS_FAILED(rv)) { NS_ERROR("failed to run appstartup"); gLogConsoleErrors = true; } } #ifdef MOZ_STYLO // This, along with the call to Servo_Initialize, should eventually move back // to nsLayoutStatics.cpp. Servo_Shutdown(); #endif return rv; } #if MOZ_WIDGET_GTK == 2 void XRE_GlibInit() { static bool ran_once = false; // glib < 2.24 doesn't want g_thread_init to be invoked twice, so ensure // we only do it once. No need for thread safety here, since this is invoked // well before any thread is spawned. if (!ran_once) { // glib version < 2.36 doesn't initialize g_slice in a static initializer. // Ensure this happens through g_thread_init (glib version < 2.32) or // g_type_init (2.32 <= gLib version < 2.36)." g_thread_init(nullptr); g_type_init(); ran_once = true; } } #endif // Separate stub function to let us specifically suppress it in Valgrind void XRE_CreateStatsObject() { // Initialize global variables used by histogram collection // machinery that is used by by Telemetry. Note: is never de-initialised. Telemetry::CreateStatisticsRecorder(); } /* * XRE_main - A class based main entry point used by most platforms. * Note that on OSX, aAppData->xreDirectory will point to * .app/Contents/Resources. */ int XREMain::XRE_main(int argc, char* argv[], const nsXREAppData* aAppData) { ScopedLogging log; // NB: this must happen after the creation of |ScopedLogging log| since // ScopedLogging::ScopedLogging calls NS_LogInit, and // XRE_CreateStatsObject calls Telemetry::CreateStatisticsRecorder, // and NS_LogInit must be called before Telemetry::CreateStatisticsRecorder. // NS_LogInit must be called before Telemetry::CreateStatisticsRecorder // so as to avoid many log messages of the form // WARNING: XPCOM objects created/destroyed from static ctor/dtor: [..] // See bug 1279614. XRE_CreateStatsObject(); char aLocal; GeckoProfilerInitRAII profilerGuard(&aLocal); PROFILER_LABEL("Startup", "XRE_Main", js::ProfileEntry::Category::OTHER); nsresult rv = NS_OK; gArgc = argc; gArgv = argv; NS_ENSURE_TRUE(aAppData, 2); mAppData = new ScopedAppData(aAppData); if (!mAppData) return 1; if (!mAppData->remotingName) { SetAllocatedString(mAppData->remotingName, mAppData->name); } // used throughout this file gAppData = mAppData; nsCOMPtr<nsIFile> binFile; rv = XRE_GetBinaryPath(argv[0], getter_AddRefs(binFile)); NS_ENSURE_SUCCESS(rv, 1); rv = binFile->GetPath(gAbsoluteArgv0Path); NS_ENSURE_SUCCESS(rv, 1); mozilla::IOInterposerInit ioInterposerGuard; #if defined(XP_WIN) // Some COM settings are global to the process and must be set before any non- // trivial COM is run in the application. Since these settings may affect // stability, we should instantiate COM ASAP so that we can ensure that these // global settings are configured before anything can interfere. mozilla::mscom::MainThreadRuntime msCOMRuntime; #endif #if MOZ_WIDGET_GTK == 2 XRE_GlibInit(); #endif // init bool exit = false; int result = XRE_mainInit(&exit); if (result != 0 || exit) return result; // startup result = XRE_mainStartup(&exit); if (result != 0 || exit) return result; bool appInitiatedRestart = false; // Start the real application mScopedXPCOM = MakeUnique<ScopedXPCOMStartup>(); if (!mScopedXPCOM) return 1; rv = mScopedXPCOM->Initialize(); NS_ENSURE_SUCCESS(rv, 1); // run! rv = XRE_mainRun(); #ifdef MOZ_INSTRUMENT_EVENT_LOOP mozilla::ShutdownEventTracing(); #endif gAbsoluteArgv0Path.Truncate(); // Check for an application initiated restart. This is one that // corresponds to nsIAppStartup.quit(eRestart) if (rv == NS_SUCCESS_RESTART_APP || rv == NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE) { appInitiatedRestart = true; // We have an application restart don't do any shutdown checks here // In particular we don't want to poison IO for checking late-writes. gShutdownChecks = SCM_NOTHING; } if (!mShuttingDown) { #ifdef MOZ_ENABLE_XREMOTE // shut down the x remote proxy window if (mRemoteService) { mRemoteService->Shutdown(); } #endif /* MOZ_ENABLE_XREMOTE */ } mScopedXPCOM = nullptr; #if defined(XP_WIN) mozilla::widget::StopAudioSession(); #endif // unlock the profile after ScopedXPCOMStartup object (xpcom) // has gone out of scope. see bug #386739 for more details mProfileLock->Unlock(); gProfileLock = nullptr; // Restart the app after XPCOM has been shut down cleanly. if (appInitiatedRestart) { RestoreStateForAppInitiatedRestart(); if (rv != NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE) { // Ensure that these environment variables are set: SaveFileToEnvIfUnset("XRE_PROFILE_PATH", mProfD); SaveFileToEnvIfUnset("XRE_PROFILE_LOCAL_PATH", mProfLD); SaveWordToEnvIfUnset("XRE_PROFILE_NAME", mProfileName); } #ifdef MOZ_WIDGET_GTK MOZ_gdk_display_close(mGdkDisplay); #endif { rv = LaunchChild(mNativeApp, true); } return rv == NS_ERROR_LAUNCHED_CHILD_PROCESS ? 0 : 1; } #ifdef MOZ_WIDGET_GTK // gdk_display_close also calls gdk_display_manager_set_default_display // appropriately when necessary. MOZ_gdk_display_close(mGdkDisplay); #endif XRE_DeinitCommandLine(); return NS_FAILED(rv) ? 1 : 0; } void XRE_StopLateWriteChecks(void) { mozilla::StopLateWriteChecks(); } int XRE_main(int argc, char* argv[], const nsXREAppData* aAppData, uint32_t aFlags) { XREMain main; int result = main.XRE_main(argc, argv, aAppData); mozilla::RecordShutdownEndTimeStamp(); return result; } nsresult XRE_InitCommandLine(int aArgc, char* aArgv[]) { nsresult rv = NS_OK; #if defined(OS_WIN) CommandLine::Init(aArgc, aArgv); #else // these leak on error, but that's OK: we'll just exit() char** canonArgs = new char*[aArgc]; // get the canonical version of the binary's path nsCOMPtr<nsIFile> binFile; rv = XRE_GetBinaryPath(aArgv[0], getter_AddRefs(binFile)); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; nsAutoCString canonBinPath; rv = binFile->GetNativePath(canonBinPath); if (NS_FAILED(rv)) return NS_ERROR_FAILURE; canonArgs[0] = strdup(canonBinPath.get()); for (int i = 1; i < aArgc; ++i) { if (aArgv[i]) { canonArgs[i] = strdup(aArgv[i]); } } NS_ASSERTION(!CommandLine::IsInitialized(), "Bad news!"); CommandLine::Init(aArgc, canonArgs); for (int i = 0; i < aArgc; ++i) free(canonArgs[i]); delete[] canonArgs; #endif const char *path = nullptr; ArgResult ar = CheckArg("greomni", false, &path); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --greomni requires a path argument\n"); return NS_ERROR_FAILURE; } if (!path) return rv; nsCOMPtr<nsIFile> greOmni; rv = XRE_GetFileFromPath(path, getter_AddRefs(greOmni)); if (NS_FAILED(rv)) { PR_fprintf(PR_STDERR, "Error: argument --greomni requires a valid path\n"); return rv; } ar = CheckArg("appomni", false, &path); if (ar == ARG_BAD) { PR_fprintf(PR_STDERR, "Error: argument --appomni requires a path argument\n"); return NS_ERROR_FAILURE; } nsCOMPtr<nsIFile> appOmni; if (path) { rv = XRE_GetFileFromPath(path, getter_AddRefs(appOmni)); if (NS_FAILED(rv)) { PR_fprintf(PR_STDERR, "Error: argument --appomni requires a valid path\n"); return rv; } } mozilla::Omnijar::Init(greOmni, appOmni); return rv; } nsresult XRE_DeinitCommandLine() { nsresult rv = NS_OK; CommandLine::Terminate(); return rv; } GeckoProcessType XRE_GetProcessType() { return mozilla::startup::sChildProcessType; } bool XRE_IsGPUProcess() { return XRE_GetProcessType() == GeckoProcessType_GPU; } bool XRE_IsParentProcess() { return XRE_GetProcessType() == GeckoProcessType_Default; } bool XRE_IsContentProcess() { return XRE_GetProcessType() == GeckoProcessType_Content; } // If you add anything to this enum, please update about:support to reflect it enum { kE10sEnabledByUser = 0, kE10sEnabledByDefault = 1, kE10sDisabledByUser = 2, // kE10sDisabledInSafeMode = 3, was removed in bug 1172491. kE10sDisabledForAccessibility = 4, // kE10sDisabledForMacGfx = 5, was removed in bug 1068674. // kE10sDisabledForBidi = 6, removed in bug 1309599 kE10sDisabledForAddons = 7, kE10sForceDisabled = 8, // kE10sDisabledForXPAcceleration = 9, removed in bug 1296353 // kE10sDisabledForOperatingSystem = 10, removed due to xp-eol }; const char* kAccessibilityLastRunDatePref = "accessibility.lastLoadDate"; const char* kAccessibilityLoadedLastSessionPref = "accessibility.loadedInLastSession"; #if defined(XP_WIN) static inline uint32_t PRTimeToSeconds(PRTime t_usec) { PRTime usec_per_sec = PR_USEC_PER_SEC; return uint32_t(t_usec /= usec_per_sec); } #endif const char* kForceEnableE10sPref = "browser.tabs.remote.force-enable"; const char* kForceDisableE10sPref = "browser.tabs.remote.force-disable"; uint32_t MultiprocessBlockPolicy() { if (gMultiprocessBlockPolicyInitialized) { return gMultiprocessBlockPolicy; } gMultiprocessBlockPolicyInitialized = true; /** * Avoids enabling e10s if there are add-ons installed. */ bool addonsCanDisable = Preferences::GetBool("extensions.e10sBlocksEnabling", false); bool disabledByAddons = Preferences::GetBool("extensions.e10sBlockedByAddons", false); if (addonsCanDisable && disabledByAddons) { gMultiprocessBlockPolicy = kE10sDisabledForAddons; } #if defined(XP_WIN) bool disabledForA11y = false; /** * Avoids enabling e10s if accessibility has recently loaded. Performs the * following checks: * 1) Checks a pref indicating if a11y loaded in the last session. This pref * is set in nsBrowserGlue.js. If a11y was loaded in the last session we * do not enable e10s in this session. * 2) Accessibility stores a last run date (PR_IntervalNow) when it is * initialized (see nsBaseWidget.cpp). We check if this pref exists and * compare it to now. If a11y hasn't run in an extended period of time or * if the date pref does not exist we load e10s. */ disabledForA11y = Preferences::GetBool(kAccessibilityLoadedLastSessionPref, false); if (!disabledForA11y && Preferences::HasUserValue(kAccessibilityLastRunDatePref)) { #define ONE_WEEK_IN_SECONDS (60*60*24*7) uint32_t a11yRunDate = Preferences::GetInt(kAccessibilityLastRunDatePref, 0); MOZ_ASSERT(0 != a11yRunDate); // If a11y hasn't run for a period of time, clear the pref and load e10s uint32_t now = PRTimeToSeconds(PR_Now()); uint32_t difference = now - a11yRunDate; if (difference > ONE_WEEK_IN_SECONDS || !a11yRunDate) { Preferences::ClearUser(kAccessibilityLastRunDatePref); } else { disabledForA11y = true; } } if (disabledForA11y) { gMultiprocessBlockPolicy = kE10sDisabledForAccessibility; } #endif // We do not support E10S, block by policy. gMultiprocessBlockPolicy = kE10sForceDisabled; return gMultiprocessBlockPolicy; } bool mozilla::BrowserTabsRemoteAutostart() { if (gBrowserTabsRemoteAutostartInitialized) { return gBrowserTabsRemoteAutostart; } gBrowserTabsRemoteAutostartInitialized = true; // If we're in the content process, we are running E10S. if (XRE_IsContentProcess()) { gBrowserTabsRemoteAutostart = true; return gBrowserTabsRemoteAutostart; } bool optInPref = Preferences::GetBool("browser.tabs.remote.autostart", false); bool trialPref = Preferences::GetBool("browser.tabs.remote.autostart.2", false); bool prefEnabled = optInPref || trialPref; int status; if (optInPref) { status = kE10sEnabledByUser; } else if (trialPref) { status = kE10sEnabledByDefault; } else { status = kE10sDisabledByUser; } if (prefEnabled) { uint32_t blockPolicy = MultiprocessBlockPolicy(); if (blockPolicy != 0) { status = blockPolicy; } else { gBrowserTabsRemoteAutostart = true; } } // Uber override pref for manual testing purposes if (Preferences::GetBool(kForceEnableE10sPref, false)) { gBrowserTabsRemoteAutostart = true; prefEnabled = true; status = kE10sEnabledByUser; } // Uber override pref for emergency blocking if (gBrowserTabsRemoteAutostart && (Preferences::GetBool(kForceDisableE10sPref, false) || EnvHasValue("MOZ_FORCE_DISABLE_E10S"))) { gBrowserTabsRemoteAutostart = false; status = kE10sForceDisabled; } gBrowserTabsRemoteStatus = status; mozilla::Telemetry::Accumulate(mozilla::Telemetry::E10S_STATUS, status); if (prefEnabled) { mozilla::Telemetry::Accumulate(mozilla::Telemetry::E10S_BLOCKED_FROM_RUNNING, !gBrowserTabsRemoteAutostart); } return gBrowserTabsRemoteAutostart; } void SetupErrorHandling(const char* progname) { #ifdef XP_WIN /* On Windows XPSP3 and Windows Vista if DEP is configured off-by-default we still want DEP protection: enable it explicitly and programmatically. This function is not available on WinXPSP2 so we dynamically load it. */ HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll"); SetProcessDEPPolicyFunc _SetProcessDEPPolicy = (SetProcessDEPPolicyFunc) GetProcAddress(kernel32, "SetProcessDEPPolicy"); if (_SetProcessDEPPolicy) _SetProcessDEPPolicy(PROCESS_DEP_ENABLE); #endif #ifdef XP_WIN32 // Suppress the "DLL Foo could not be found" dialog, such that if dependent // libraries (such as GDI+) are not preset, we gracefully fail to load those // XPCOM components, instead of being ungraceful. UINT realMode = SetErrorMode(0); realMode |= SEM_FAILCRITICALERRORS; // If XRE_NO_WINDOWS_CRASH_DIALOG is set, suppress displaying the "This // application has crashed" dialog box. This is mainly useful for // automated testing environments, e.g. tinderbox, where there's no need // for a dozen of the dialog boxes to litter the console if (getenv("XRE_NO_WINDOWS_CRASH_DIALOG")) realMode |= SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX; SetErrorMode(realMode); #endif #if defined (DEBUG) && defined(XP_WIN) // Send MSCRT Warnings, Errors and Assertions to stderr. // See http://msdn.microsoft.com/en-us/library/1y71x448(v=VS.80).aspx // and http://msdn.microsoft.com/en-us/library/a68f826y(v=VS.80).aspx. _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE); _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE); _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR); _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE); _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); _CrtSetReportHook(MSCRTReportHook); #endif InstallSignalHandlers(progname); // Unbuffer stdout, needed for tinderbox tests. setbuf(stdout, 0); } void OverrideDefaultLocaleIfNeeded() { // Read pref to decide whether to override default locale with US English. if (mozilla::Preferences::GetBool("javascript.use_us_english_locale", false)) { // Set the application-wide C-locale. Needed to resist fingerprinting // of Date.toLocaleFormat(). We use the locale to "C.UTF-8" if possible, // to avoid interfering with non-ASCII keyboard input on some Linux desktops. // Otherwise fall back to the "C" locale, which is available on all platforms. setlocale(LC_ALL, "C.UTF-8") || setlocale(LC_ALL, "C"); } } void XRE_EnableSameExecutableForContentProc() { if (!PR_GetEnv("MOZ_SEPARATE_CHILD_PROCESS")) { mozilla::ipc::GeckoChildProcessHost::EnableSameExecutableForContentProc(); } }