segv_handler/gnome-segvhanlder.c

   1 /* bug-buddy bug submitting program
   2  *
   3  * Copyright (C) 2007 Fernando Herrera
   4  *
   5  * Authors: Fernando Herrera  <fherrera@onirica.com>
   6  *          Cosimo Cecchi     <cosimoc@gnome.org>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of version 2 of the GNU General Public
  10  * License as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <signal.h>
  26 #include <sys/wait.h>
  27
  28 #include <glib.h>
  29 #include <glib/gstdio.h>
  30
  31 #include <gdk/gdk.h>
  32 #include <gdk/gdkx.h>
  33 #include <X11/Xlib.h>
  34
  35 #include <config.h>
  36
  37 #include <string.h>
  38
  39 const char         *g_module_check_init (GModule *module);
  40 int                gtk_module_init      (int *argc, char** argv[]);
  41 static gboolean    run_bug_buddy        (const gchar *appname, pid_t pid);
  42 static gboolean    release_grabs        (void);
  43
  44 static gchar *bugbuddy;
  45 static GLogFunc old_handler = NULL;
  46
  47 typedef struct {
  48         int start;
  49         int next_free;
  50         int size;
  51         char **strings;
  52 } CircBuff;
  53
  54 static CircBuff * log_buff = NULL;
  55 #define LOG_BUFFER_SIZE 15
  56
  57 static void
  58 circ_buff_free (CircBuff *buff)
  59 {
  60         if (!buff) {
  61                 return;
  62         }
  63
  64         g_strfreev (buff->strings);
  65         g_free (buff);
  66
  67         buff = NULL;
  68 }
  69
  70 static CircBuff *
  71 circ_buff_new (int size)
  72 {
  73         CircBuff *retval;
  74
  75         retval = g_new0 (CircBuff, 1);
  76         retval->strings = g_new0 (char *, size + 1);
  77         retval->strings[size] = NULL;
  78         retval->size = size;
  79
  80         return retval;
  81 }
  82
  83 static void
  84 circ_add (CircBuff *buff, char * str)
  85 {
  86         if (buff->strings[buff->next_free]) {
  87                 g_free (buff->strings[buff->next_free]);
  88                 buff->start = (buff->start + 1) % buff->size;
  89         }
  90
  91         buff->strings[buff->next_free] = str;
  92         buff->next_free = (buff->next_free + 1) % buff->size;
  93 }
  94
  95 static char *
  96 circ_buff_to_file (CircBuff *buff)
  97 {
  98         int tmp_fd, i;
  99         char *actual_name = NULL;
 100         GError *error = NULL;
 101         const char *header;
 102
 103         if (!buff) {
 104                 return NULL;
 105         }
 106
 107         tmp_fd = g_file_open_tmp ("bug-buddy-XXXXXX", &actual_name, &error);
 108
 109         if (error) {
 110                 g_warning ("Unable to create the warnings temp file: %s", error->message);
 111                 g_error_free (error);
 112                 return NULL;
 113         }
 114
 115         header = "\n\n---- Critical and fatal warnings logged during execution ----\n\n";
 116         write (tmp_fd, header, strlen (header));
 117
 118         i = buff->start;
 119
 120         while (buff->strings[i] != NULL) {
 121                 /* write to file */
 122                 write (tmp_fd, buff->strings[i], strlen (buff->strings[i]));
 123
 124                 /* increase and check for overflow */
 125                 i = (i + 1) % buff->size;
 126
 127                 if (i == buff->start)
 128                         break;
 129         }
 130
 131         close (tmp_fd);
 132
 133         return actual_name;
 134 }
 135
 136 static void
 137 bug_buddy_log_handler (const gchar *log_domain,
 138                        GLogLevelFlags log_level,
 139                        const gchar *message,
 140                        gpointer user_data)
 141 {
 142         /* forward the message to the real handler and use the default GLib
 143          * handler if that's NULL (should never happen, but who knows).
 144          */
 145         if (old_handler) {
 146                 old_handler (log_domain, log_level, message, user_data);
 147         } else {
 148                 g_log_default_handler (log_domain, log_level, message, user_data);
 149         }
 150
 151         if (log_level &
 152             (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL))
 153         {
 154                 /* log the message into memory */
 155                 if (!log_buff) {
 156                         log_buff = circ_buff_new (LOG_BUFFER_SIZE);
 157                 }
 158
 159                 /* if the log domain is NULL, assume it's a message coming from the app,
 160                  * see the docs for G_LOG_DOMAIN.
 161                  */
 162                 circ_add (log_buff, g_strdup_printf ("** %s **: %s \n", log_domain ? log_domain : g_get_prgname (), message));
 163         }
 164 }
 165
 166 static void
 167 bugbuddy_segv_handle(int signum)
 168 {
 169         static int in_segv = 0;
 170         struct sigaction sa;
 171         pid_t pid;
 172         gchar *appname;
 173         gboolean res;
 174
 175         sa.sa_handler = NULL;
 176         in_segv++;
 177
 178         if (in_segv > 2) {
 179                 /* The fprintf() was segfaulting, we are just totally hosed */
 180                 _exit(1);
 181         } else if (in_segv > 1) {
 182                 /* dialog display isn't working out */
 183                 fprintf(stderr, "Multiple segmentation faults occurred; can't display error dialog\n");
 184                 _exit(1);
 185         }
 186
 187         release_grabs ();
 188
 189         appname = g_get_prgname ();
 190         pid = getpid ();
 191         res = run_bug_buddy (appname, pid);
 192         if (!res)
 193                 _exit (1);
 194
 195         _exit(0);
 196 }
 197
 198 static gboolean
 199 release_grabs (void)
 200 {
 201         /* Make sure we release grabs */
 202         gdk_pointer_ungrab(GDK_CURRENT_TIME);
 203         gdk_keyboard_ungrab(GDK_CURRENT_TIME);
 204
 205         /* TODO: can we replace this with gdk_x11_ungrab_server ()?
 206          * see http://bugzilla.gnome.org/show_bug.cgi?id=550135.
 207          */
 208         XUngrabServer (GDK_DISPLAY ());
 209
 210         gdk_flush();
 211
 212         return TRUE;
 213 }
 214
 215 static gboolean
 216 run_bug_buddy (const gchar *appname, pid_t pid)
 217 {
 218         gboolean res;
 219         char *warning_file, *exec_str;
 220         GString *args_str;
 221         GError *error = NULL;
 222
 223         if (pid == 0)
 224                 return FALSE;
 225
 226         warning_file = circ_buff_to_file (log_buff);
 227         circ_buff_free (log_buff);
 228
 229         args_str = g_string_new ("bug-buddy ");
 230         g_string_append_printf (args_str, "--appname=\"%s\" ", appname);
 231
 232         if (warning_file) {
 233                 g_string_append_printf (args_str, "--include=\"%s\" --unlink-tempfile ", warning_file);
 234                 g_free (warning_file);
 235         }
 236
 237         g_string_append_printf (args_str,  "--pid=%d",(int) pid);
 238
 239         exec_str = g_string_free (args_str, FALSE);
 240         res = g_spawn_command_line_sync (exec_str, NULL, NULL,
 241                                          NULL, &error);
 242         g_free (exec_str);
 243         if (!res) {
 244                 g_warning ("Couldn't run bug-buddy\n");
 245                 return FALSE;
 246         }
 247
 248         return TRUE;
 249 }
 250
 251 int
 252 gtk_module_init (int *argc, char** argv[])
 253 {
 254         bugbuddy = g_find_program_in_path ("bug-buddy");
 255
 256         if (bugbuddy && !g_getenv ("GNOME_DISABLE_CRASH_DIALOG")) {
 257
 258                 static struct sigaction *setptr;
 259                 static struct sigaction old_action;
 260                 struct sigaction sa;
 261                 memset(&sa, 0, sizeof(sa));
 262                 setptr = &sa;
 263
 264                 sa.sa_handler = bugbuddy_segv_handle;
 265
 266                 sigaction(SIGSEGV, NULL, &old_action);
 267                 if (old_action.sa_handler == SIG_DFL)
 268                         sigaction(SIGSEGV, setptr, NULL);
 269
 270                 sigaction(SIGABRT, NULL, &old_action);
 271                 if (old_action.sa_handler == SIG_DFL)
 272                         sigaction(SIGABRT, setptr, NULL);
 273
 274                 sigaction(SIGTRAP, NULL, &old_action);
 275                 if (old_action.sa_handler == SIG_DFL)
 276                         sigaction(SIGTRAP, setptr, NULL);
 277
 278                 sigaction(SIGFPE, NULL, &old_action);
 279                 if (old_action.sa_handler == SIG_DFL)
 280                         sigaction(SIGFPE, setptr, NULL);
 281
 282                 sigaction(SIGBUS, NULL, &old_action);
 283                 if (old_action.sa_handler == SIG_DFL)
 284                         sigaction(SIGBUS, setptr, NULL);
 285
 286                 old_handler = g_log_set_default_handler (bug_buddy_log_handler, NULL);
 287
 288                 /* We cannot call previous log handlers other than glib's default
 289                  * because we don't know its previous user_data and they may rely on it
 290                  * See https://bugzilla.gnome.org/show_bug.cgi?id=622068 */
 291                 if (old_handler != g_log_default_handler) {
 292                         old_handler = NULL;
 293                 }
 294         }
 295         return 0;
 296 }
 297
 298 const char *
 299 g_module_check_init (GModule *module)
 300 {
 301         g_module_make_resident (module);
 302
 303         return NULL;
 304 }
 305