sal/osl/unx/signal.c

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