pidgin3: comparison pidgin/gtkmain.c

-:6158b4151a59
+:58701e24ed40
 		}
 	}
 }
 #ifdef HAVE_SIGNAL_H
+static char *segfault_message;
+static int signal_sockets[2];
 static void sighandler(int sig);
 /*
 * This child process reaping stuff is currently only used for processes that
 * were forked to play sounds.  It's not needed for forked DNS child, which
 		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
 		perror(errmsg);
 	}
 }
-char *segfault_message;
+static void sighandler(int sig)
+{
-/*
+	ssize_t written;
-* This signal handler shouldn't be touching this much stuff.
-* It should just set a flag and return, and something else in
+	/*
-* Pidgin should monitor the flag to see if something needs to
+	 * We won't do any of the heavy lifting for the signal handling here
-* be done.  Because the signal handler interrupts the program,
+	 * because we have no idea what was interrupted.  Previously this signal
-* it could be called in the middle of adding a new connection
+	 * handler could result in some calls to malloc/free, which can cause
-* to the list of connections, and then if we try to disconnect
+	 * deadlock in libc when the signal handler was interrupting a previous
-* all connections it could lead to a crash because the linked
+	 * malloc or free.  So instead we'll do an ugly hack where we write the
-* list of connections could be in a weird state.  But, well,
+	 * signal number to one end of a socket pair.  The other half of the
-* this signal handler probably isn't called very often, so it's
+	 * socket pair is watched by our main loop.  When the main loop sees new
-* not a big deal.
+	 * data on the socket it reads in the signal and performs the appropriate
-*/
+	 * action without fear of interrupting stuff.
-static void
+	 */
-sighandler(int sig)
+	if (sig == SIGSEGV) {
-{
+		fprintf(stderr, "%s", segfault_message);
+		abort();
+		return;
+	}
+	written = write(signal_sockets[0], &sig, sizeof(int));
+	if (written < 0 || written != sizeof(int)) {
+		/* This should never happen */
+		purple_debug_error("sighandler", "Received signal %d but only "
+				"wrote %" G_GSSIZE_FORMAT " bytes out of %"
+				G_GSIZE_FORMAT ": %s\n",
+				sig, written, sizeof(int), g_strerror(errno));
+		exit(1);
+	}
+}
+static gboolean
+mainloop_sighandler(GIOChannel *source, GIOCondition cond, gpointer data)
+{
+	GIOStatus stat;
+	int sig;
+	gsize bytes_read;
+	GError *error = NULL;
+	/* read the signal number off of the io channel */
+	stat = g_io_channel_read_chars(source, (gchar *)&sig, sizeof(int),
+			&bytes_read, &error);
+	if (stat != G_IO_STATUS_NORMAL) {
+		purple_debug_error("sighandler", "Signal callback failed to read "
+				"from signal socket: %s", error->message);
+		purple_core_quit();
+		return FALSE;
+	}
 	switch (sig) {
 	case SIGHUP:
 		purple_debug_warning("sighandler", "Caught signal %d\n", sig);
-		break;
-	case SIGSEGV:
-		fprintf(stderr, "%s", segfault_message);
-		abort();
 		break;
 #if defined(USE_GSTREAMER) && !defined(GST_CAN_DISABLE_FORKING)
 /* By default, gstreamer forks when you initialize it, and waitpids for the
 * child.  But if libpurple reaps the child rather than leaving it to
 * gstreamer, gstreamer's initialization fails.  So, we wait a second before
 		break;
 	default:
 		purple_debug_warning("sighandler", "Caught signal %d\n", sig);
 		purple_core_quit();
 	}
+	return TRUE;
 }
 #endif
 static int
 ui_main(void)
 #ifdef HAVE_SIGNAL_H
 	int sig_indx;	/* for setting up signal catching */
 	sigset_t sigset;
 	RETSIGTYPE (*prev_sig_disp)(int);
 	char errmsg[BUFSIZ];
+	GIOChannel *signal_channel;
+	GIOStatus signal_status;
 #ifndef DEBUG
 	char *segfault_message_tmp;
 	GError *error = NULL;
 #endif
 #endif
 			"haven't been cheating on you!!  How many times do you want me to tell you?!  And\n"
 			"for the last time, it's just a rash!\n"
 		);
 #endif
+	/*
+	 * Create a socket pair for receiving unix signals from a signal
+	 * handler.
+	 */
+	if (socketpair(AF_UNIX, SOCK_STREAM, 0, signal_sockets) < 0) {
+		perror("Failed to create sockets for GLib signal handling");
+		exit(1);
+	}
+	signal_channel = g_io_channel_unix_new(signal_sockets[1]);
+	/*
+	 * Set the channel encoding to raw binary instead of the default of
+	 * UTF-8, because we'll be sending integers across instead of strings.
+	 */
+	error = NULL;
+	signal_status = g_io_channel_set_encoding(signal_channel, NULL, &error);
+	if (signal_status != G_IO_STATUS_NORMAL) {
+		fprintf(stderr, "Failed to set the signal channel to raw "
+				"binary: %s", error->message);
+		exit(1);
+	}
+	g_io_add_watch(signal_channel, G_IO_IN, mainloop_sighandler, NULL);
 	/* Let's not violate any PLA's!!!! */
 	/* jseymour: whatever the fsck that means */
 	/* Robot101: for some reason things like gdm like to block     *
 	 * useful signals like SIGCHLD, so we unblock all the ones we  *
 	 * declare a handler for. thanks JSeymour and Vann.            */

Mercurial > pidgin3 / file comparison

comparison: pidgin/gtkmain.c

pidgin/gtkmain.c