int main(int argc, char* argv[])
{
ScopedLogging log;
nsCOMPtr<nsILocalFile> appini;
nsresult rv = XRE_GetBinaryPath(argv[0], getter_AddRefs(appini));
if (NS_FAILED(rv)) {
Output("Couldn't calculate the application directory.");
return 255;
}
appini->SetNativeLeafName(NS_LITERAL_CSTRING("application.ini"));
// Allow firefox.exe to launch XULRunner apps via -app <application.ini>
// Note that -app must be the *first* argument.
char *appEnv = nsnull;
const char *appDataFile = PR_GetEnv("XUL_APP_FILE");
if (appDataFile && *appDataFile) {
rv = XRE_GetFileFromPath(appDataFile, getter_AddRefs(appini));
if (NS_FAILED(rv)) {
Output("Invalid path found: '%s'", appDataFile);
return 255;
}
}
else if (argc > 1 && IsArg(argv[1], "app")) {
if (argc == 2) {
Output("Incorrect number of arguments passed to -app");
return 255;
}
rv = XRE_GetFileFromPath(argv[2], getter_AddRefs(appini));
if (NS_FAILED(rv)) {
Output("application.ini path not recognized: '%s'", argv[2]);
return 255;
}
appEnv = PR_smprintf("XUL_APP_FILE=%s", argv[2]);
PR_SetEnv(appEnv);
argv[2] = argv[0];
argv += 2;
argc -= 2;
}
nsXREAppData *appData;
rv = XRE_CreateAppData(appini, &appData);
if (NS_FAILED(rv)) {
Output("Couldn't read application.ini");
return 255;
}
int result = XRE_main(argc, argv, appData);
XRE_FreeAppData(appData);
if (appEnv)
PR_smprintf_free(appEnv);
return result;
}
static int
InstallXULApp(nsIFile* aXULRunnerDir,
const char *aAppLocation,
const char *aInstallTo,
const char *aLeafName)
{
nsCOMPtr<nsILocalFile> appLocation;
nsCOMPtr<nsILocalFile> installTo;
nsString leafName;
nsresult rv = XRE_GetFileFromPath(aAppLocation, getter_AddRefs(appLocation));
if (NS_FAILED(rv))
return 2;
if (aInstallTo) {
rv = XRE_GetFileFromPath(aInstallTo, getter_AddRefs(installTo));
if (NS_FAILED(rv))
return 2;
}
if (aLeafName)
NS_CStringToUTF16(nsDependentCString(aLeafName),
NS_CSTRING_ENCODING_NATIVE_FILESYSTEM, leafName);
rv = NS_InitXPCOM2(nsnull, aXULRunnerDir, nsnull);
if (NS_FAILED(rv))
return 3;
{
// Scope our COMPtr to avoid holding XPCOM refs beyond xpcom shutdown
nsCOMPtr<nsIXULAppInstall> install
(do_GetService("@mozilla.org/xulrunner/app-install-service;1"));
if (!install) {
rv = NS_ERROR_FAILURE;
}
else {
rv = install->InstallApplication(appLocation, installTo, leafName);
}
}
NS_ShutdownXPCOM(nsnull);
if (NS_FAILED(rv))
return 3;
return 0;
}
void xxxNeverCalledXUL()
{
XRE_main(0, nsnull, nsnull);
XRE_GetFileFromPath(nsnull, nsnull);
XRE_GetStaticComponents(nsnull, nsnull);
XRE_InitEmbedding(nsnull, nsnull, nsnull, nsnull, 0);
XRE_TermEmbedding();
}
void xxxNeverCalledXUL()
{
XRE_main(0, nsnull, nsnull);
XRE_GetFileFromPath(nsnull, nsnull);
XRE_GetStaticComponents(nsnull, nsnull);
XRE_LockProfileDirectory(nsnull, nsnull);
XRE_InitEmbedding(nsnull, nsnull, nsnull, nsnull, 0);
XRE_NotifyProfile();
XRE_TermEmbedding();
XRE_CreateAppData(nsnull, nsnull);
XRE_ParseAppData(nsnull, nsnull);
XRE_FreeAppData(nsnull);
}
int main(int argc, char* argv[])
{
if (argc > 1 && (IsArg(argv[1], "h") ||
IsArg(argv[1], "help") ||
IsArg(argv[1], "?")))
{
Usage(argv[0]);
return 0;
}
if (argc == 2 && (IsArg(argv[1], "v") || IsArg(argv[1], "version")))
{
nsCAutoString milestone;
nsCAutoString version;
GetGREVersion(argv[0], &milestone, &version);
Output(PR_FALSE, "Mozilla XULRunner %s - %s\n",
milestone.get(), version.get());
return 0;
}
if (argc > 1) {
nsCAutoString milestone;
nsresult rv = GetGREVersion(argv[0], &milestone, nsnull);
if (NS_FAILED(rv))
return 2;
if (IsArg(argv[1], "gre-version")) {
if (argc != 2) {
Usage(argv[0]);
return 1;
}
printf("%s\n", milestone.get());
return 0;
}
if (IsArg(argv[1], "install-app")) {
if (argc < 3 || argc > 5) {
Usage(argv[0]);
return 1;
}
char *appLocation = argv[2];
char *installTo = nsnull;
if (argc > 3) {
installTo = argv[3];
if (!*installTo) // left blank?
installTo = nsnull;
}
char *leafName = nsnull;
if (argc > 4) {
leafName = argv[4];
if (!*leafName)
leafName = nsnull;
}
nsCOMPtr<nsIFile> regDir;
rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir));
if (NS_FAILED(rv))
return 2;
return InstallXULApp(regDir, appLocation, installTo, leafName);
}
}
const char *appDataFile = PR_GetEnv("XUL_APP_FILE");
if (!(appDataFile && *appDataFile)) {
if (argc < 2) {
Usage(argv[0]);
return 1;
}
if (IsArg(argv[1], "app")) {
if (argc == 2) {
Usage(argv[0]);
return 1;
}
argv[1] = argv[0];
++argv;
--argc;
}
appDataFile = argv[1];
argv[1] = argv[0];
++argv;
--argc;
static char kAppEnv[MAXPATHLEN];
PR_snprintf(kAppEnv, MAXPATHLEN, "XUL_APP_FILE=%s", appDataFile);
PR_SetEnv(kAppEnv);
}
nsCOMPtr<nsILocalFile> appDataLF;
nsresult rv = XRE_GetFileFromPath(appDataFile, getter_AddRefs(appDataLF));
if (NS_FAILED(rv)) {
Output(PR_TRUE, "Error: unrecognized application.ini path.\n");
return 2;
}
AutoAppData appData(appDataLF);
if (!appData) {
Output(PR_TRUE, "Error: couldn't parse application.ini.\n");
return 2;
}
return XRE_main(argc, argv, appData);
}
void
WriteConsoleLog()
{
nsresult rv;
nsCOMPtr<nsILocalFile> lfile;
char* logFileEnv = PR_GetEnv("XRE_CONSOLE_LOG");
if (logFileEnv && *logFileEnv) {
rv = XRE_GetFileFromPath(logFileEnv, getter_AddRefs(lfile));
if (NS_FAILED(rv))
return;
}
else {
if (!gLogConsoleErrors)
return;
rv = gDirServiceProvider->GetUserAppDataDirectory(getter_AddRefs(lfile));
if (NS_FAILED(rv))
return;
lfile->AppendNative(NS_LITERAL_CSTRING("console.log"));
}
PRFileDesc *file;
rv = lfile->OpenNSPRFileDesc(PR_WRONLY | PR_APPEND | PR_CREATE_FILE,
0660, &file);
if (NS_FAILED(rv))
return;
nsCOMPtr<nsIConsoleService> csrv
(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
if (!csrv) {
PR_Close(file);
return;
}
nsIConsoleMessage** messages;
PRUint32 mcount;
rv = csrv->GetMessageArray(&messages, &mcount);
if (NS_FAILED(rv)) {
PR_Close(file);
return;
}
if (mcount) {
PRExplodedTime etime;
PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &etime);
char datetime[512];
PR_FormatTimeUSEnglish(datetime, sizeof(datetime),
"%Y-%m-%d %H:%M:%S", &etime);
PR_fprintf(file, NS_LINEBREAK
"*** Console log: %s ***" NS_LINEBREAK,
datetime);
}
// From this point on, we have to release all the messages, and free
// the memory allocated for the messages array. XPCOM arrays suck.
nsXPIDLString msg;
nsCAutoString nativemsg;
for (PRUint32 i = 0; i < mcount; ++i) {
rv = messages[i]->GetMessage(getter_Copies(msg));
if (NS_SUCCEEDED(rv)) {
NS_CopyUnicodeToNative(msg, nativemsg);
PR_fprintf(file, "%s" NS_LINEBREAK, nativemsg.get());
}
NS_IF_RELEASE(messages[i]);
}
PR_Close(file);
NS_Free(messages);
}
bool
ContentProcess::Init(int aArgc, char* aArgv[])
{
// If passed in grab the application path for xpcom init
bool foundAppdir = false;
bool foundChildID = false;
bool foundIsForBrowser = false;
bool foundIntPrefs = false;
bool foundBoolPrefs = false;
bool foundStringPrefs = false;
uint64_t childID;
bool isForBrowser;
#if defined(XP_MACOSX) && defined(MOZ_CONTENT_SANDBOX)
// If passed in grab the profile path for sandboxing
bool foundProfile = false;
nsCOMPtr<nsIFile> profileDir;
#endif
InfallibleTArray<PrefSetting> prefsArray;
for (int idx = aArgc; idx > 0; idx--) {
if (!aArgv[idx]) {
continue;
}
if (!strcmp(aArgv[idx], "-appdir")) {
MOZ_ASSERT(!foundAppdir);
if (foundAppdir) {
continue;
}
nsCString appDir;
appDir.Assign(nsDependentCString(aArgv[idx+1]));
mXREEmbed.SetAppDir(appDir);
foundAppdir = true;
} else if (!strcmp(aArgv[idx], "-childID")) {
MOZ_ASSERT(!foundChildID);
if (foundChildID) {
continue;
}
if (idx + 1 < aArgc) {
childID = strtoull(aArgv[idx + 1], nullptr, 10);
foundChildID = true;
}
} else if (!strcmp(aArgv[idx], "-isForBrowser") || !strcmp(aArgv[idx], "-notForBrowser")) {
MOZ_ASSERT(!foundIsForBrowser);
if (foundIsForBrowser) {
continue;
}
isForBrowser = strcmp(aArgv[idx], "-notForBrowser");
foundIsForBrowser = true;
} else if (!strcmp(aArgv[idx], "-intPrefs")) {
SET_PREF_PHASE(BEGIN_INIT_PREFS);
char* str = aArgv[idx + 1];
while (*str) {
int32_t index = strtol(str, &str, 10);
MOZ_ASSERT(str[0] == ':');
str++;
MaybePrefValue value(PrefValue(static_cast<int32_t>(strtol(str, &str, 10))));
MOZ_ASSERT(str[0] == '|');
str++;
PrefSetting pref(nsCString(ContentPrefs::GetContentPref(index)), value, MaybePrefValue());
prefsArray.AppendElement(pref);
}
SET_PREF_PHASE(END_INIT_PREFS);
foundIntPrefs = true;
} else if (!strcmp(aArgv[idx], "-boolPrefs")) {
SET_PREF_PHASE(BEGIN_INIT_PREFS);
char* str = aArgv[idx + 1];
while (*str) {
int32_t index = strtol(str, &str, 10);
MOZ_ASSERT(str[0] == ':');
str++;
MaybePrefValue value(PrefValue(!!strtol(str, &str, 10)));
MOZ_ASSERT(str[0] == '|');
str++;
PrefSetting pref(nsCString(ContentPrefs::GetContentPref(index)), value, MaybePrefValue());
prefsArray.AppendElement(pref);
}
SET_PREF_PHASE(END_INIT_PREFS);
foundBoolPrefs = true;
} else if (!strcmp(aArgv[idx], "-stringPrefs")) {
SET_PREF_PHASE(BEGIN_INIT_PREFS);
char* str = aArgv[idx + 1];
while (*str) {
int32_t index = strtol(str, &str, 10);
MOZ_ASSERT(str[0] == ':');
str++;
int32_t length = strtol(str, &str, 10);
MOZ_ASSERT(str[0] == ';');
str++;
MaybePrefValue value(PrefValue(nsCString(str, length)));
PrefSetting pref(nsCString(ContentPrefs::GetContentPref(index)), value, MaybePrefValue());
prefsArray.AppendElement(pref);
str += length + 1;
MOZ_ASSERT(*(str - 1) == '|');
}
SET_PREF_PHASE(END_INIT_PREFS);
foundStringPrefs = true;
}
else if (!strcmp(aArgv[idx], "-safeMode")) {
gSafeMode = true;
}
#if defined(XP_MACOSX) && defined(MOZ_CONTENT_SANDBOX)
else if (!strcmp(aArgv[idx], "-profile")) {
MOZ_ASSERT(!foundProfile);
if (foundProfile) {
continue;
}
bool flag;
nsresult rv = XRE_GetFileFromPath(aArgv[idx+1], getter_AddRefs(profileDir));
if (NS_FAILED(rv) ||
NS_FAILED(profileDir->Exists(&flag)) || !flag) {
NS_WARNING("Invalid profile directory passed to content process.");
profileDir = nullptr;
}
foundProfile = true;
}
#endif /* XP_MACOSX && MOZ_CONTENT_SANDBOX */
bool allFound = foundAppdir && foundChildID && foundIsForBrowser && foundIntPrefs && foundBoolPrefs && foundStringPrefs;
#if defined(XP_MACOSX) && defined(MOZ_CONTENT_SANDBOX)
allFound &= foundProfile;
#endif
if (allFound) {
break;
}
}
Preferences::SetInitPreferences(&prefsArray);
mContent.Init(IOThreadChild::message_loop(),
ParentPid(),
IOThreadChild::channel(),
childID,
isForBrowser);
mXREEmbed.Start();
#if (defined(XP_MACOSX)) && defined(MOZ_CONTENT_SANDBOX)
mContent.SetProfileDir(profileDir);
#endif
#if (defined(XP_WIN) || defined(XP_MACOSX)) && defined(MOZ_CONTENT_SANDBOX)
SetUpSandboxEnvironment();
#endif
return true;
}
/**
* Parse application data.
*/
static int LoadAppData(const char* appDataFile, nsXREAppData* aResult,
nsCString& vendor, nsCString& name, nsCString& version,
nsCString& buildID, nsCString& appID,
nsCString& copyright)
{
nsresult rv;
nsCOMPtr<nsILocalFile> lf;
XRE_GetFileFromPath(appDataFile, getter_AddRefs(lf));
if (!lf)
return 2;
nsCOMPtr<nsIFile> appDir;
rv = lf->GetParent(getter_AddRefs(appDir));
if (NS_FAILED(rv))
return 2;
rv = CallQueryInterface(appDir, &aResult->directory);
if (NS_FAILED(rv))
return 2;
nsINIParser parser;
rv = parser.Init(lf);
if (NS_FAILED(rv))
return 2;
// Gecko version checking
//
// TODO: If these version checks fail, then look for a compatible XULRunner
// version on the system, and launch it instead.
nsCAutoString gkVersion;
rv = parser.GetString("Gecko", "MinVersion", gkVersion);
if (NS_FAILED(rv) || !CheckMinVersion(gkVersion.get())) {
Output(PR_TRUE, "Error: Gecko MinVersion requirement not met.\n");
return 1;
}
rv = parser.GetString("Gecko", "MaxVersion", gkVersion);
if (NS_SUCCEEDED(rv) && !CheckMaxVersion(gkVersion.get())) {
Output(PR_TRUE, "Error: Gecko MaxVersion requirement not met.\n");
return 1;
}
PRUint32 i;
// Read string-valued fields
const struct
{
const char *key;
const char **fill;
nsCString *buf;
PRBool required;
} string_fields[] = {
{ "Vendor", &aResult->vendor, &vendor, PR_FALSE },
{ "Name", &aResult->name, &name, PR_TRUE },
{ "Version", &aResult->version, &version, PR_FALSE },
{ "BuildID", &aResult->buildID, &buildID, PR_TRUE },
{ "ID", &aResult->ID, &appID, PR_FALSE },
{ "Copyright", &aResult->copyright, ©right, PR_FALSE }
};
for (i = 0; i < NS_ARRAY_LENGTH(string_fields); ++i) {
rv = parser.GetString("App", string_fields[i].key,
*string_fields[i].buf);
if (NS_SUCCEEDED(rv)) {
*string_fields[i].fill = string_fields[i].buf->get();
}
else if (string_fields[i].required) {
Output(PR_TRUE, "Error: %x: No \"%s\" field.\n",
rv, string_fields[i].key);
return 1;
}
}
// Read boolean-valued fields
const struct {
const char* key;
PRUint32 flag;
} boolean_fields[] = {
{ "EnableProfileMigrator", NS_XRE_ENABLE_PROFILE_MIGRATOR },
{ "EnableExtensionManager", NS_XRE_ENABLE_EXTENSION_MANAGER }
};
char buf[6]; // large enough to hold "false"
aResult->flags = 0;
for (i = 0; i < NS_ARRAY_LENGTH(boolean_fields); ++i) {
rv = parser.GetString("XRE", boolean_fields[i].key, buf, sizeof(buf));
// accept a truncated result since we are only interested in the
// first character. this is designed to allow the possibility of
// expanding these boolean attributes to express additional options.
if ((NS_SUCCEEDED(rv) || rv == NS_ERROR_LOSS_OF_SIGNIFICANT_DATA) &&
(buf[0] == '1' || buf[0] == 't' || buf[0] == 'T')) {
aResult->flags |= boolean_fields[i].flag;
}
}
#ifdef DEBUG
printf("---------------------------------------------------------\n");
printf(" Vendor %s\n", aResult->vendor);
printf(" Name %s\n", aResult->name);
printf(" Version %s\n", aResult->version);
printf(" BuildID %s\n", aResult->buildID);
printf(" Copyright %s\n", aResult->copyright);
printf(" Flags %08x\n", aResult->flags);
printf("---------------------------------------------------------\n");
#endif
return 0;
}
