xulrunner/app/nsXULRunnerApp.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "nsXULAppAPI.h"
   6 #include "nsXPCOMGlue.h"
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #ifdef XP_WIN
  10 #include <windows.h>
  11 #define snprintf _snprintf
  12 #define strcasecmp _stricmp
  13 #endif
  14
  15 #include "nsAppRunner.h"
  16 #include "nsIFile.h"
  17 #include "nsCOMPtr.h"
  18 #include "nsMemory.h"
  19 #include "nsCRTGlue.h"
  20 #include "nsStringAPI.h"
  21 #include "nsServiceManagerUtils.h"
  22 #include "plstr.h"
  23 #include "prprf.h"
  24 #include "prenv.h"
  25 #include "nsINIParser.h"
  26
  27 #ifdef XP_WIN
  28 #define XRE_DONT_SUPPORT_XPSP2 // See https://bugzil.la/1023941#c32
  29 #include "nsWindowsWMain.cpp"
  30 #endif
  31
  32 #include "BinaryPath.h"
  33
  34 #include "nsXPCOMPrivate.h" // for MAXPATHLEN and XPCOM_DLL
  35
  36 using namespace mozilla;
  37
  38 /**
  39  * Output a string to the user.  This method is really only meant to be used to
  40  * output last-ditch error messages designed for developers NOT END USERS.
  41  *
  42  * @param isError
  43  *        Pass true to indicate severe errors.
  44  * @param fmt
  45  *        printf-style format string followed by arguments.
  46  */
  47 static void Output(bool isError, const char *fmt, ... )
  48 {
  49   va_list ap;
  50   va_start(ap, fmt);
  51
  52 #if (defined(XP_WIN) && !MOZ_WINCONSOLE)
  53   wchar_t msg[2048];
  54   _vsnwprintf(msg, sizeof(msg)/sizeof(msg[0]), NS_ConvertUTF8toUTF16(fmt).get(), ap);
  55
  56   UINT flags = MB_OK;
  57   if (isError)
  58     flags |= MB_ICONERROR;
  59   else
  60     flags |= MB_ICONINFORMATION;
  61
  62   MessageBoxW(nullptr, msg, L"XULRunner", flags);
  63 #else
  64   vfprintf(stderr, fmt, ap);
  65 #endif
  66
  67   va_end(ap);
  68 }
  69
  70 /**
  71  * Return true if |arg| matches the given argument name.
  72  */
  73 static bool IsArg(const char* arg, const char* s)
  74 {
  75   if (*arg == '-')
  76   {
  77     if (*++arg == '-')
  78       ++arg;
  79     return !strcasecmp(arg, s);
  80   }
  81
  82 #if defined(XP_WIN)
  83   if (*arg == '/')
  84     return !strcasecmp(++arg, s);
  85 #endif
  86
  87   return false;
  88 }
  89
  90 static nsresult
  91 GetGREVersion(const char *argv0,
  92               nsACString *aMilestone,
  93               nsACString *aVersion)
  94 {
  95   if (aMilestone)
  96     aMilestone->AssignLiteral("<Error>");
  97   if (aVersion)
  98     aVersion->AssignLiteral("<Error>");
  99
 100   nsCOMPtr<nsIFile> iniFile;
 101   nsresult rv = BinaryPath::GetFile(argv0, getter_AddRefs(iniFile));
 102   if (NS_FAILED(rv))
 103     return rv;
 104
 105   iniFile->SetNativeLeafName(NS_LITERAL_CSTRING("platform.ini"));
 106
 107   nsINIParser parser;
 108   rv = parser.Init(iniFile);
 109   if (NS_FAILED(rv))
 110     return rv;
 111
 112   if (aMilestone) {
 113     rv = parser.GetString("Build", "Milestone", *aMilestone);
 114     if (NS_FAILED(rv))
 115       return rv;
 116   }
 117   if (aVersion) {
 118     rv = parser.GetString("Build", "BuildID", *aVersion);
 119     if (NS_FAILED(rv))
 120       return rv;
 121   }
 122   return NS_OK;
 123 }
 124
 125 /**
 126  * A helper class which calls NS_LogInit/NS_LogTerm in its scope.
 127  */
 128 class ScopedLogging
 129 {
 130 public:
 131   ScopedLogging() { NS_LogInit(); }
 132   ~ScopedLogging() { NS_LogTerm(); }
 133 };
 134
 135 static void Usage(const char *argv0)
 136 {
 137     nsAutoCString milestone;
 138     GetGREVersion(argv0, &milestone, nullptr);
 139
 140     // display additional information (XXX make localizable?)
 141     Output(false,
 142            "Mozilla XULRunner %s\n\n"
 143            "Usage: " XULRUNNER_PROGNAME " [OPTIONS]\n"
 144            "       " XULRUNNER_PROGNAME " APP-FILE [APP-OPTIONS...]\n"
 145            "\n"
 146            "OPTIONS\n"
 147            "      --app                  specify APP-FILE (optional)\n"
 148            "  -h, --help                 show this message\n"
 149            "  -v, --version              show version\n"
 150            "  --gre-version              print the GRE version string on stdout\n"
 151            "\n"
 152            "APP-FILE\n"
 153            "  Application initialization file.\n"
 154            "\n"
 155            "APP-OPTIONS\n"
 156            "  Application specific options.\n",
 157            milestone.get());
 158 }
 159
 160 XRE_GetFileFromPathType XRE_GetFileFromPath;
 161 XRE_CreateAppDataType XRE_CreateAppData;
 162 XRE_FreeAppDataType XRE_FreeAppData;
 163 XRE_mainType XRE_main;
 164
 165 static const nsDynamicFunctionLoad kXULFuncs[] = {
 166     { "XRE_GetFileFromPath", (NSFuncPtr*) &XRE_GetFileFromPath },
 167     { "XRE_CreateAppData", (NSFuncPtr*) &XRE_CreateAppData },
 168     { "XRE_FreeAppData", (NSFuncPtr*) &XRE_FreeAppData },
 169     { "XRE_main", (NSFuncPtr*) &XRE_main },
 170     { nullptr, nullptr }
 171 };
 172
 173 class AutoAppData
 174 {
 175 public:
 176   AutoAppData(nsIFile* aINIFile) : mAppData(nullptr) {
 177     nsresult rv = XRE_CreateAppData(aINIFile, &mAppData);
 178     if (NS_FAILED(rv))
 179       mAppData = nullptr;
 180   }
 181   ~AutoAppData() {
 182     if (mAppData)
 183       XRE_FreeAppData(mAppData);
 184   }
 185
 186   operator nsXREAppData*() const { return mAppData; }
 187   nsXREAppData* operator -> () const { return mAppData; }
 188
 189 private:
 190   nsXREAppData* mAppData;
 191 };
 192
 193 int main(int argc, char* argv[])
 194 {
 195   char exePath[MAXPATHLEN];
 196   nsresult rv = mozilla::BinaryPath::Get(argv[0], exePath);
 197   if (NS_FAILED(rv)) {
 198     Output(true, "Couldn't calculate the application directory.\n");
 199     return 255;
 200   }
 201
 202   char *lastSlash = strrchr(exePath, XPCOM_FILE_PATH_SEPARATOR[0]);
 203   if (!lastSlash || (size_t(lastSlash - exePath) > MAXPATHLEN - sizeof(XPCOM_DLL) - 1))
 204     return 255;
 205
 206   strcpy(++lastSlash, XPCOM_DLL);
 207
 208   rv = XPCOMGlueStartup(exePath);
 209   if (NS_FAILED(rv)) {
 210     Output(true, "Couldn't load XPCOM.\n");
 211     return 255;
 212   }
 213
 214   ScopedLogging log;
 215
 216   if (argc > 1 && (IsArg(argv[1], "h") ||
 217                    IsArg(argv[1], "help") ||
 218                    IsArg(argv[1], "?")))
 219   {
 220     Usage(argv[0]);
 221     return 0;
 222   }
 223
 224   if (argc == 2 && (IsArg(argv[1], "v") || IsArg(argv[1], "version")))
 225   {
 226     nsAutoCString milestone;
 227     nsAutoCString version;
 228     GetGREVersion(argv[0], &milestone, &version);
 229     Output(false, "Mozilla XULRunner %s - %s\n",
 230            milestone.get(), version.get());
 231     return 0;
 232   }
 233
 234   rv = XPCOMGlueLoadXULFunctions(kXULFuncs);
 235   if (NS_FAILED(rv)) {
 236     Output(true, "Couldn't load XRE functions.\n");
 237     return 255;
 238   }
 239
 240   if (argc > 1) {
 241     nsAutoCString milestone;
 242     rv = GetGREVersion(argv[0], &milestone, nullptr);
 243     if (NS_FAILED(rv))
 244       return 2;
 245
 246     if (IsArg(argv[1], "gre-version")) {
 247       if (argc != 2) {
 248         Usage(argv[0]);
 249         return 1;
 250       }
 251
 252       printf("%s\n", milestone.get());
 253       return 0;
 254     }
 255
 256     if (IsArg(argv[1], "install-app")) {
 257       Output(true, "--install-app support has been removed.  Use 'python install-app.py' instead.\n");
 258       return 1;
 259     }
 260   }
 261
 262   const char *appDataFile = getenv("XUL_APP_FILE");
 263
 264   if (!(appDataFile && *appDataFile)) {
 265     if (argc < 2) {
 266       Usage(argv[0]);
 267       return 1;
 268     }
 269
 270     if (IsArg(argv[1], "app")) {
 271       if (argc == 2) {
 272         Usage(argv[0]);
 273         return 1;
 274       }
 275       argv[1] = argv[0];
 276       ++argv;
 277       --argc;
 278     }
 279
 280     appDataFile = argv[1];
 281     argv[1] = argv[0];
 282     ++argv;
 283     --argc;
 284
 285     static char kAppEnv[MAXPATHLEN];
 286     snprintf(kAppEnv, MAXPATHLEN, "XUL_APP_FILE=%s", appDataFile);
 287     putenv(kAppEnv);
 288   }
 289
 290   nsCOMPtr<nsIFile> appDataLF;
 291   rv = XRE_GetFileFromPath(appDataFile, getter_AddRefs(appDataLF));
 292   if (NS_FAILED(rv)) {
 293     Output(true, "Error: unrecognized application.ini path.\n");
 294     return 2;
 295   }
 296
 297   AutoAppData appData(appDataLF);
 298   if (!appData) {
 299     Output(true, "Error: couldn't parse application.ini.\n");
 300     return 2;
 301   }
 302
 303   return XRE_main(argc, argv, appData, 0);
 304 }