toolkit/crashreporter/nsExceptionHandler.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla Breakpad integration
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Ted Mielczarek <ted.mielczarek@gmail.com>
  19  * Portions created by the Initial Developer are Copyright (C) 2006
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *  Josh Aas <josh@mozilla.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "nsExceptionHandler.h"
  40
  41 #if defined(XP_WIN32)
  42 #ifdef WIN32_LEAN_AND_MEAN
  43 #undef WIN32_LEAN_AND_MEAN
  44 #endif
  45
  46 #include "client/windows/handler/exception_handler.h"
  47 #include <string.h>
  48 #elif defined(XP_MACOSX)
  49 #include "client/mac/handler/exception_handler.h"
  50 #include <string>
  51 #include <Carbon/Carbon.h>
  52 #include <fcntl.h>
  53 #include <sys/types.h>
  54 #include <unistd.h>
  55 #include "mac_utils.h"
  56 #elif defined(XP_LINUX)
  57 #include "client/linux/handler/exception_handler.h"
  58 #include <fcntl.h>
  59 #include <sys/types.h>
  60 #include <unistd.h>
  61 #elif defined(XP_SOLARIS)
  62 #include "client/solaris/handler/exception_handler.h"
  63 #include <fcntl.h>
  64 #include <sys/types.h>
  65 #include <unistd.h>
  66 #else
  67 #error "Not yet implemented for this platform"
  68 #endif // defined(XP_WIN32)
  69
  70 #include <stdlib.h>
  71 #include <time.h>
  72 #include <prenv.h>
  73 #include <prio.h>
  74 #include <prmem.h>
  75 #include "nsDebug.h"
  76 #include "nsCRT.h"
  77 #include "nsILocalFile.h"
  78 #include "nsDataHashtable.h"
  79
  80 namespace CrashReporter {
  81
  82 #ifdef XP_WIN32
  83 typedef wchar_t XP_CHAR;
  84 #define CONVERT_UTF16_TO_XP_CHAR(x) x
  85 #define XP_STRLEN(x) wcslen(x)
  86 #define CRASH_REPORTER_FILENAME "crashreporter.exe"
  87 #define PATH_SEPARATOR "\\"
  88 #define XP_PATH_SEPARATOR L"\\"
  89 // sort of arbitrary, but MAX_PATH is kinda small
  90 #define XP_PATH_MAX 4096
  91 // "<reporter path>" "<minidump path>"
  92 #define CMDLINE_SIZE ((XP_PATH_MAX * 2) + 6)
  93 #ifdef _USE_32BIT_TIME_T
  94 #define XP_TTOA(time, buffer, base) ltoa(time, buffer, base)
  95 #else
  96 #define XP_TTOA(time, buffer, base) _i64toa(time, buffer, base)
  97 #endif
  98 #else
  99 typedef char XP_CHAR;
 100 #define CONVERT_UTF16_TO_XP_CHAR(x) NS_ConvertUTF16toUTF8(x)
 101 #define XP_STRLEN(x) strlen(x)
 102 #define CRASH_REPORTER_FILENAME "crashreporter"
 103 #define PATH_SEPARATOR "/"
 104 #define XP_PATH_SEPARATOR "/"
 105 #define XP_PATH_MAX PATH_MAX
 106 #define XP_TTOA(time, buffer, base) sprintf(buffer, "%ld", time)
 107 #endif // XP_WIN32
 108
 109 static const XP_CHAR dumpFileExtension[] = {'.', 'd', 'm', 'p',
 110                                             '\0'}; // .dmp
 111 static const XP_CHAR extraFileExtension[] = {'.', 'e', 'x', 't',
 112                                              'r', 'a', '\0'}; // .extra
 113
 114 static google_breakpad::ExceptionHandler* gExceptionHandler = nsnull;
 115
 116 static XP_CHAR* crashReporterPath;
 117
 118 // if this is false, we don't launch the crash reporter
 119 static bool doReport = true;
 120
 121 // if this is true, we pass the exception on to the OS crash reporter
 122 static bool showOSCrashReporter = false;
 123
 124 // The time of the last recorded crash, as a time_t value.
 125 static time_t lastCrashTime = 0;
 126 // The pathname of a file to store the crash time in
 127 static XP_CHAR lastCrashTimeFilename[XP_PATH_MAX] = {0};
 128
 129 // these are just here for readability
 130 static const char kCrashTimeParameter[] = "CrashTime=";
 131 static const int kCrashTimeParameterLen = sizeof(kCrashTimeParameter)-1;
 132
 133 static const char kTimeSinceLastCrashParameter[] = "SecondsSinceLastCrash=";
 134 static const int kTimeSinceLastCrashParameterLen =
 135                                      sizeof(kTimeSinceLastCrashParameter)-1;
 136
 137 // this holds additional data sent via the API
 138 static nsDataHashtable<nsCStringHashKey,nsCString>* crashReporterAPIData_Hash;
 139 static nsCString* crashReporterAPIData = nsnull;
 140 static nsCString* notesField = nsnull;
 141
 142 static XP_CHAR*
 143 Concat(XP_CHAR* str, const XP_CHAR* toAppend, int* size)
 144 {
 145   int appendLen = XP_STRLEN(toAppend);
 146   if (appendLen >= *size) appendLen = *size - 1;
 147
 148   memcpy(str, toAppend, appendLen * sizeof(XP_CHAR));
 149   str += appendLen;
 150   *str = '\0';
 151   *size -= appendLen;
 152
 153   return str;
 154 }
 155
 156 bool MinidumpCallback(const XP_CHAR* dump_path,
 157                       const XP_CHAR* minidump_id,
 158                       void* context,
 159 #ifdef XP_WIN32
 160                       EXCEPTION_POINTERS* exinfo,
 161                       MDRawAssertionInfo* assertion,
 162 #endif
 163                       bool succeeded)
 164 {
 165   bool returnValue = showOSCrashReporter ? false : succeeded;
 166
 167   XP_CHAR minidumpPath[XP_PATH_MAX];
 168   int size = XP_PATH_MAX;
 169   XP_CHAR* p = Concat(minidumpPath, dump_path, &size);
 170   p = Concat(p, XP_PATH_SEPARATOR, &size);
 171   p = Concat(p, minidump_id, &size);
 172   Concat(p, dumpFileExtension, &size);
 173
 174   XP_CHAR extraDataPath[XP_PATH_MAX];
 175   size = XP_PATH_MAX;
 176   p = Concat(extraDataPath, dump_path, &size);
 177   p = Concat(p, XP_PATH_SEPARATOR, &size);
 178   p = Concat(p, minidump_id, &size);
 179   Concat(p, extraFileExtension, &size);
 180
 181   // calculate time since last crash (if possible), and store
 182   // the time of this crash.
 183   time_t crashTime = time(NULL);
 184   time_t timeSinceLastCrash = 0;
 185   // stringified versions of the above
 186   char crashTimeString[32];
 187   int crashTimeStringLen = 0;
 188   char timeSinceLastCrashString[32];
 189   int timeSinceLastCrashStringLen = 0;
 190
 191   XP_TTOA(crashTime, crashTimeString, 10);
 192   crashTimeStringLen = strlen(crashTimeString);
 193   if (lastCrashTime != 0) {
 194     timeSinceLastCrash = crashTime - lastCrashTime;
 195     XP_TTOA(timeSinceLastCrash, timeSinceLastCrashString, 10);
 196     timeSinceLastCrashStringLen = strlen(timeSinceLastCrashString);
 197   }
 198   // write crash time to file
 199   if (lastCrashTimeFilename[0] != 0) {
 200 #if defined(XP_WIN32)
 201     HANDLE hFile = CreateFile(lastCrashTimeFilename, GENERIC_WRITE, 0,
 202                               NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
 203                               NULL);
 204     if(hFile != INVALID_HANDLE_VALUE) {
 205       DWORD nBytes;
 206       WriteFile(hFile, crashTimeString, crashTimeStringLen, &nBytes, NULL);
 207       CloseHandle(hFile);
 208     }
 209 #elif defined(XP_UNIX)
 210     int fd = open(lastCrashTimeFilename,
 211                   O_WRONLY | O_CREAT | O_TRUNC,
 212                   0600);
 213     if (fd != -1) {
 214       write(fd, crashTimeString, crashTimeStringLen);
 215       close(fd);
 216     }
 217 #endif
 218   }
 219
 220 #if defined(XP_WIN32)
 221   XP_CHAR cmdLine[CMDLINE_SIZE];
 222   size = CMDLINE_SIZE;
 223   p = Concat(cmdLine, L"\"", &size);
 224   p = Concat(p, crashReporterPath, &size);
 225   p = Concat(p, L"\" \"", &size);
 226   p = Concat(p, minidumpPath, &size);
 227   Concat(p, L"\"", &size);
 228
 229   if (!crashReporterAPIData->IsEmpty()) {
 230     // write out API data
 231     HANDLE hFile = CreateFile(extraDataPath, GENERIC_WRITE, 0,
 232                               NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
 233                               NULL);
 234     if(hFile != INVALID_HANDLE_VALUE) {
 235       DWORD nBytes;
 236       WriteFile(hFile, crashReporterAPIData->get(),
 237                 crashReporterAPIData->Length(), &nBytes, NULL);
 238       WriteFile(hFile, kCrashTimeParameter, kCrashTimeParameterLen,
 239                 &nBytes, NULL);
 240       WriteFile(hFile, crashTimeString, crashTimeStringLen, &nBytes, NULL);
 241       WriteFile(hFile, "\n", 1, &nBytes, NULL);
 242       if (timeSinceLastCrash != 0) {
 243         WriteFile(hFile, kTimeSinceLastCrashParameter,
 244                   kTimeSinceLastCrashParameterLen, &nBytes, NULL);
 245         WriteFile(hFile, timeSinceLastCrashString, timeSinceLastCrashStringLen,
 246                   &nBytes, NULL);
 247         WriteFile(hFile, "\n", 1, &nBytes, NULL);
 248       }
 249       CloseHandle(hFile);
 250     }
 251   }
 252
 253   if (!doReport) {
 254     return returnValue;
 255   }
 256
 257   STARTUPINFO si;
 258   PROCESS_INFORMATION pi;
 259
 260   ZeroMemory(&si, sizeof(si));
 261   si.cb = sizeof(si);
 262   si.dwFlags = STARTF_USESHOWWINDOW;
 263   si.wShowWindow = SW_SHOWNORMAL;
 264   ZeroMemory(&pi, sizeof(pi));
 265
 266   if (CreateProcess(NULL, (LPWSTR)cmdLine, NULL, NULL, FALSE, 0,
 267                     NULL, NULL, &si, &pi)) {
 268     CloseHandle( pi.hProcess );
 269     CloseHandle( pi.hThread );
 270   }
 271   // we're not really in a position to do anything if the CreateProcess fails
 272   TerminateProcess(GetCurrentProcess(), 1);
 273 #elif defined(XP_UNIX)
 274   if (!crashReporterAPIData->IsEmpty()) {
 275     // write out API data
 276     int fd = open(extraDataPath,
 277                   O_WRONLY | O_CREAT | O_TRUNC,
 278                   0666);
 279
 280     if (fd != -1) {
 281       // not much we can do in case of error
 282       write(fd, crashReporterAPIData->get(), crashReporterAPIData->Length());
 283       write(fd, kCrashTimeParameter, kCrashTimeParameterLen);
 284       write(fd, crashTimeString, crashTimeStringLen);
 285       write(fd, "\n", 1);
 286       if (timeSinceLastCrash != 0) {
 287         write(fd, kTimeSinceLastCrashParameter,kTimeSinceLastCrashParameterLen);
 288         write(fd, timeSinceLastCrashString, timeSinceLastCrashStringLen);
 289         write(fd, "\n", 1);
 290       }
 291       close (fd);
 292     }
 293   }
 294
 295   if (!doReport) {
 296     return returnValue;
 297   }
 298
 299   pid_t pid = fork();
 300
 301   if (pid == -1)
 302     return false;
 303   else if (pid == 0) {
 304     // need to clobber this, as libcurl might load NSS,
 305     // and we want it to load the system NSS.
 306     unsetenv("LD_LIBRARY_PATH");
 307     (void) execl(crashReporterPath,
 308                  crashReporterPath, minidumpPath, (char*)0);
 309     _exit(1);
 310   }
 311 #endif
 312
 313  return returnValue;
 314 }
 315
 316 nsresult SetExceptionHandler(nsILocalFile* aXREDirectory,
 317                              const char* aServerURL)
 318 {
 319   nsresult rv;
 320
 321   if (gExceptionHandler)
 322     return NS_ERROR_ALREADY_INITIALIZED;
 323
 324   const char *envvar = PR_GetEnv("MOZ_CRASHREPORTER_DISABLE");
 325   if (envvar && *envvar)
 326     return NS_OK;
 327
 328   // this environment variable prevents us from launching
 329   // the crash reporter client
 330   envvar = PR_GetEnv("MOZ_CRASHREPORTER_NO_REPORT");
 331   if (envvar && *envvar)
 332     doReport = false;
 333
 334   // allocate our strings
 335   crashReporterAPIData = new nsCString();
 336   NS_ENSURE_TRUE(crashReporterAPIData, NS_ERROR_OUT_OF_MEMORY);
 337
 338   crashReporterAPIData_Hash =
 339     new nsDataHashtable<nsCStringHashKey,nsCString>();
 340   NS_ENSURE_TRUE(crashReporterAPIData_Hash, NS_ERROR_OUT_OF_MEMORY);
 341
 342   rv = crashReporterAPIData_Hash->Init();
 343   NS_ENSURE_SUCCESS(rv, rv);
 344
 345   notesField = new nsCString();
 346   NS_ENSURE_TRUE(notesField, NS_ERROR_OUT_OF_MEMORY);
 347
 348   // locate crashreporter executable
 349   nsCOMPtr<nsIFile> exePath;
 350   rv = aXREDirectory->Clone(getter_AddRefs(exePath));
 351   NS_ENSURE_SUCCESS(rv, rv);
 352
 353 #if defined(XP_MACOSX)
 354   exePath->Append(NS_LITERAL_STRING("crashreporter.app"));
 355   exePath->Append(NS_LITERAL_STRING("Contents"));
 356   exePath->Append(NS_LITERAL_STRING("MacOS"));
 357 #endif
 358
 359   exePath->AppendNative(NS_LITERAL_CSTRING(CRASH_REPORTER_FILENAME));
 360
 361 #ifdef XP_WIN32
 362   nsString crashReporterPath_temp;
 363   exePath->GetPath(crashReporterPath_temp);
 364
 365   crashReporterPath = ToNewUnicode(crashReporterPath_temp);
 366 #else
 367   nsCString crashReporterPath_temp;
 368   exePath->GetNativePath(crashReporterPath_temp);
 369
 370   crashReporterPath = ToNewCString(crashReporterPath_temp);
 371 #endif
 372
 373   // get temp path to use for minidump path
 374 #if defined(XP_WIN32)
 375   nsString tempPath;
 376
 377   // first figure out buffer size
 378   int pathLen = GetTempPath(0, NULL);
 379   if (pathLen == 0)
 380     return NS_ERROR_FAILURE;
 381
 382   tempPath.SetLength(pathLen);
 383   GetTempPath(pathLen, (LPWSTR)tempPath.BeginWriting());
 384 #elif defined(XP_MACOSX)
 385   nsCString tempPath;
 386   FSRef fsRef;
 387   OSErr err = FSFindFolder(kUserDomain, kTemporaryFolderType,
 388                            kCreateFolder, &fsRef);
 389   if (err != noErr)
 390     return NS_ERROR_FAILURE;
 391
 392   char path[PATH_MAX];
 393   OSStatus status = FSRefMakePath(&fsRef, (UInt8*)path, PATH_MAX);
 394   if (status != noErr)
 395     return NS_ERROR_FAILURE;
 396
 397   tempPath = path;
 398
 399 #elif defined(XP_UNIX)
 400   // we assume it's always /tmp on unix systems
 401   nsCString tempPath = NS_LITERAL_CSTRING("/tmp/");
 402 #else
 403 #error "Implement this for your platform"
 404 #endif
 405
 406   // now set the exception handler
 407   gExceptionHandler = new google_breakpad::
 408     ExceptionHandler(tempPath.get(),
 409                      nsnull,
 410                      MinidumpCallback,
 411                      nsnull,
 412 #if defined(XP_WIN32)
 413                      google_breakpad::ExceptionHandler::HANDLER_ALL);
 414 #else
 415                      true);
 416 #endif
 417
 418   if (!gExceptionHandler)
 419     return NS_ERROR_OUT_OF_MEMORY;
 420
 421   // store server URL with the API data
 422   if (aServerURL)
 423     AnnotateCrashReport(NS_LITERAL_CSTRING("ServerURL"),
 424                         nsDependentCString(aServerURL));
 425
 426   // store application start time
 427   char timeString[32];
 428   XP_TTOA(time(NULL), timeString, 10);
 429   AnnotateCrashReport(NS_LITERAL_CSTRING("StartupTime"),
 430                       nsDependentCString(timeString));
 431
 432 #if defined(XP_MACOSX)
 433   // On OS X, many testers like to see the OS crash reporting dialog
 434   // since it offers immediate stack traces.  We allow them to set
 435   // a default to pass exceptions to the OS handler.
 436   showOSCrashReporter = PassToOSCrashReporter();
 437 #endif
 438
 439   return NS_OK;
 440 }
 441
 442 nsresult SetMinidumpPath(const nsAString& aPath)
 443 {
 444   if (!gExceptionHandler)
 445     return NS_ERROR_NOT_INITIALIZED;
 446
 447   gExceptionHandler->set_dump_path(CONVERT_UTF16_TO_XP_CHAR(aPath).BeginReading());
 448
 449   return NS_OK;
 450 }
 451
 452 static nsresult
 453 WriteDataToFile(nsIFile* aFile, const nsACString& data)
 454 {
 455   nsCOMPtr<nsILocalFile> localFile = do_QueryInterface(aFile);
 456   NS_ENSURE_TRUE(localFile, NS_ERROR_FAILURE);
 457
 458   PRFileDesc* fd;
 459   nsresult rv = localFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE, 00600,
 460                                             &fd);
 461   NS_ENSURE_SUCCESS(rv, rv);
 462
 463   rv = NS_OK;
 464   if (PR_Write(fd, data.Data(), data.Length()) == -1) {
 465     rv = NS_ERROR_FAILURE;
 466   }
 467   PR_Close(fd);
 468   return rv;
 469 }
 470
 471 static nsresult
 472 GetFileContents(nsIFile* aFile, nsACString& data)
 473 {
 474   nsCOMPtr<nsILocalFile> localFile = do_QueryInterface(aFile);
 475   NS_ENSURE_TRUE(localFile, NS_ERROR_FAILURE);
 476
 477   PRFileDesc* fd;
 478   nsresult rv = localFile->OpenNSPRFileDesc(PR_RDONLY, 0, &fd);
 479   NS_ENSURE_SUCCESS(rv, rv);
 480
 481   rv = NS_OK;
 482   PRInt32 filesize = PR_Available(fd);
 483   if (filesize <= 0) {
 484     rv = NS_ERROR_FILE_NOT_FOUND;
 485   }
 486   else {
 487     data.SetLength(filesize);
 488     if (PR_Read(fd, data.BeginWriting(), filesize) == -1) {
 489       rv = NS_ERROR_FAILURE;
 490     }
 491   }
 492   PR_Close(fd);
 493   return rv;
 494 }
 495
 496 // Function typedef for initializing a piece of data that we
 497 // don't already have.
 498 typedef nsresult (*InitDataFunc)(nsACString&);
 499
 500 // Attempt to read aFile's contents into aContents, if aFile
 501 // does not exist, create it and initialize its contents
 502 // by calling aInitFunc for the data.
 503 static nsresult
 504 GetOrInit(nsIFile* aDir, const nsACString& filename,
 505           nsACString& aContents, InitDataFunc aInitFunc)
 506 {
 507   PRBool exists;
 508
 509   nsCOMPtr<nsIFile> dataFile;
 510   nsresult rv = aDir->Clone(getter_AddRefs(dataFile));
 511   NS_ENSURE_SUCCESS(rv, rv);
 512
 513   rv = dataFile->AppendNative(filename);
 514   NS_ENSURE_SUCCESS(rv, rv);
 515
 516   rv = dataFile->Exists(&exists);
 517   NS_ENSURE_SUCCESS(rv, rv);
 518
 519   if (!exists) {
 520     if (aInitFunc) {
 521       // get the initial value and write it to the file
 522       rv = aInitFunc(aContents);
 523       NS_ENSURE_SUCCESS(rv, rv);
 524       rv = WriteDataToFile(dataFile, aContents);
 525     }
 526     else {
 527       // didn't pass in an init func
 528       rv = NS_ERROR_FAILURE;
 529     }
 530   }
 531   else {
 532     // just get the file's contents
 533     rv = GetFileContents(dataFile, aContents);
 534   }
 535
 536   return rv;
 537 }
 538
 539 // Init the "install time" data.  We're taking an easy way out here
 540 // and just setting this to "the time when this version was first run".
 541 static nsresult
 542 InitInstallTime(nsACString& aInstallTime)
 543 {
 544   time_t t = time(NULL);
 545   char buf[16];
 546   sprintf(buf, "%ld", t);
 547   aInstallTime = buf;
 548
 549   return NS_OK;
 550 }
 551
 552 // Annotate the crash report with a Unique User ID and time
 553 // since install.  Also do some prep work for recording
 554 // time since last crash, which must be calculated at
 555 // crash time.
 556 // If any piece of data doesn't exist, initialize it first.
 557 nsresult SetupExtraData(nsILocalFile* aAppDataDirectory,
 558                         const nsACString& aBuildID)
 559 {
 560   nsCOMPtr<nsIFile> dataDirectory;
 561   nsresult rv = aAppDataDirectory->Clone(getter_AddRefs(dataDirectory));
 562   NS_ENSURE_SUCCESS(rv, rv);
 563
 564   rv = dataDirectory->AppendNative(NS_LITERAL_CSTRING("Crash Reports"));
 565   NS_ENSURE_SUCCESS(rv, rv);
 566
 567   PRBool exists;
 568   rv = dataDirectory->Exists(&exists);
 569   NS_ENSURE_SUCCESS(rv, rv);
 570
 571   if (!exists) {
 572     rv = dataDirectory->Create(nsIFile::DIRECTORY_TYPE, 0700);
 573     NS_ENSURE_SUCCESS(rv, rv);
 574   }
 575
 576 #if defined(XP_WIN32)
 577   nsAutoString dataDirEnv(NS_LITERAL_STRING("MOZ_CRASHREPORTER_DATA_DIRECTORY="));
 578
 579   nsAutoString dataDirectoryPath;
 580   rv = dataDirectory->GetPath(dataDirectoryPath);
 581   NS_ENSURE_SUCCESS(rv, rv);
 582
 583   dataDirEnv.Append(dataDirectoryPath);
 584
 585   _wputenv(dataDirEnv.get());
 586 #else
 587   // Save this path in the environment for the crash reporter application.
 588   nsCAutoString dataDirEnv("MOZ_CRASHREPORTER_DATA_DIRECTORY=");
 589
 590   nsCAutoString dataDirectoryPath;
 591   rv = dataDirectory->GetNativePath(dataDirectoryPath);
 592   NS_ENSURE_SUCCESS(rv, rv);
 593
 594   dataDirEnv.Append(dataDirectoryPath);
 595
 596   char* env = ToNewCString(dataDirEnv);
 597   NS_ENSURE_TRUE(env, NS_ERROR_OUT_OF_MEMORY);
 598
 599   PR_SetEnv(env);
 600 #endif
 601
 602   nsCAutoString data;
 603   if(NS_SUCCEEDED(GetOrInit(dataDirectory,
 604                             NS_LITERAL_CSTRING("InstallTime") + aBuildID,
 605                             data, InitInstallTime)))
 606     AnnotateCrashReport(NS_LITERAL_CSTRING("InstallTime"), data);
 607
 608   // this is a little different, since we can't init it with anything,
 609   // since it's stored at crash time, and we can't annotate the
 610   // crash report with the stored value, since we really want
 611   // (now - LastCrash), so we just get a value if it exists,
 612   // and store it in a time_t value.
 613   if(NS_SUCCEEDED(GetOrInit(dataDirectory, NS_LITERAL_CSTRING("LastCrash"),
 614                             data, NULL))) {
 615     lastCrashTime = (time_t)atol(data.get());
 616   }
 617
 618   // not really the best place to init this, but I have the path I need here
 619   nsCOMPtr<nsIFile> lastCrashFile;
 620   rv = dataDirectory->Clone(getter_AddRefs(lastCrashFile));
 621   NS_ENSURE_SUCCESS(rv, rv);
 622
 623   rv = lastCrashFile->AppendNative(NS_LITERAL_CSTRING("LastCrash"));
 624   NS_ENSURE_SUCCESS(rv, rv);
 625   memset(lastCrashTimeFilename, 0, sizeof(lastCrashTimeFilename));
 626
 627 #if defined(XP_WIN32)
 628   nsAutoString filename;
 629   rv = lastCrashFile->GetPath(filename);
 630   NS_ENSURE_SUCCESS(rv, rv);
 631
 632   if (filename.Length() < XP_PATH_MAX)
 633     wcsncpy(lastCrashTimeFilename, filename.get(), filename.Length());
 634 #else
 635   nsCAutoString filename;
 636   rv = lastCrashFile->GetNativePath(filename);
 637   NS_ENSURE_SUCCESS(rv, rv);
 638
 639   if (filename.Length() < XP_PATH_MAX)
 640     strncpy(lastCrashTimeFilename, filename.get(), filename.Length());
 641 #endif
 642
 643   return NS_OK;
 644 }
 645
 646 nsresult UnsetExceptionHandler()
 647 {
 648   // do this here in the unlikely case that we succeeded in allocating
 649   // our strings but failed to allocate gExceptionHandler.
 650   if (crashReporterAPIData_Hash) {
 651     delete crashReporterAPIData_Hash;
 652     crashReporterAPIData_Hash = nsnull;
 653   }
 654
 655   if (crashReporterAPIData) {
 656     delete crashReporterAPIData;
 657     crashReporterAPIData = nsnull;
 658   }
 659
 660   if (notesField) {
 661     delete notesField;
 662     notesField = nsnull;
 663   }
 664
 665   if (crashReporterPath) {
 666     NS_Free(crashReporterPath);
 667     crashReporterPath = nsnull;
 668   }
 669
 670   if (!gExceptionHandler)
 671     return NS_ERROR_NOT_INITIALIZED;
 672
 673   delete gExceptionHandler;
 674   gExceptionHandler = nsnull;
 675
 676   return NS_OK;
 677 }
 678
 679 static void ReplaceChar(nsCString& str, const nsACString& character,
 680                         const nsACString& replacement)
 681 {
 682   nsCString::const_iterator start, end;
 683
 684   str.BeginReading(start);
 685   str.EndReading(end);
 686
 687   while (FindInReadable(character, start, end)) {
 688     PRInt32 pos = end.size_backward();
 689     str.Replace(pos - 1, 1, replacement);
 690
 691     str.BeginReading(start);
 692     start.advance(pos + replacement.Length() - 1);
 693     str.EndReading(end);
 694   }
 695 }
 696
 697 static PRBool DoFindInReadable(const nsACString& str, const nsACString& value)
 698 {
 699   nsACString::const_iterator start, end;
 700   str.BeginReading(start);
 701   str.EndReading(end);
 702
 703   return FindInReadable(value, start, end);
 704 }
 705
 706 static PLDHashOperator PR_CALLBACK EnumerateEntries(const nsACString& key,
 707                                                     nsCString entry,
 708                                                     void* userData)
 709 {
 710   crashReporterAPIData->Append(key + NS_LITERAL_CSTRING("=") + entry +
 711                                NS_LITERAL_CSTRING("\n"));
 712   return PL_DHASH_NEXT;
 713 }
 714
 715 nsresult AnnotateCrashReport(const nsACString& key, const nsACString& data)
 716 {
 717   if (!gExceptionHandler)
 718     return NS_ERROR_NOT_INITIALIZED;
 719
 720   if (DoFindInReadable(key, NS_LITERAL_CSTRING("=")) ||
 721       DoFindInReadable(key, NS_LITERAL_CSTRING("\n")))
 722     return NS_ERROR_INVALID_ARG;
 723
 724   if (DoFindInReadable(data, NS_LITERAL_CSTRING("\0")))
 725     return NS_ERROR_INVALID_ARG;
 726
 727   nsCString escapedData(data);
 728
 729   // escape backslashes
 730   ReplaceChar(escapedData, NS_LITERAL_CSTRING("\\"),
 731               NS_LITERAL_CSTRING("\\\\"));
 732   // escape newlines
 733   ReplaceChar(escapedData, NS_LITERAL_CSTRING("\n"),
 734               NS_LITERAL_CSTRING("\\n"));
 735
 736   nsresult rv = crashReporterAPIData_Hash->Put(key, escapedData);
 737   NS_ENSURE_SUCCESS(rv, rv);
 738
 739   // now rebuild the file contents
 740   crashReporterAPIData->Truncate(0);
 741   crashReporterAPIData_Hash->EnumerateRead(EnumerateEntries,
 742                                            crashReporterAPIData);
 743
 744   return NS_OK;
 745 }
 746
 747 nsresult AppendAppNotesToCrashReport(const nsACString& data)
 748 {
 749   if (!gExceptionHandler)
 750     return NS_ERROR_NOT_INITIALIZED;
 751
 752   if (DoFindInReadable(data, NS_LITERAL_CSTRING("\0")))
 753     return NS_ERROR_INVALID_ARG;
 754
 755   notesField->Append(data);
 756   return AnnotateCrashReport(NS_LITERAL_CSTRING("Notes"), *notesField);
 757 }
 758
 759 // Returns true if found, false if not found.
 760 bool GetAnnotation(const nsACString& key, nsACString& data)
 761 {
 762   if (!gExceptionHandler)
 763     return NS_ERROR_NOT_INITIALIZED;
 764
 765   nsCAutoString entry;
 766   if (!crashReporterAPIData_Hash->Get(key, &entry))
 767     return false;
 768
 769   data = entry;
 770   return true;
 771 }
 772
 773 nsresult
 774 SetRestartArgs(int argc, char** argv)
 775 {
 776   if (!gExceptionHandler)
 777     return NS_OK;
 778
 779   int i;
 780   nsCAutoString envVar;
 781   char *env;
 782   for (i = 0; i < argc; i++) {
 783     envVar = "MOZ_CRASHREPORTER_RESTART_ARG_";
 784     envVar.AppendInt(i);
 785     envVar += "=";
 786 #if defined(XP_UNIX) && !defined(XP_MACOSX)
 787     // we'd like to run the script around the binary
 788     // instead of the binary itself, so remove the -bin
 789     // if it exists on the first argument
 790     int arg_len = 0;
 791     if (i == 0 &&
 792         (arg_len = strlen(argv[i])) > 4 &&
 793         strcmp(argv[i] + arg_len - 4, "-bin") == 0) {
 794       envVar.Append(argv[i], arg_len - 4);
 795     } else
 796 #endif
 797     {
 798       envVar += argv[i];
 799     }
 800
 801     // PR_SetEnv() wants the string to be available for the lifetime
 802     // of the app, so dup it here
 803     env = ToNewCString(envVar);
 804     if (!env)
 805       return NS_ERROR_OUT_OF_MEMORY;
 806
 807     PR_SetEnv(env);
 808   }
 809
 810   // make sure the arg list is terminated
 811   envVar = "MOZ_CRASHREPORTER_RESTART_ARG_";
 812   envVar.AppendInt(i);
 813   envVar += "=";
 814
 815   // PR_SetEnv() wants the string to be available for the lifetime
 816   // of the app, so dup it here
 817   env = ToNewCString(envVar);
 818   if (!env)
 819     return NS_ERROR_OUT_OF_MEMORY;
 820
 821   PR_SetEnv(env);
 822
 823   // make sure we save the info in XUL_APP_FILE for the reporter
 824   const char *appfile = PR_GetEnv("XUL_APP_FILE");
 825   if (appfile && *appfile) {
 826     envVar = "MOZ_CRASHREPORTER_RESTART_XUL_APP_FILE=";
 827     envVar += appfile;
 828     env = ToNewCString(envVar);
 829     PR_SetEnv(env);
 830   }
 831
 832   return NS_OK;
 833 }
 834
 835 #ifdef XP_WIN32
 836 nsresult WriteMinidumpForException(EXCEPTION_POINTERS* aExceptionInfo)
 837 {
 838   if (!gExceptionHandler)
 839     return NS_ERROR_NOT_INITIALIZED;
 840
 841   return gExceptionHandler->WriteMinidumpForException(aExceptionInfo) ? NS_OK : NS_ERROR_FAILURE;
 842 }
 843 #endif
 844
 845 #ifdef XP_MACOSX
 846 nsresult AppendObjCExceptionInfoToAppNotes(void *inException)
 847 {
 848   nsCAutoString excString;
 849   GetObjCExceptionInfo(inException, excString);
 850   AppendAppNotesToCrashReport(excString);
 851   return NS_OK;
 852 }
 853 #endif
 854
 855 } // namespace CrashReporter