sal/osl/unx/signal.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 /* system headers */
  22 #include "system.h"
  23
  24 #if defined( MACOSX )
  25
  26 #if defined( INTEL )
  27 #include "backtrace.h"
  28 #define INCLUDE_BACKTRACE
  29 #ifdef SAL_ENABLE_CRASH_REPORT
  30 #define STACKTYPE "MacOsX_X86"
  31 #endif
  32 #endif /* INTEL */
  33
  34 #endif /* MACOSX */
  35
  36 #ifdef LINUX
  37 #include <execinfo.h>
  38 #include <link.h>
  39 #define INCLUDE_BACKTRACE
  40 #if defined SAL_ENABLE_CRASH_REPORT
  41 #define STACKTYPE "Linux"
  42 #endif
  43 #endif
  44
  45 #ifdef SOLARIS
  46
  47 #include "backtrace.h"
  48 #define INCLUDE_BACKTRACE
  49
  50 #if defined SAL_ENABLE_CRASH_REPORT
  51 #if defined( SPARC )
  52 #define STACKTYPE "Solaris_Sparc"
  53 #elif defined( INTEL )
  54 #define STACKTYPE "Solaris_X86"
  55 #else
  56 #define STACKTYPE "Solaris_Unknown"
  57 #endif
  58 #endif
  59
  60 #endif /* defined SOLARIS */
  61
  62 #if defined INCLUDE_BACKTRACE
  63 #define MAX_STACK_FRAMES 256
  64 #endif
  65
  66 #include <osl/diagnose.h>
  67 #include <osl/mutex.h>
  68 #include <osl/signal.h>
  69 #include <osl/process.h>
  70 #include <osl/thread.h>
  71 #include <sal/macros.h>
  72 #include <rtl/bootstrap.h>
  73 #include <rtl/digest.h>
  74
  75 #include "file_path_helper.h"
  76
  77 #define ACT_IGNORE  1
  78 #define ACT_EXIT    2
  79 #define ACT_SYSTEM  3
  80 #define ACT_HIDE    4
  81 #ifdef SAL_ENABLE_CRASH_REPORT
  82 #    define ACT_ABORT   5
  83 #else
  84 #    define ACT_ABORT   ACT_SYSTEM
  85 #endif
  86
  87 #if defined HAVE_VALGRIND_HEADERS
  88 #include <valgrind/memcheck.h>
  89 #endif
  90
  91 typedef struct _oslSignalHandlerImpl
  92 {
  93     oslSignalHandlerFunction      Handler;
  94     void*                         pData;
  95     struct _oslSignalHandlerImpl* pNext;
  96 } oslSignalHandlerImpl;
  97
  98 static struct SignalAction
  99 {
 100     int Signal;
 101     int Action;
 102     void (*Handler)(int);
 103 } Signals[] =
 104 {
 105     { SIGHUP,    ACT_HIDE, NULL },    /* hangup */
 106     { SIGINT,    ACT_EXIT,   NULL },    /* interrupt (rubout) */
 107     { SIGQUIT,   ACT_EXIT,  NULL },    /* quit (ASCII FS) */
 108     { SIGILL,    ACT_SYSTEM,  NULL },    /* illegal instruction (not reset when caught) */
 109 /* changed from ACT_ABOUT to ACT_SYSTEM to try and get collector to run*/
 110     { SIGTRAP,   ACT_ABORT,  NULL },    /* trace trap (not reset when caught) */
 111 #if ( SIGIOT != SIGABRT )
 112     { SIGIOT,    ACT_ABORT,  NULL },    /* IOT instruction */
 113 #endif
 114     { SIGABRT,   ACT_ABORT,  NULL },    /* used by abort, replace SIGIOT in the future */
 115 #ifdef SIGEMT
 116     { SIGEMT,    ACT_SYSTEM,  NULL },    /* EMT instruction */
 117 /* changed from ACT_ABORT to ACT_SYSTEM to remove handler*/
 118 /* SIGEMT may also be used by the profiler - so it is probably not a good
 119 plan to have the new handler use this signal*/
 120 #endif
 121     { SIGFPE,    ACT_ABORT,  NULL },    /* floating point exception */
 122     { SIGKILL,   ACT_SYSTEM, NULL },    /* kill (cannot be caught or ignored) */
 123     { SIGBUS,    ACT_ABORT,  NULL },    /* bus error */
 124     { SIGSEGV,   ACT_ABORT,  NULL },    /* segmentation violation */
 125 #ifdef SIGSYS
 126     { SIGSYS,    ACT_ABORT,  NULL },    /* bad argument to system call */
 127 #endif
 128     { SIGPIPE,   ACT_HIDE,   NULL },    /* write on a pipe with no one to read it */
 129     { SIGALRM,   ACT_EXIT,   NULL },    /* alarm clock */
 130     { SIGTERM,   ACT_EXIT,   NULL },    /* software termination signal from kill */
 131     { SIGUSR1,   ACT_SYSTEM, NULL },    /* user defined signal 1 */
 132     { SIGUSR2,   ACT_SYSTEM, NULL },    /* user defined signal 2 */
 133     { SIGCHLD,   ACT_SYSTEM, NULL },    /* child status change */
 134 #ifdef SIGPWR
 135     { SIGPWR,    ACT_IGNORE, NULL },    /* power-fail restart */
 136 #endif
 137     { SIGWINCH,  ACT_IGNORE, NULL },    /* window size change */
 138     { SIGURG,    ACT_EXIT,   NULL },    /* urgent socket condition */
 139 #ifdef SIGPOLL
 140     { SIGPOLL,   ACT_EXIT,   NULL },    /* pollable event occurred */
 141 #endif
 142     { SIGSTOP,   ACT_SYSTEM, NULL },    /* stop (cannot be caught or ignored) */
 143     { SIGTSTP,   ACT_SYSTEM, NULL },    /* user stop requested from tty */
 144     { SIGCONT,   ACT_SYSTEM, NULL },    /* stopped process has been continued */
 145     { SIGTTIN,   ACT_SYSTEM, NULL },    /* background tty read attempted */
 146     { SIGTTOU,   ACT_SYSTEM, NULL },    /* background tty write attempted */
 147     { SIGVTALRM, ACT_EXIT,   NULL },    /* virtual timer expired */
 148     { SIGPROF,   ACT_SYSTEM,   NULL },    /* profiling timer expired */
 149 /*Change from ACT_EXIT to ACT_SYSTEM for SIGPROF is so that profiling signals do
 150 not get taken by the new handler - the new handler does not pass on context
 151 information which causes 'collect' to crash. This is a way of avoiding
 152 what looks like a bug in the new handler*/
 153     { SIGXCPU,   ACT_ABORT,  NULL },    /* exceeded cpu limit */
 154     { SIGXFSZ,   ACT_ABORT,  NULL }     /* exceeded file size limit */
 155 };
 156 const int NoSignals = sizeof(Signals) / sizeof(struct SignalAction);
 157
 158 static sal_Bool               bErrorReportingEnabled = sal_True;
 159 static sal_Bool               bInitSignal = sal_False;
 160 static oslMutex               SignalListMutex;
 161 static oslSignalHandlerImpl*  SignalList;
 162 static sal_Bool               bDoHardKill = sal_False;
 163 static sal_Bool               bSetSEGVHandler = sal_False;
 164 static sal_Bool               bSetWINCHHandler = sal_False;
 165 static sal_Bool               bSetILLHandler = sal_False;
 166
 167 static void SignalHandlerFunction(int);
 168
 169 static void getExecutableName_Impl (rtl_String ** ppstrProgName)
 170 {
 171     rtl_uString * ustrProgFile = 0;
 172     osl_getExecutableFile (&ustrProgFile);
 173     if (ustrProgFile)
 174     {
 175         rtl_uString * ustrProgName = 0;
 176         osl_systemPathGetFileNameOrLastDirectoryPart (ustrProgFile, &ustrProgName);
 177         if (ustrProgName != 0)
 178         {
 179             rtl_uString2String (
 180                 ppstrProgName,
 181                 rtl_uString_getStr (ustrProgName), rtl_uString_getLength (ustrProgName),
 182                 osl_getThreadTextEncoding(),
 183                 OUSTRING_TO_OSTRING_CVTFLAGS);
 184             rtl_uString_release (ustrProgName);
 185         }
 186         rtl_uString_release (ustrProgFile);
 187     }
 188 }
 189
 190 static sal_Bool is_soffice_Impl (void)
 191 {
 192     sal_Int32    idx       = -1;
 193     rtl_String * strProgName = 0;
 194
 195     getExecutableName_Impl (&strProgName);
 196     if (strProgName)
 197     {
 198         idx = rtl_str_indexOfStr (rtl_string_getStr (strProgName), "soffice");
 199         rtl_string_release (strProgName);
 200     }
 201     return (idx != -1);
 202 }
 203
 204 static sal_Bool InitSignal()
 205 {
 206     int i;
 207     struct sigaction act;
 208     struct sigaction oact;
 209     sigset_t unset;
 210
 211     if (is_soffice_Impl())
 212     {
 213         sal_uInt32  argi;
 214         sal_uInt32  argc;
 215         rtl_uString *ustrCommandArg = 0;
 216
 217         argc = osl_getCommandArgCount();
 218         for ( argi = 0; argi < argc; argi++ )
 219         {
 220             if (osl_Process_E_None == osl_getCommandArg (argi, &ustrCommandArg))
 221             {
 222                 if (0 == rtl_ustr_ascii_compare (rtl_uString_getStr (ustrCommandArg), "-bean"))
 223                 {
 224                     bDoHardKill = sal_True;
 225                     break;
 226                 }
 227             }
 228         }
 229         if (ustrCommandArg)
 230         {
 231             rtl_uString_release (ustrCommandArg);
 232             ustrCommandArg = 0;
 233         }
 234
 235         // WORKAROUND FOR SEGV HANDLER CONFLICT
 236         //
 237         // the java jit needs SIGSEGV for proper work
 238         // and we need SIGSEGV for the office crashguard
 239         //
 240         // TEMPORARY SOLUTION:
 241         //   the office sets the signal handler during startup
 242         //   java can than overwrite it, if needed
 243         bSetSEGVHandler = sal_True;
 244
 245         // WORKAROUND FOR WINCH HANDLER (SEE ABOVE)
 246         bSetWINCHHandler = sal_True;
 247
 248         // WORKAROUND FOR ILLEGAL INSTRUCTION HANDLER (SEE ABOVE)
 249         bSetILLHandler = sal_True;
 250     }
 251
 252 #ifdef DBG_UTIL
 253     bSetSEGVHandler = bSetWINCHHandler = bSetILLHandler = bDoHardKill = sal_False;
 254 #endif
 255
 256     SignalListMutex = osl_createMutex();
 257
 258     act.sa_handler = SignalHandlerFunction;
 259     act.sa_flags   = SA_RESTART;
 260
 261     sigfillset(&(act.sa_mask));
 262
 263     /* Initialize the rest of the signals */
 264     for (i = 0; i < NoSignals; ++i)
 265     {
 266 #if defined HAVE_VALGRIND_HEADERS
 267         if (Signals[i].Signal == SIGUSR2 && RUNNING_ON_VALGRIND)
 268             Signals[i].Action = ACT_IGNORE;
 269 #endif
 270
 271         /* hack: stomcatd is attaching JavaVM which does not work with an sigaction(SEGV) */
 272         if ((bSetSEGVHandler || Signals[i].Signal != SIGSEGV)
 273         && (bSetWINCHHandler || Signals[i].Signal != SIGWINCH)
 274         && (bSetILLHandler   || Signals[i].Signal != SIGILL))
 275         {
 276             if (Signals[i].Action != ACT_SYSTEM)
 277             {
 278                 if (Signals[i].Action == ACT_HIDE)
 279                 {
 280                     struct sigaction ign;
 281
 282                     ign.sa_handler = SIG_IGN;
 283                     ign.sa_flags   = 0;
 284                     sigemptyset(&ign.sa_mask);
 285
 286                     if (sigaction(Signals[i].Signal, &ign, &oact) == 0)
 287                         Signals[i].Handler = oact.sa_handler;
 288                     else
 289                         Signals[i].Handler = SIG_DFL;
 290                 }
 291                 else
 292                 {
 293                     if (sigaction(Signals[i].Signal, &act, &oact) == 0)
 294                         Signals[i].Handler = oact.sa_handler;
 295                     else
 296                         Signals[i].Handler = SIG_DFL;
 297                 }
 298             }
 299         }
 300     }
 301
 302     /* Clear signal mask inherited from parent process (on Mac OS X, upon a
 303        crash soffice re-execs itself from within the signal handler, so the
 304        second soffice would have the guilty signal blocked and would freeze upon
 305        encountering a similar crash again): */
 306     if (sigemptyset(&unset) < 0 ||
 307         pthread_sigmask(SIG_SETMASK, &unset, NULL) < 0)
 308     {
 309         OSL_TRACE("sigemptyset or pthread_sigmask failed");
 310     }
 311
 312     return sal_True;
 313 }
 314
 315 static sal_Bool DeInitSignal()
 316 {
 317     int i;
 318     struct sigaction act;
 319
 320     act.sa_flags   = 0;
 321     sigemptyset(&(act.sa_mask));
 322
 323     /* Initialize the rest of the signals */
 324     for (i = NoSignals - 1; i >= 0; i--)
 325         if (Signals[i].Action != ACT_SYSTEM)
 326         {
 327             act.sa_handler = Signals[i].Handler;
 328
 329             sigaction(Signals[i].Signal, &act, NULL);
 330         }
 331
 332     osl_destroyMutex(SignalListMutex);
 333
 334     return sal_False;
 335 }
 336
 337 #if defined (SAL_ENABLE_CRASH_REPORT) && defined(INCLUDE_BACKTRACE)
 338
 339 static sal_uInt32 calc_md5_checksum( const char *filename, sal_uInt8 *pChecksum, sal_uInt32 nChecksumLen )
 340 {
 341     sal_uInt32  nBytesProcessed = 0;
 342
 343     FILE *fp = fopen( filename, "r" );
 344
 345     if ( fp )
 346     {
 347         rtlDigest digest = rtl_digest_createMD5();
 348
 349         if ( digest )
 350         {
 351             size_t          nBytesRead;
 352             sal_uInt8       buffer[4096];
 353             rtlDigestError  error = rtl_Digest_E_None;
 354
 355             while ( rtl_Digest_E_None == error &&
 356                 0 != (nBytesRead = fread( buffer, 1, sizeof(buffer), fp )) )
 357             {
 358                 error = rtl_digest_updateMD5( digest, buffer, nBytesRead );
 359                 nBytesProcessed += nBytesRead;
 360             }
 361
 362             if ( rtl_Digest_E_None == error )
 363             {
 364                 error = rtl_digest_getMD5( digest, pChecksum, nChecksumLen );
 365             }
 366
 367             if ( rtl_Digest_E_None != error )
 368                 nBytesProcessed = 0;
 369
 370             rtl_digest_destroyMD5( digest );
 371         }
 372
 373         fclose( fp );
 374     }
 375
 376     return nBytesProcessed;
 377 }
 378
 379 /*****************************************************************************/
 380 /* Call crash reporter  */
 381 /*****************************************************************************/
 382
 383 /* Helper function to encode and write a string to a stream */
 384
 385 static int fputs_xml( const char *string, FILE *stream )
 386 {
 387     int result = 0;
 388
 389     while ( result >= 0 && *string )
 390     {
 391         switch( *string )
 392         {
 393         case '&':
 394             result = fputs( "&amp;", stream );
 395             break;
 396         case '<':
 397             result = fputs( "&lt;", stream );
 398             break;
 399         case '>':
 400             result = fputs( "&gt;", stream );
 401             break;
 402         default:
 403             result = fputc( *string, stream );
 404             break;
 405         }
 406
 407         string++;
 408     }
 409
 410     return result;
 411 }
 412 #endif
 413
 414 /* Create intermediate files and run crash reporter */
 415
 416 #if defined SAL_ENABLE_CRASH_REPORT && defined INCLUDE_BACKTRACE && \
 417     defined LINUX
 418
 419 typedef struct
 420 {
 421     const char *name;
 422     ElfW(Off) offset;
 423 } dynamic_entry;
 424
 425 static int
 426 callback(struct dl_phdr_info *info, size_t size, void *data)
 427 {
 428     const ElfW(Phdr) *pDynamic = NULL;
 429
 430     if (size == sizeof(struct dl_phdr_info))
 431     {
 432         int i;
 433         for (i = 0; i < info->dlpi_phnum; ++i)
 434         {
 435             if (info->dlpi_phdr[i].p_type == PT_DYNAMIC)
 436             {
 437                 pDynamic = &(info->dlpi_phdr[i]);
 438                 break;
 439             }
 440         }
 441     }
 442
 443     if (pDynamic)
 444     {
 445         char buffer[100];
 446         int len;
 447         char exe[PATH_MAX];
 448         const char *dsoname = info->dlpi_name;
 449
 450         dynamic_entry* entry = (dynamic_entry*)data;
 451
 452         if (strcmp(dsoname, "") == 0)
 453         {
 454             snprintf(buffer, sizeof(buffer), "/proc/%d/exe", getpid());
 455             if ((len = readlink(buffer, exe, PATH_MAX)) != -1)
 456             {
 457                 exe[len] = '\0';
 458                 dsoname = exe;
 459             }
 460         }
 461
 462         if (strcmp(dsoname, entry->name) == 0)
 463         {
 464             entry->offset = pDynamic->p_offset;
 465             return 1;
 466         }
 467     }
 468     return 0;
 469 }
 470
 471 /* Get the location of the .dynamic section offset for the given elf file.
 472  * i.e. same as the "Offset" value shown for DYNAMIC from readelf -l foo
 473  *
 474  * We want to know this value so that if the binaries have been modifed
 475  * by prelink then we can still process the call stack on server side
 476  * by comparing this value to that of an "un-prelinked but known to be
 477  * otherwise equivalent" version of those binaries and adjust the call
 478  * stack addresses by the differences between .dynamic addresses so as
 479  * to be able to map the prelinked addresses back to the unprelinked
 480  * addresses
 481  *
 482  * cmc@openoffice.org
 483  */
 484 static ElfW(Off)
 485 dynamic_section_offset(const char *name)
 486 {
 487     dynamic_entry entry;
 488
 489     entry.name = name;
 490     entry.offset = 0;
 491
 492     dl_iterate_phdr(callback, &entry);
 493
 494     return entry.offset;
 495 }
 496 #endif
 497
 498 static int ReportCrash( int Signal )
 499 {
 500 #ifdef SAL_ENABLE_CRASH_REPORT
 501
 502 #define REPORTENV_PARAM     "-crashreportenv:"
 503
 504     static sal_Bool bCrashReporterExecuted = sal_False;
 505     sal_Bool        bAutoCrashReport = sal_False;
 506
 507     sal_uInt32  argi;
 508     sal_uInt32  argc;
 509     rtl_uString *ustrCommandArg = NULL;
 510
 511     if ( !bErrorReportingEnabled )
 512         return -1;
 513
 514     argc = osl_getCommandArgCount();
 515
 516     for ( argi = 0; argi < argc; argi++ )
 517     {
 518         if ( osl_Process_E_None == osl_getCommandArg( argi, &ustrCommandArg ) )
 519         {
 520             if ( 0 == rtl_ustr_ascii_compare( rtl_uString_getStr( ustrCommandArg ), "--nocrashreport" ) )
 521             {
 522                 rtl_uString_release( ustrCommandArg );
 523                 return -1;
 524             }
 525             else if ( 0 == rtl_ustr_ascii_compare( rtl_uString_getStr( ustrCommandArg ), "--autocrashreport" ) )
 526             {
 527                 bAutoCrashReport = sal_True;
 528             }
 529             else if ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength(
 530                 rtl_uString_getStr( ustrCommandArg ), rtl_uString_getLength( ustrCommandArg ),
 531                 REPORTENV_PARAM, strlen(REPORTENV_PARAM) )
 532                 )
 533             {
 534                 rtl_uString *ustrEnvironment = NULL;
 535                 rtl_String *strEnv = NULL;
 536
 537                 rtl_uString_newFromStr( &ustrEnvironment, rtl_uString_getStr( ustrCommandArg ) + strlen(REPORTENV_PARAM) );
 538
 539                 if ( ustrEnvironment )
 540                 {
 541                     rtl_uString2String(
 542                         &strEnv,
 543                         rtl_uString_getStr( ustrEnvironment ), rtl_uString_getLength( ustrEnvironment ),
 544                         osl_getThreadTextEncoding(), OUSTRING_TO_OSTRING_CVTFLAGS
 545                         );
 546
 547                     if ( strEnv )
 548                     {
 549                         putenv( rtl_string_getStr( strEnv ) );
 550                         rtl_string_release( strEnv );
 551                     }
 552
 553                     rtl_uString_release( ustrEnvironment );
 554                 }
 555
 556             }
 557
 558         }
 559     }
 560
 561     if ( ustrCommandArg )
 562         rtl_uString_release( ustrCommandArg );
 563
 564     if ( !bCrashReporterExecuted )
 565     {
 566         int i;
 567         /* struct sigaction act; */
 568
 569         for (i = 0; i < NoSignals; i++)
 570         {
 571             if (Signals[i].Signal == Signal && Signals[i].Action == ACT_ABORT )
 572             {
 573                 int  ret;
 574                 char szShellCmd[512] = { '\0' };
 575                 char *pXMLTempName = NULL;
 576                 char *pStackTempName = NULL;
 577                 char *pChecksumTempName = NULL;
 578
 579 #ifdef INCLUDE_BACKTRACE
 580                 char szXMLTempNameBuffer[L_tmpnam];
 581                 char szChecksumTempNameBuffer[L_tmpnam];
 582                 char szStackTempNameBuffer[L_tmpnam];
 583
 584                 void *stackframes[MAX_STACK_FRAMES];
 585                 int  iFrame;
 586                 int  nFrames = backtrace( stackframes, SAL_N_ELEMENTS(stackframes) );
 587
 588                 FILE *xmlout = NULL, *stackout = NULL, *checksumout = NULL;
 589                 int fdxml, fdstk, fdchksum;
 590
 591                 strncpy( szXMLTempNameBuffer, P_tmpdir, sizeof(szXMLTempNameBuffer) );
 592                 strncat( szXMLTempNameBuffer, "/crxmlXXXXXX", sizeof(szXMLTempNameBuffer) - strlen(szXMLTempNameBuffer) - 1 );
 593
 594                 strncpy( szStackTempNameBuffer, P_tmpdir, sizeof(szStackTempNameBuffer) );
 595                 strncat( szStackTempNameBuffer, "/crstkXXXXXX", sizeof(szStackTempNameBuffer) - strlen(szStackTempNameBuffer) - 1 );
 596
 597                 strncpy( szChecksumTempNameBuffer, P_tmpdir, sizeof(szChecksumTempNameBuffer) );
 598                 strncat( szChecksumTempNameBuffer, "/crchkXXXXXX", sizeof(szChecksumTempNameBuffer) - strlen(szChecksumTempNameBuffer) - 1 );
 599
 600                 fdxml = mkstemp(szXMLTempNameBuffer);
 601                 fdstk = mkstemp(szStackTempNameBuffer);
 602                 fdchksum = mkstemp(szChecksumTempNameBuffer);
 603
 604                 xmlout = fdopen( fdxml , "w" );
 605                 stackout = fdopen( fdstk , "w" );
 606                 checksumout = fdopen( fdchksum, "w" );
 607
 608                 pXMLTempName = szXMLTempNameBuffer;
 609                 pStackTempName = szStackTempNameBuffer;
 610                 pChecksumTempName = szChecksumTempNameBuffer;
 611
 612
 613                 if ( xmlout && stackout && checksumout )
 614                 {
 615                     fprintf( xmlout, "<errormail:Stack type=\"%s\">\n", STACKTYPE );
 616
 617                     fprintf( checksumout, "<errormail:Checksums type=\"MD5\">\n" );
 618
 619                     for ( iFrame = 0; iFrame < nFrames; iFrame++ )
 620                     {
 621                         Dl_info dl_info;
 622
 623                         fprintf( stackout, "0x%" SAL_PRIxUINTPTR ":",
 624                             SAL_INT_CAST(sal_uIntPtr, stackframes[iFrame]) );
 625
 626                         fprintf( xmlout, "<errormail:StackInfo pos=\"%d\" ip=\"0x%" SAL_PRIxUINTPTR "\"",
 627                             iFrame,
 628                             SAL_INT_CAST(sal_uIntPtr, stackframes[iFrame])
 629                             );
 630
 631                         memset( &dl_info, 0, sizeof(dl_info) );
 632
 633                         /* dladdr may fail */
 634                         if ( dladdr( stackframes[iFrame], &dl_info) )
 635                         {
 636                             const char *dli_fname = NULL;
 637                             char *dli_fdir = NULL;
 638                             char szDirectory[PATH_MAX];
 639                             char szCanonicDirectory[PATH_MAX];
 640
 641                             /* Don't expect that dladdr filled all members of dl_info */
 642
 643                             dli_fname = dl_info.dli_fname ? strrchr(  dl_info.dli_fname, '/' ) : NULL;
 644                             if ( dli_fname )
 645                             {
 646                                 ++dli_fname;
 647                                 memcpy( szDirectory, dl_info.dli_fname, dli_fname - dl_info.dli_fname );
 648                                 szDirectory[dli_fname - dl_info.dli_fname] = 0;
 649
 650                                 dli_fdir = realpath( szDirectory, szCanonicDirectory ) ? szCanonicDirectory : szDirectory;
 651
 652                                 if ( *dli_fdir && dli_fdir[ strlen(dli_fdir) - 1 ] != '/' )
 653                                     strcat( dli_fdir, "/" );
 654                             }
 655                             else
 656                                 dli_fname = dl_info.dli_fname;
 657
 658                             /* create checksum of library on stack */
 659                             if ( dli_fname )
 660                             {
 661                                 sal_uInt8   checksum[RTL_DIGEST_LENGTH_MD5];
 662
 663                                 sal_uInt32 nBytesProcessed = calc_md5_checksum(
 664                                     dl_info.dli_fname, checksum, sizeof(checksum) );
 665                                 if ( nBytesProcessed )
 666                                 {
 667                                     int j;
 668
 669                                     fprintf( checksumout, "<errormail:Checksum sum=\"0x" );
 670                                     for ( j = 0; j < 16; fprintf( checksumout, "%02X", checksum[j++] ) );
 671                                     fprintf( checksumout,
 672                                         "\" bytes=\"%lu\" file=\"%s\"/>\n",
 673                                         SAL_INT_CAST(
 674                                             unsigned long, nBytesProcessed),
 675                                         dli_fname );
 676                                 }
 677                             }
 678
 679                             if ( dl_info.dli_fbase && dl_info.dli_fname )
 680                             {
 681 #ifdef LINUX
 682                                 ElfW(Off) dynamic_offset = dynamic_section_offset(dl_info.dli_fname);
 683                                 fprintf( stackout, " 0x%" SAL_PRI_SIZET "x:", dynamic_offset);
 684 #endif
 685
 686                                 fprintf( stackout, " %s + 0x%" SAL_PRI_PTRDIFFT "x",
 687                                     dl_info.dli_fname,
 688                                     (char*)stackframes[iFrame] - (char*)dl_info.dli_fbase
 689                                     );
 690
 691                                 fprintf( xmlout, " rel=\"0x%" SAL_PRI_PTRDIFFT "x\"", (char *)stackframes[iFrame] - (char *)dl_info.dli_fbase );
 692                                 if ( dli_fname )
 693                                     fprintf( xmlout, " name=\"%s\"", dli_fname );
 694
 695                                 if ( dli_fdir )
 696                                     fprintf( xmlout, " path=\"%s\"", dli_fdir );
 697
 698 #ifdef LINUX
 699                                 fprintf( xmlout, " dynamicoffset=\"0x%" SAL_PRI_SIZET "x\"", dynamic_offset );
 700 #endif
 701                             }
 702                             else
 703                                 fprintf( stackout, " ????????" );
 704
 705                             if ( dl_info.dli_sname && dl_info.dli_saddr )
 706                             {
 707                                 fputs( " (", stackout );
 708                                 fputs_xml( dl_info.dli_sname, stackout );
 709                                 fprintf( stackout, " + 0x%" SAL_PRI_PTRDIFFT "x)",
 710                                     (char*)stackframes[iFrame] - (char*)dl_info.dli_saddr );
 711
 712                                 fputs( " ordinal=\"", xmlout );
 713                                 fputs_xml( dl_info.dli_sname, xmlout );
 714                                 fprintf( xmlout, "+0x%" SAL_PRI_PTRDIFFT "x\"",
 715                                     (char *)stackframes[iFrame] - (char *)dl_info.dli_saddr );
 716                             }
 717
 718                         }
 719                         else /* dladdr failed */
 720                         {
 721                             fprintf( stackout, " ????????" );
 722                         }
 723
 724                         fprintf( stackout, "\n" );
 725                         fprintf( xmlout, "/>\n" );
 726
 727                     }
 728
 729                     fprintf( xmlout, "</errormail:Stack>\n" );
 730                     fprintf( checksumout, "</errormail:Checksums>\n" );
 731                 }
 732                 else
 733                 {
 734                     pXMLTempName = NULL;
 735                     pStackTempName = NULL;
 736                     pChecksumTempName = NULL;
 737                 }
 738
 739                 if ( stackout )
 740                     fclose( stackout );
 741                 if ( xmlout )
 742                     fclose( xmlout );
 743                 if ( checksumout )
 744                     fclose( checksumout );
 745
 746                 if ( pXMLTempName && pChecksumTempName && pStackTempName )
 747 #endif /* INCLUDE_BACKTRACE */
 748                 {
 749                     rtl_uString * crashrep_url = NULL;
 750                     rtl_uString * crashrep_path = NULL;
 751                     rtl_String  * crashrep_path_system = NULL;
 752                     rtl_string2UString(
 753                         &crashrep_url,
 754                         RTL_CONSTASCII_USTRINGPARAM(
 755                             "$BRAND_BASE_DIR/program/crashrep"),
 756                         OSTRING_TO_OUSTRING_CVTFLAGS);
 757                     rtl_bootstrap_expandMacros(&crashrep_url);
 758                     osl_getSystemPathFromFileURL(crashrep_url, &crashrep_path);
 759                     rtl_uString2String(
 760                         &crashrep_path_system,
 761                         rtl_uString_getStr(crashrep_path),
 762                         rtl_uString_getLength(crashrep_path),
 763                         osl_getThreadTextEncoding(),
 764                         (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
 765                          | RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR));
 766                     rtl_uString_release(crashrep_url);
 767                     rtl_uString_release(crashrep_path);
 768 #if defined INCLUDE_BACKTRACE && (defined LINUX || defined MACOSX)
 769                     snprintf( szShellCmd, SAL_N_ELEMENTS(szShellCmd),
 770                         "%s -p %d -s %d -xml %s -chksum %s -stack %s -noui%s",
 771                         rtl_string_getStr(crashrep_path_system),
 772                         getpid(),
 773                         Signal,
 774                         pXMLTempName,
 775                         pChecksumTempName,
 776                         pStackTempName,
 777                         bAutoCrashReport ? " -send" : "" );
 778 #elif defined INCLUDE_BACKTRACE && defined SOLARIS
 779                     snprintf( szShellCmd, SAL_N_ELEMENTS(szShellCmd),
 780                         "%s -p %d -s %d -xml %s -chksum %s -noui%s",
 781                         rtl_string_getStr(crashrep_path_system),
 782                         getpid(),
 783                         Signal,
 784                         pXMLTempName,
 785                         pChecksumTempName,
 786                         bAutoCrashReport ? " -send" : "" );
 787 #else
 788                     snprintf( szShellCmd, SAL_N_ELEMENTS(szShellCmd),
 789                         "%s -p %d -s %d -noui%s",
 790                         rtl_string_getStr(crashrep_path_system),
 791                         getpid(), Signal, bAutoCrashReport ? " -send" : "" );
 792 #endif
 793                     rtl_string_release(crashrep_path_system);
 794                 }
 795
 796                 ret = szShellCmd[0] == '\0' ? -1 : system( szShellCmd );
 797
 798                 if ( pXMLTempName )
 799                     unlink( pXMLTempName );
 800
 801                 if ( pStackTempName )
 802                     unlink( pStackTempName );
 803
 804                 if ( pChecksumTempName )
 805                     unlink( pChecksumTempName );
 806
 807                 if ( -1 != ret )
 808                 {
 809                     bCrashReporterExecuted = sal_True;
 810                     return 1;
 811                 }
 812                 else
 813                     return -1;
 814
 815             }
 816         }
 817
 818         return 0;
 819     }
 820
 821     return 1;
 822 #else /* defined SAL_ENABLE_CRASH_REPORT */
 823     /* the utility crash_report is not build, so do the same as when
 824        the option -nocrashreport is used */
 825     (void) Signal; // avoid warnings
 826     return -1;
 827 #endif /* defined SAL_ENABLE_CRASH_REPORT */
 828 }
 829
 830 static void PrintStack( int sig )
 831 {
 832 #ifdef INCLUDE_BACKTRACE
 833     void *buffer[MAX_STACK_FRAMES];
 834     int size = backtrace( buffer, SAL_N_ELEMENTS(buffer) );
 835 #endif
 836
 837     fprintf( stderr, "\n\nFatal exception: Signal %d\n", sig );
 838
 839 #if defined( MACOSX ) && !defined( INCLUDE_BACKTRACE )
 840     fprintf( stderr, "Please turn on Enable Crash Reporting and\nAutomatic Display of Crashlogs in the Console application\n" );
 841 #else
 842 #ifdef INCLUDE_BACKTRACE
 843     if ( size > 0 )
 844     {
 845         fputs( "Stack:\n", stderr );
 846         backtrace_symbols_fd( buffer, size, fileno(stderr) );
 847     }
 848 #endif
 849 #endif
 850 }
 851
 852 static oslSignalAction CallSignalHandler(oslSignalInfo *pInfo)
 853 {
 854     oslSignalHandlerImpl* pHandler = SignalList;
 855     oslSignalAction Action = osl_Signal_ActCallNextHdl;
 856
 857     while (pHandler != NULL)
 858     {
 859         if ((Action = pHandler->Handler(pHandler->pData, pInfo))
 860             != osl_Signal_ActCallNextHdl)
 861             break;
 862
 863         pHandler = pHandler->pNext;
 864     }
 865
 866     return Action;
 867 }
 868
 869 void CallSystemHandler(int Signal)
 870 {
 871     int i;
 872     struct sigaction act;
 873
 874     for (i = 0; i < NoSignals; i++)
 875     {
 876         if (Signals[i].Signal == Signal)
 877             break;
 878     }
 879
 880     if (i < NoSignals)
 881     {
 882         if ((Signals[i].Handler == NULL)    ||
 883             (Signals[i].Handler == SIG_DFL) ||
 884             (Signals[i].Handler == SIG_IGN) ||
 885              (Signals[i].Handler == SIG_ERR))
 886         {
 887             switch (Signals[i].Action)
 888             {
 889                 case ACT_EXIT:      /* terminate */
 890                     /* prevent dumping core on exit() */
 891                     _exit(255);
 892                     break;
 893
 894                 case ACT_ABORT:     /* terminate witch core dump */
 895                     ReportCrash( Signal );
 896                     act.sa_handler = SIG_DFL;
 897                     act.sa_flags   = 0;
 898                     sigemptyset(&(act.sa_mask));
 899                     sigaction(SIGABRT, &act, NULL);
 900                     PrintStack( Signal );
 901                     abort();
 902                     break;
 903
 904                 case ACT_IGNORE:    /* ignore */
 905                     break;
 906
 907                 default:            /* should never happen */
 908                     OSL_ASSERT(0);
 909             }
 910         }
 911         else
 912             (*Signals[i].Handler)(Signal);
 913     }
 914 }
 915
 916 #if defined HAVE_VALGRIND_HEADERS
 917 static void DUMPCURRENTALLOCS()
 918 {
 919     VALGRIND_PRINTF( "=== start memcheck dump of active allocations ===\n" );
 920
 921 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 922 #   pragma GCC diagnostic push
 923 #   pragma GCC diagnostic ignored "-Wunused-but-set-variable"
 924 #endif
 925
 926     VALGRIND_DO_LEAK_CHECK;
 927
 928 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 929 #   pragma GCC diagnostic pop
 930 #endif
 931
 932     VALGRIND_PRINTF( "=== end memcheck dump of active allocations ===\n" );
 933 }
 934 #endif
 935
 936 void SignalHandlerFunction(int Signal)
 937 {
 938     oslSignalInfo    Info;
 939     struct sigaction act;
 940
 941     Info.UserSignal = Signal;
 942     Info.UserData   = NULL;
 943
 944     switch (Signal)
 945     {
 946         case SIGBUS:
 947         case SIGILL:
 948         case SIGSEGV:
 949         case SIGIOT:
 950 #if ( SIGIOT != SIGABRT )
 951         case SIGABRT:
 952 #endif
 953             Info.Signal = osl_Signal_AccessViolation;
 954             break;
 955
 956         case -1:
 957             Info.Signal = osl_Signal_IntegerDivideByZero;
 958             break;
 959
 960         case SIGFPE:
 961             Info.Signal = osl_Signal_FloatDivideByZero;
 962             break;
 963
 964         case SIGINT:
 965         case SIGTERM:
 966         case SIGQUIT:
 967             Info.Signal = osl_Signal_Terminate;
 968             break;
 969
 970 #if defined HAVE_VALGRIND_HEADERS
 971         case SIGUSR2:
 972             if (RUNNING_ON_VALGRIND)
 973                 DUMPCURRENTALLOCS();
 974             Info.Signal = osl_Signal_System;
 975             break;
 976 #endif
 977
 978         default:
 979             Info.Signal = osl_Signal_System;
 980             break;
 981     }
 982
 983     ReportCrash( Signal );
 984
 985     /* Portal Demo HACK !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 986     if (bDoHardKill && (Info.Signal == osl_Signal_AccessViolation))
 987         _exit(255);
 988     /* Portal Demo HACK !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 989
 990
 991     switch (CallSignalHandler(&Info))
 992     {
 993     case osl_Signal_ActCallNextHdl:
 994         CallSystemHandler(Signal);
 995         break;
 996
 997     case osl_Signal_ActAbortApp:
 998         ReportCrash( Signal );
 999         act.sa_handler = SIG_DFL;
1000         act.sa_flags   = 0;
1001         sigemptyset(&(act.sa_mask));
1002         sigaction(SIGABRT, &act, NULL);
1003         PrintStack( Signal );
1004         abort();
1005         break;
1006
1007     case osl_Signal_ActKillApp:
1008         /* prevent dumping core on exit() */
1009         _exit(255);
1010         break;
1011     default:
1012         break;
1013     }
1014 }
1015
1016 oslSignalHandler SAL_CALL osl_addSignalHandler(oslSignalHandlerFunction Handler, void* pData)
1017 {
1018     oslSignalHandlerImpl* pHandler;
1019
1020     OSL_ASSERT(Handler != NULL);
1021     if ( Handler == 0 )
1022     {
1023         return 0;
1024     }
1025
1026     if (! bInitSignal)
1027         bInitSignal = InitSignal();
1028
1029     pHandler = (oslSignalHandlerImpl*) calloc(1, sizeof(oslSignalHandlerImpl));
1030
1031     if (pHandler != NULL)
1032     {
1033         pHandler->Handler = Handler;
1034         pHandler->pData   = pData;
1035
1036         osl_acquireMutex(SignalListMutex);
1037
1038         pHandler->pNext = SignalList;
1039         SignalList      = pHandler;
1040
1041         osl_releaseMutex(SignalListMutex);
1042
1043         return (pHandler);
1044     }
1045
1046     return (NULL);
1047 }
1048
1049 sal_Bool SAL_CALL osl_removeSignalHandler(oslSignalHandler Handler)
1050 {
1051     oslSignalHandlerImpl *pHandler, *pPrevious = NULL;
1052
1053     OSL_ASSERT(Handler != NULL);
1054
1055     if (! bInitSignal)
1056         bInitSignal = InitSignal();
1057
1058     osl_acquireMutex(SignalListMutex);
1059
1060     pHandler = SignalList;
1061
1062     while (pHandler != NULL)
1063     {
1064         if (pHandler == Handler)
1065         {
1066             if (pPrevious)
1067                 pPrevious->pNext = pHandler->pNext;
1068             else
1069                 SignalList = pHandler->pNext;
1070
1071             osl_releaseMutex(SignalListMutex);
1072
1073             if (SignalList == NULL)
1074                 bInitSignal = DeInitSignal();
1075
1076             free(pHandler);
1077
1078             return (sal_True);
1079         }
1080
1081         pPrevious = pHandler;
1082         pHandler  = pHandler->pNext;
1083     }
1084
1085     osl_releaseMutex(SignalListMutex);
1086
1087     return (sal_False);
1088 }
1089
1090 oslSignalAction SAL_CALL osl_raiseSignal(sal_Int32 UserSignal, void* UserData)
1091 {
1092     oslSignalInfo   Info;
1093     oslSignalAction Action;
1094
1095     if (! bInitSignal)
1096         bInitSignal = InitSignal();
1097
1098     osl_acquireMutex(SignalListMutex);
1099
1100     Info.Signal     = osl_Signal_User;
1101     Info.UserSignal = UserSignal;
1102     Info.UserData   = UserData;
1103
1104     Action = CallSignalHandler(&Info);
1105
1106     osl_releaseMutex(SignalListMutex);
1107
1108     return (Action);
1109 }
1110
1111 sal_Bool SAL_CALL osl_setErrorReporting( sal_Bool bEnable )
1112 {
1113     sal_Bool bOld = bErrorReportingEnabled;
1114     bErrorReportingEnabled = bEnable;
1115
1116     return bOld;
1117 }
1118
1119 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */