1 files changed, 189 insertions, 18 deletions

diff --git a/linden/indra/newview/llappviewermacosx.cpp b/linden/indra/newview/llappviewermacosx.cpp
index 68c3a16..0e5062d 100644
--- a/linden/indra/newview/llappviewermacosx.cpp
+++ b/linden/indra/newview/llappviewermacosx.cpp
@@ -4,7 +4,7 @@
  *
  * $LicenseInfo:firstyear=2007&license=viewergpl$
  * 
- * Copyright (c) 2007-2008, Linden Research, Inc.
+ * Copyright (c) 2007-2009, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -48,12 +48,25 @@
 #include "llurldispatcher.h"
 #include <Carbon/Carbon.h>
 #include "lldir.h"
+#include <signal.h>
+
 namespace 
 {
         // The command line args stored.
         // They are not used immediately by the app.
         int gArgC;
         char** gArgV;
+        
+        bool sCrashReporterIsRunning = false;
+        
+        OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)
+        {
+                OSErr result = noErr;
+                
+                LLAppViewer::instance()->userQuit();
+                
+                return(result);
+        }
 }
 
 int main( int argc, char **argv ) 
@@ -193,22 +206,189 @@ bool LLAppViewerMacOSX::initParseCommandLine(LLCommandLineParser& clp)
     return true;
 }
 
+// *FIX:Mani It would be nice to provide a clean interface to get the
+// default_unix_signal_handler for the LLApp class.
+extern void default_unix_signal_handler(int, siginfo_t *, void *);
+bool LLAppViewerMacOSX::restoreErrorTrap()
+{
+        // This method intends to reinstate signal handlers.
+        // *NOTE:Mani It was found that the first execution of a shader was overriding
+        // our initial signal handlers somehow.
+        // This method will be called (at least) once per mainloop execution.
+        // *NOTE:Mani The signals used below are copied over from the 
+        // setup_signals() func in LLApp.cpp
+        // LLApp could use some way of overriding that func, but for this viewer
+        // fix I opt to avoid affecting the server code.
+        
+        // Set up signal handlers that may result in program termination
+        //
+        struct sigaction act;
+        struct sigaction old_act;
+        act.sa_sigaction = default_unix_signal_handler;
+        sigemptyset( &act.sa_mask );
+        act.sa_flags = SA_SIGINFO;
+        
+        unsigned int reset_count = 0;
+        
+#define SET_SIG(S)      sigaction(SIGABRT, &act, &old_act); \
+                                        if((unsigned int)act.sa_sigaction != (unsigned int) old_act.sa_sigaction) \
+                                                ++reset_count;
+        // Synchronous signals
+        SET_SIG(SIGABRT)
+        SET_SIG(SIGALRM)
+        SET_SIG(SIGBUS)
+        SET_SIG(SIGFPE)
+        SET_SIG(SIGHUP) 
+        SET_SIG(SIGILL)
+        SET_SIG(SIGPIPE)
+        SET_SIG(SIGSEGV)
+        SET_SIG(SIGSYS)
+        
+        SET_SIG(LL_HEARTBEAT_SIGNAL)
+        SET_SIG(LL_SMACKDOWN_SIGNAL)
+        
+        // Asynchronous signals that are normally ignored
+        SET_SIG(SIGCHLD)
+        SET_SIG(SIGUSR2)
+        
+        // Asynchronous signals that result in attempted graceful exit
+        SET_SIG(SIGHUP)
+        SET_SIG(SIGTERM)
+        SET_SIG(SIGINT)
+        
+        // Asynchronous signals that result in core
+        SET_SIG(SIGQUIT)        
+#undef SET_SIG
+        
+        return reset_count == 0;
+}
+
 void LLAppViewerMacOSX::handleSyncCrashTrace()
 {
         // do nothing
 }
 
