You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdelibs/kdecore/kcrash.cpp

525 lines
13 KiB

/*
* This file is part of the KDE Libraries
* Copyright (C) 2000 Timo Hummel <timo.hummel@sap.com>
* Tom Braun <braunt@fh-konstanz.de>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/*
* This file is used to catch signals which would normally
* crash the application (like segmentation fault, floating
* point exception and such).
*/
#include "config.h"
#include <string.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include "kcrash.h"
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <sys/socket.h>
#include <errno.h>
#include <tqwindowdefs.h>
#include <kglobal.h>
#include <kinstance.h>
#include <kaboutdata.h>
#include <kdebug.h>
#include <kapplication.h>
#include <dcopclient.h>
#include <../kinit/klauncher_cmds.h>
#if defined Q_WS_X11
#include <X11/Xlib.h>
#endif
KCrash::HandlerType KCrash::_emergencySaveFunction = 0;
KCrash::HandlerType KCrash::_crashHandler = 0;
const char *KCrash::appName = 0;
const char *KCrash::appPath = 0;
bool KCrash::safer = false;
// This function sets the function which should be called when the
// application crashes and the
// application is asked to try to save its data.
void
KCrash::setEmergencySaveFunction (HandlerType saveFunction)
{
_emergencySaveFunction = saveFunction;
/*
* We need at least the default crash handler for
* emergencySaveFunction to be called
*/
if (_emergencySaveFunction && !_crashHandler)
_crashHandler = defaultCrashHandler;
}
// This function sets the function which should be responsible for
// the application crash handling.
void
KCrash::setCrashHandler (HandlerType handler)
{
#ifdef Q_OS_UNIX
if (!handler)
handler = SIG_DFL;
sigset_t tqmask;
sigemptyset(&tqmask);
#ifdef SIGSEGV
signal (SIGSEGV, handler);
sigaddset(&tqmask, SIGSEGV);
#endif
#ifdef SIGFPE
signal (SIGFPE, handler);
sigaddset(&tqmask, SIGFPE);
#endif
#ifdef SIGILL
signal (SIGILL, handler);
sigaddset(&tqmask, SIGILL);
#endif
#ifdef SIGABRT
signal (SIGABRT, handler);
sigaddset(&tqmask, SIGABRT);
#endif
sigprocmask(SIG_UNBLOCK, &tqmask, 0);
#endif //Q_OS_UNIX
_crashHandler = handler;
}
void
KCrash::defaultCrashHandler (int sig)
{
#ifdef Q_OS_UNIX
// WABA: Do NOT use kdDebug() in this function because it is much too risky!
// Handle possible recursions
static int crashRecursionCounter = 0;
crashRecursionCounter++; // Nothing before this, please !
signal(SIGALRM, SIG_DFL);
alarm(3); // Kill me... (in case we deadlock in malloc)
if (crashRecursionCounter < 2) {
if (_emergencySaveFunction) {
_emergencySaveFunction (sig);
}
crashRecursionCounter++; //
}
// Close all remaining file descriptors except for stdin/stdout/stderr
struct rlimit rlp;
getrlimit(RLIMIT_NOFILE, &rlp);
for (int i = 3; i < (int)rlp.rlim_cur; i++)
close(i);
// this code is leaking, but this should not hurt cause we will do a
// exec() afterwards. exec() is supposed to clean up.
if (crashRecursionCounter < 3)
{
if (appName)
{
#ifndef NDEBUG
fprintf(stderr, "KCrash: crashing... crashRecursionCounter = %d\n", crashRecursionCounter);
fprintf(stderr, "KCrash: Application Name = %s path = %s pid = %d\n", appName ? appName : "<unknown>" , appPath ? appPath : "<unknown>", getpid());
#else
fprintf(stderr, "KCrash: Application '%s' crashing...\n", appName ? appName : "<unknown>");
#endif
const char * argv[24]; // don't forget to update this
int i = 0;
// argument 0 has to be drkonqi
argv[i++] = "drkonqi";
#if defined Q_WS_X11
// start up on the correct display
argv[i++] = "-display";
if ( qt_xdisplay() )
argv[i++] = XDisplayString(qt_xdisplay());
else
argv[i++] = getenv("DISPLAY");
#elif defined(Q_WS_QWS)
// start up on the correct display
argv[i++] = "-display";
argv[i++] = getenv("QWS_DISPLAY");
#endif
// we have already tested this
argv[i++] = "--appname";
argv[i++] = appName;
if (KApplication::loadedByKdeinit)
argv[i++] = "--kdeinit";
// only add apppath if it's not NULL
if (appPath) {
argv[i++] = "--apppath";
argv[i++] = appPath;
}
// signal number -- will never be NULL
char sigtxt[ 10 ];
sprintf( sigtxt, "%d", sig );
argv[i++] = "--signal";
argv[i++] = sigtxt;
char pidtxt[ 10 ];
sprintf( pidtxt, "%d", getpid());
argv[i++] = "--pid";
argv[i++] = pidtxt;
const KInstance *instance = KGlobal::_instance;
const KAboutData *about = instance ? instance->aboutData() : 0;
if (about) {
if (about->internalVersion()) {
argv[i++] = "--appversion";
argv[i++] = about->internalVersion();
}
if (about->internalProgramName()) {
argv[i++] = "--programname";
argv[i++] = about->internalProgramName();
}
if (about->internalBugAddress()) {
argv[i++] = "--bugaddress";
argv[i++] = about->internalBugAddress();
}
}
if ( kapp && !kapp->startupId().isNull()) {
argv[i++] = "--startupid";
argv[i++] = kapp->startupId().data();
}
if ( safer )
argv[i++] = "--safer";
// NULL terminated list
argv[i] = NULL;
startDrKonqi( argv, i );
_exit(253);
}
else {
fprintf(stderr, "Unknown appname\n");
}
}
if (crashRecursionCounter < 4)
{
fprintf(stderr, "Unable to start Dr. Konqi\n");
}
#endif //Q_OS_UNIX
_exit(255);
}
#ifdef Q_OS_UNIX
// Since we can't fork() in the crashhandler, we cannot execute any external code
// (there can be functions registered to be performed before fork(), for example
// handling of malloc locking, which doesn't work when malloc crashes because of heap corruption).
static int write_socket(int sock, char *buffer, int len);
static int read_socket(int sock, char *buffer, int len);
static int openSocket();
void KCrash::startDrKonqi( const char* argv[], int argc )
{
int socket = openSocket();
if( socket < -1 )
{
startDirectly( argv, argc );
return;
}
klauncher_header header;
header.cmd = LAUNCHER_EXEC_NEW;
const int BUFSIZE = 8192; // make sure this is big enough
char buffer[ BUFSIZE + 10 ];
int pos = 0;
long argcl = argc;
memcpy( buffer + pos, &argcl, sizeof( argcl ));
pos += sizeof( argcl );
for( int i = 0;
i < argc;
++i )
{
int len = strlen( argv[ i ] ) + 1; // include terminating \0
if( pos + len > BUFSIZE )
{
fprintf( stderr, "BUFSIZE in KCrash not big enough!\n" );
startDirectly( argv, argc );
return;
}
memcpy( buffer + pos, argv[ i ], len );
pos += len;
}
long env = 0;
memcpy( buffer + pos, &env, sizeof( env ));
pos += sizeof( env );
long avoid_loops = 0;
memcpy( buffer + pos, &avoid_loops, sizeof( avoid_loops ));
pos += sizeof( avoid_loops );
header.arg_length = pos;
write_socket(socket, (char *) &header, sizeof(header));
write_socket(socket, buffer, pos);
if( read_socket( socket, (char *) &header, sizeof(header)) < 0
|| header.cmd != LAUNCHER_OK )
{
startDirectly( argv, argc );
return;
}
long pid;
read_socket(socket, buffer, header.arg_length);
pid = *((long *) buffer);
alarm(0); // Seems we made it....
for(;;)
{
if( kill( pid, 0 ) < 0 )
_exit(253);
sleep(1);
// the debugger should stop this process anyway
}
}
// If we can't reach kdeinit we can still at least try to fork()
void KCrash::startDirectly( const char* argv[], int )
{
fprintf( stderr, "KCrash cannot reach kdeinit, launching directly.\n" );
pid_t pid = fork();
if (pid <= 0)
{
if(!geteuid() && setgid(getgid()) < 0)
_exit(253);
if(!geteuid() && setuid(getuid()) < 0)
_exit(253);
execvp("drkonqi", const_cast< char** >( argv ));
_exit(errno);
}
else
{
alarm(0); // Seems we made it....
// wait for child to exit
waitpid(pid, NULL, 0);
_exit(253);
}
}
// From now on this code is copy&pasted from kinit/wrapper.c :
extern char **environ;
static char *getDisplay()
{
const char *display;
char *result;
char *screen;
char *colon;
char *i;
/*
don't test for a value from tqglobal.h but instead distinguish
Qt/X11 from Qt/Embedded by the fact that Qt/E apps have -DQWS
on the commandline (which in tqglobal.h however triggers Q_WS_QWS,
but we don't want to include that here) (Simon)
#ifdef Q_WS_X11
*/
#if !defined(QWS)
display = getenv("DISPLAY");
#else
display = getenv("QWS_DISPLAY");
#endif
if (!display || !*display)
{
display = ":0";
}
result = (char*)malloc(strlen(display)+1);
if (result == NULL)
return NULL;
strcpy(result, display);
screen = strrchr(result, '.');
colon = strrchr(result, ':');
if (screen && (screen > colon))
*screen = '\0';
while((i = strchr(result, ':')))
*i = '_';
return result;
}
/*
* Write 'len' bytes from 'buffer' into 'sock'.
* returns 0 on success, -1 on failure.
*/
static int write_socket(int sock, char *buffer, int len)
{
ssize_t result;
int bytes_left = len;
while ( bytes_left > 0)
{
result = write(sock, buffer, bytes_left);
if (result > 0)
{
buffer += result;
bytes_left -= result;
}
else if (result == 0)
return -1;
else if ((result == -1) && (errno != EINTR) && (errno != EAGAIN))
return -1;
}
return 0;
}
/*
* Read 'len' bytes from 'sock' into 'buffer'.
* returns 0 on success, -1 on failure.
*/
static int read_socket(int sock, char *buffer, int len)
{
ssize_t result;
int bytes_left = len;
while ( bytes_left > 0)
{
result = read(sock, buffer, bytes_left);
if (result > 0)
{
buffer += result;
bytes_left -= result;
}
else if (result == 0)
return -1;
else if ((result == -1) && (errno != EINTR) && (errno != EAGAIN))
return -1;
}
return 0;
}
static int openSocket()
{
kde_socklen_t socklen;
int s;
struct sockaddr_un server;
#define MAX_SOCK_FILE 255
char sock_file[MAX_SOCK_FILE + 1];
const char *home_dir = getenv("HOME");
const char *kde_home = getenv("KDEHOME");
char *display;
sock_file[0] = sock_file[MAX_SOCK_FILE] = 0;
if (!kde_home || !kde_home[0])
{
kde_home = "~/.kde3/";
}
if (kde_home[0] == '~')
{
if (!home_dir || !home_dir[0])
{
fprintf(stderr, "Warning: $HOME not set!\n");
return -1;
}
if (strlen(home_dir) > (MAX_SOCK_FILE-100))
{
fprintf(stderr, "Warning: Home directory path too long!\n");
return -1;
}
kde_home++;
strncpy(sock_file, home_dir, MAX_SOCK_FILE);
}
strncat(sock_file, kde_home, MAX_SOCK_FILE - strlen(sock_file));
/** Strip trailing '/' **/
if ( sock_file[strlen(sock_file)-1] == '/')
sock_file[strlen(sock_file)-1] = 0;
strncat(sock_file, "/socket-", MAX_SOCK_FILE - strlen(sock_file));
if( getenv("XAUTHLOCALHOSTNAME"))
strncat(sock_file, getenv("XAUTHLOCALHOSTNAME"), MAX_SOCK_FILE - strlen(sock_file) - 1);
else if (gethostname(sock_file+strlen(sock_file), MAX_SOCK_FILE - strlen(sock_file) - 1) != 0)
{
perror("Warning: Could not determine hostname: ");
return -1;
}
sock_file[sizeof(sock_file)-1] = '\0';
/* append $DISPLAY */
display = getDisplay();
if (display == NULL)
{
fprintf(stderr, "Error: Could not determine display.\n");
return -1;
}
if (strlen(sock_file)+strlen(display)+strlen("/kdeinit_")+2 > MAX_SOCK_FILE)
{
fprintf(stderr, "Warning: Socket name will be too long.\n");
free(display);
return -1;
}
strcat(sock_file, "/kdeinit_");
strcat(sock_file, display);
free(display);
if (strlen(sock_file) >= sizeof(server.sun_path))
{
fprintf(stderr, "Warning: Path of socketfile exceeds UNIX_PATH_MAX.\n");
return -1;
}
/*
* create the socket stream
*/
s = socket(PF_UNIX, SOCK_STREAM, 0);
if (s < 0)
{
perror("Warning: socket() failed: ");
return -1;
}
server.sun_family = AF_UNIX;
strcpy(server.sun_path, sock_file);
socklen = sizeof(server);
if(connect(s, (struct sockaddr *)&server, socklen) == -1)
{
perror("Warning: connect() failed: ");
close(s);
return -1;
}
return s;
}
#endif // Q_OS_UNIX