-void LLAppViewerMacOSX::handleCrashReporting()
+static OSStatus CarbonEventHandler(EventHandlerCallRef inHandlerCallRef, 
+                                                                   EventRef inEvent, 
+                                                                   void* inUserData)
+{
+    ProcessSerialNumber psn;
+        
+    GetEventParameter(inEvent, 
+                                          kEventParamProcessID, 
+                                          typeProcessSerialNumber, 
+                                          NULL, 
+                                          sizeof(psn), 
+                                          NULL, 
+                                          &psn);
+        
+    if( GetEventKind(inEvent) == kEventAppTerminated ) 
+        {
+                Boolean matching_psn = FALSE;   
+                OSErr os_result = SameProcess(&psn, (ProcessSerialNumber*)inUserData, &matching_psn);
+                if(os_result >= 0 && matching_psn)
+                {
+                        sCrashReporterIsRunning = false;
+                }
+    }
+    return noErr;
+}
+
+void LLAppViewerMacOSX::handleCrashReporting(bool reportFreeze)
 {
-        // Macintosh
+        // This used to use fork&exec, but is switched to LSOpenApplication to 
+        // Make sure the crash reporter launches in front of the SL window.
+        
         std::string command_str;
-        command_str += "open mac-crash-logger.app";     
+        //command_str = "open Second Life.app/Contents/Resources/mac-crash-logger.app";
+        command_str = "mac-crash-logger.app/Contents/MacOS/mac-crash-logger";
         
-        clear_signals();
-        llinfos << "Launching crash reporter using: '" << command_str << "'" << llendl;
-        system(command_str.c_str());            /* Flawfinder: ignore */
-        llinfos << "returned from crash reporter... dying" << llendl;   
-        _exit(1);
+        FSRef appRef;
+        Boolean isDir = 0;
+        OSStatus os_result = FSPathMakeRef((UInt8*)command_str.c_str(),
+                                                                           &appRef,
+                                                                           &isDir);
+        if(os_result >= 0)
+        {
+                LSApplicationParameters appParams;
+                memset(&appParams, 0, sizeof(appParams));
+                appParams.version = 0;
+                appParams.flags = kLSLaunchNoParams | kLSLaunchStartClassic;
+                appParams.application = &appRef;
+                
+                if(reportFreeze)
+                {
+                        // Make sure freeze reporting launches the crash logger synchronously, lest 
+                        // Log files get changed by SL while the logger is running.
+                
+                        // *NOTE:Mani A better way - make a copy of the data that the crash reporter will send
+                        // and let SL go about its business. This way makes the mac work like windows and linux
+                        // and is the smallest patch for the issue. 
+                        sCrashReporterIsRunning = true;
+                        ProcessSerialNumber o_psn;
+
+                        static EventHandlerRef sCarbonEventsRef = NULL;
+                        static const EventTypeSpec kEvents[] = 
+                        {
+                                { kEventClassApplication, kEventAppTerminated }
+                        };
+                        
+                        // Install the handler to detect crash logger termination
+                        InstallEventHandler(GetApplicationEventTarget(), 
+                                                                (EventHandlerUPP) CarbonEventHandler,
+                                                                GetEventTypeCount(kEvents),
+                                                                kEvents,
+                                                                &o_psn,
+                                                                &sCarbonEventsRef
+                                                                );
+                        
+                        // Remove, temporarily the quit handler - which has *crash* behavior before 
+                        // the mainloop gets running!
+                        AERemoveEventHandler(kCoreEventClass, 
+                                                                 kAEQuitApplication, 
+                                                                 NewAEEventHandlerUPP(AEQuitHandler),
+                                                                 false);
+
+                        // Launch the crash reporter.
+                        os_result = LSOpenApplication(&appParams, &o_psn);
+                        
+                        if(os_result >= 0)
+                        {       
+                                EventRecord evt;
+                                while(sCrashReporterIsRunning)
+                                {
+                                        while(WaitNextEvent(osMask, &evt, 0, NULL))
+                                        {
+                                                // null op!?!
+                                        }
+                                }
+                        }       
+
+                        // Re-install the apps quit handler.
+                        AEInstallEventHandler(kCoreEventClass, 
+                                                                  kAEQuitApplication, 
+                                                                  NewAEEventHandlerUPP(AEQuitHandler),
+                                                                  0, 
+                                                                  false);
+                        
+                        // Remove the crash reporter quit handler.
+                        RemoveEventHandler(sCarbonEventsRef);
+                }
+                else
+                {
+                        appParams.flags |= kLSLaunchAsync;
+                        clear_signals();
+
+                        ProcessSerialNumber o_psn;
+                        os_result = LSOpenApplication(&appParams, &o_psn);
+                }
+                
+        }
+
+        if(!reportFreeze)
+        {
+                _exit(1);
+        }
 }
 
 std::string LLAppViewerMacOSX::generateSerialNumber()
@@ -267,15 +447,6 @@ OSErr AEGURLHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)
         return(result);
 }
 
-OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)
-{
-        OSErr result = noErr;
-        
-        LLAppViewer::instance()->userQuit();
-        
-        return(result);
-}
-
 OSStatus simpleDialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata)
 {
         OSStatus result = eventNotHandledErr;