/********************************************************************\
  * BitlBee -- An IRC to other IM-networks gateway                     *
  *                                                                    *
  * Copyright 2002-2012 Wilmer van der Gaast and others                *
  \********************************************************************/

/* IPC - communication between BitlBee processes                        */

/*
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License with
  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
  Fifth Floor, Boston, MA  02110-1301  USA
*/

#define BITLBEE_CORE
#include "bitlbee.h"
#include "ipc.h"
#include "commands.h"
#include <sys/uio.h>
#include <sys/un.h>

GSList *child_list = NULL;
static int ipc_child_recv_fd = -1;

static void ipc_master_takeover_fail(struct bitlbee_child *child, gboolean both);
static gboolean ipc_send_fd(int fd, int send_fd);

/* On Solaris and possibly other systems passing FDs between processes is
 * not possible (or at least not using the method used in this file.
 * Just disable that code, the functionality is not that important. */
#if defined(NO_FD_PASSING) && !defined(CMSG_SPACE)
#define CMSG_SPACE(len) 1
#endif

static void ipc_master_cmd_client(irc_t *data, char **cmd)
{
	/* Normally data points at an irc_t block, but for the IPC master
	   this is different. We think this scary cast is better than
	   creating a new command_t structure, just to make the compiler
	   happy. */
	struct bitlbee_child *child = (void *) data;

	if (child && cmd[1]) {
		child->host = g_strdup(cmd[1]);
		child->nick = g_strdup(cmd[2]);
		child->realname = g_strdup(cmd[3]);
	}

	/* CLIENT == On initial connects, HELLO is after /RESTARTs. */
	if (g_strcasecmp(cmd[0], "CLIENT") == 0) {
		ipc_to_children_str("OPERMSG :Client connecting (PID=%d): %s@%s (%s)\r\n",
		                    (int) (child ? child->pid : -1), cmd[2], cmd[1], cmd[3]);
	}
}

static void ipc_master_cmd_nick(irc_t *data, char **cmd)
{
	struct bitlbee_child *child = (void *) data;

	if (child && cmd[1]) {
		g_free(child->nick);
		child->nick = g_strdup(cmd[1]);
	}
}

static void ipc_master_cmd_die(irc_t *data, char **cmd)
{
	if (global.conf->runmode == RUNMODE_FORKDAEMON) {
		ipc_to_children_str("DIE\r\n");
	}

	bitlbee_shutdown(NULL, -1, 0);
}

static void ipc_master_cmd_deaf(irc_t *data, char **cmd)
{
	if (global.conf->runmode == RUNMODE_DAEMON) {
		b_event_remove(global.listen_watch_source_id);
		close(global.listen_socket);

		global.listen_socket = global.listen_watch_source_id = -1;

		ipc_to_children_str("OPERMSG :Closed listening socket, waiting "
		                    "for all users to disconnect.");
	} else {
		ipc_to_children_str("OPERMSG :The DEAF command only works in "
		                    "normal daemon mode. Try DIE instead.");
	}
}

void ipc_master_cmd_rehash(irc_t *data, char **cmd)
{
	runmode_t oldmode;

	oldmode = global.conf->runmode;

	g_free(global.conf);
	global.conf = conf_load(0, NULL);

	if (global.conf->runmode != oldmode) {
		log_message(LOGLVL_WARNING, "Can't change RunMode setting at runtime, restoring original setting");
		global.conf->runmode = oldmode;
	}

	if (global.conf->runmode == RUNMODE_FORKDAEMON) {
		ipc_to_children(cmd);
	}
}

void ipc_master_cmd_restart(irc_t *data, char **cmd)
{
	if (global.conf->runmode != RUNMODE_FORKDAEMON) {
		/* Tell child that this is unsupported. */
		return;
	}

	global.restart = -1;
	bitlbee_shutdown(NULL, -1, 0);
}

void ipc_master_cmd_identify(irc_t *data, char **cmd)
{
	struct bitlbee_child *child = (void *) data, *old = NULL;
	char *resp;
	GSList *l;

	if (!child || !child->nick || strcmp(child->nick, cmd[1]) != 0) {
		return;
	}

	g_free(child->password);
	child->password = g_strdup(cmd[2]);

	for (l = child_list; l; l = l->next) {
		old = l->data;
		if (child != old &&
		    old->nick && nick_cmp(NULL, old->nick, child->nick) == 0 &&
		    old->password && strcmp(old->password, child->password) == 0) {
			break;
		}
	}

	if (l && !child->to_child && !old->to_child) {
		resp = "TAKEOVER INIT\r\n";
		child->to_child = old;
		old->to_child = child;
	} else {
		/* Won't need the fd since we can't send it anywhere. */
		closesocket(child->to_fd);
		child->to_fd = -1;
		resp = "TAKEOVER NO\r\n";
	}

	if (write(child->ipc_fd, resp, strlen(resp)) != strlen(resp)) {
		ipc_master_free_one(child);
	}
}


void ipc_master_cmd_takeover(irc_t *data, char **cmd)
{
	struct bitlbee_child *child = (void *) data;
	char *fwd = NULL;

	/* Normal daemon mode doesn't keep these and has simplified code for
	   takeovers. */
	if (child == NULL) {
		return;
	}

	if (child->to_child == NULL ||
	    g_slist_find(child_list, child->to_child) == NULL) {
		return ipc_master_takeover_fail(child, FALSE);
	}

	if (strcmp(cmd[1], "AUTH") == 0) {
		/* New connection -> Master */
		if (child->to_child &&
		    child->nick && child->to_child->nick && cmd[2] &&
		    child->password && child->to_child->password && cmd[3] &&
		    strcmp(child->nick, child->to_child->nick) == 0 &&
		    strcmp(child->nick, cmd[2]) == 0 &&
		    strcmp(child->password, child->to_child->password) == 0 &&
		    strcmp(child->password, cmd[3]) == 0) {
			ipc_send_fd(child->to_child->ipc_fd, child->to_fd);

			fwd = irc_build_line(cmd);
			if (write(child->to_child->ipc_fd, fwd, strlen(fwd)) != strlen(fwd)) {
				ipc_master_free_one(child);
			}
			g_free(fwd);
		} else {
			return ipc_master_takeover_fail(child, TRUE);
		}
	} else if (strcmp(cmd[1], "DONE") == 0 || strcmp(cmd[1], "FAIL") == 0) {
		/* Old connection -> Master */
		int fd;

		/* The copy was successful (or not), we don't need it anymore. */
		closesocket(child->to_fd);
		child->to_fd = -1;

		/* Pass it through to the other party, and flush all state. */
		fwd = irc_build_line(cmd);
		fd = child->to_child->ipc_fd;
		child->to_child->to_child = NULL;
		child->to_child = NULL;
		if (write(fd, fwd, strlen(fwd)) != strlen(fwd)) {
			ipc_master_free_one(child);
		}
		g_free(fwd);
	}
}

static const command_t ipc_master_commands[] = {
	{ "client",     3, ipc_master_cmd_client,     0 },
	{ "hello",      0, ipc_master_cmd_client,     0 },
	{ "nick",       1, ipc_master_cmd_nick,       0 },
	{ "die",        0, ipc_master_cmd_die,        0 },
	{ "deaf",       0, ipc_master_cmd_deaf,       0 },
	{ "wallops",    1, NULL,                      IPC_CMD_TO_CHILDREN },
	{ "wall",       1, NULL,                      IPC_CMD_TO_CHILDREN },
	{ "opermsg",    1, NULL,                      IPC_CMD_TO_CHILDREN },
	{ "rehash",     0, ipc_master_cmd_rehash,     0 },
	{ "kill",       2, NULL,                      IPC_CMD_TO_CHILDREN },
	{ "restart",    0, ipc_master_cmd_restart,    0 },
	{ "identify",   2, ipc_master_cmd_identify,   0 },
	{ "takeover",   1, ipc_master_cmd_takeover,   0 },
	{ NULL }
};


static void ipc_child_cmd_die(irc_t *irc, char **cmd)
{
	irc_abort(irc, 0, "Shutdown requested by operator");
}

static void ipc_child_cmd_wallops(irc_t *irc, char **cmd)
{
	if (!(irc->status & USTATUS_LOGGED_IN)) {
		return;
	}

	if (strchr(irc->umode, 'w')) {
		irc_write(irc, ":%s WALLOPS :%s", irc->root->host, cmd[1]);
	}
}

static void ipc_child_cmd_wall(irc_t *irc, char **cmd)
{
	if (!(irc->status & USTATUS_LOGGED_IN)) {
		return;
	}

	if (strchr(irc->umode, 's')) {
		irc_write(irc, ":%s NOTICE %s :%s", irc->root->host, irc->user->nick, cmd[1]);
	}
}

static void ipc_child_cmd_opermsg(irc_t *irc, char **cmd)
{
	if (!(irc->status & USTATUS_LOGGED_IN)) {
		return;
	}

	if (strchr(irc->umode, 'o')) {
		irc_write(irc, ":%s NOTICE %s :*** OperMsg *** %s", irc->root->host, irc->user->nick, cmd[1]);
	}
}

static void ipc_child_cmd_rehash(irc_t *irc, char **cmd)
{
	runmode_t oldmode;

	oldmode = global.conf->runmode;

	g_free(global.conf);
	global.conf = conf_load(0, NULL);

	global.conf->runmode = oldmode;
}

static void ipc_child_cmd_kill(irc_t *irc, char **cmd)
{
	if (!(irc->status & USTATUS_LOGGED_IN)) {
		return;
	}

	if (nick_cmp(NULL, cmd[1], irc->user->nick) != 0) {
		return;         /* It's not for us. */

	}
	irc_write(irc, ":%s!%s@%s KILL %s :%s", irc->root->nick, irc->root->nick, irc->root->host, irc->user->nick,
	          cmd[2]);
	irc_abort(irc, 0, "Killed by operator: %s", cmd[2]);
}

static void ipc_child_cmd_hello(irc_t *irc, char **cmd)
{
	if (!(irc->status & USTATUS_LOGGED_IN)) {
		ipc_to_master_str("HELLO\r\n");
	} else {
		ipc_to_master_str("HELLO %s %s :%s\r\n", irc->user->host, irc->user->nick, irc->user->fullname);
	}
}

static void ipc_child_cmd_takeover_yes(void *data);
static void ipc_child_cmd_takeover_no(void *data);

static void ipc_child_cmd_takeover(irc_t *irc, char **cmd)
{
	if (strcmp(cmd[1], "NO") == 0) {
		/* Master->New connection */
		/* No takeover, finish the login. */
	} else if (strcmp(cmd[1], "INIT") == 0) {
		/* Master->New connection */
		if (!set_getbool(&irc->b->set, "allow_takeover")) {
			ipc_child_cmd_takeover_no(irc);
			return;
		}

		/* Offer to take over the old session, unless for some reason
		   we're already logging into IM connections. */
		if (irc->login_source_id != -1) {
			query_add(irc, NULL,
			          "You're already connected to this server. "
			          "Would you like to take over this session?",
			          ipc_child_cmd_takeover_yes,
			          ipc_child_cmd_takeover_no, NULL, irc);
		}

		/* This one's going to connect to accounts, avoid that. */
		b_event_remove(irc->login_source_id);
		irc->login_source_id = -1;
	} else if (strcmp(cmd[1], "AUTH") == 0) {
		/* Master->Old connection */
		if (irc->password && cmd[2] && cmd[3] &&
		    ipc_child_recv_fd != -1 &&
		    strcmp(irc->user->nick, cmd[2]) == 0 &&
		    strcmp(irc->password, cmd[3]) == 0 &&
		    set_getbool(&irc->b->set, "allow_takeover")) {
			irc_switch_fd(irc, ipc_child_recv_fd);
			irc_sync(irc);
			irc_rootmsg(irc, "You've successfully taken over your old session");
			ipc_child_recv_fd = -1;

			ipc_to_master_str("TAKEOVER DONE\r\n");
		} else {
			ipc_to_master_str("TAKEOVER FAIL\r\n");
		}
	} else if (strcmp(cmd[1], "DONE") == 0) {
		/* Master->New connection (now taken over by old process) */
		irc_free(irc);
	} else if (strcmp(cmd[1], "FAIL") == 0) {
		/* Master->New connection */
		irc_rootmsg(irc, "Could not take over old session");
	}
}

static void ipc_child_cmd_takeover_yes(void *data)
{
	irc_t *irc = data, *old = NULL;
	char *to_auth[] = { "TAKEOVER", "AUTH", irc->user->nick, irc->password, NULL };

	/* Master->New connection */
	ipc_to_master_str("TAKEOVER AUTH %s :%s\r\n",
	                  irc->user->nick, irc->password);

	if (global.conf->runmode == RUNMODE_DAEMON) {
		GSList *l;

		for (l = irc_connection_list; l; l = l->next) {
			old = l->data;

			if (irc != old &&
			    irc->user->nick && old->user->nick &&
			    irc->password && old->password &&
			    strcmp(irc->user->nick, old->user->nick) == 0 &&
			    strcmp(irc->password, old->password) == 0) {
				break;
			}
		}
		if (l == NULL) {
			to_auth[1] = "FAIL";
			ipc_child_cmd_takeover(irc, to_auth);
			return;
		}
	}

	/* Drop credentials, we'll shut down soon and shouldn't overwrite
	   any settings. */
	irc_rootmsg(irc, "Trying to take over existing session");

	irc_desync(irc);

	if (old) {
		ipc_child_recv_fd = dup(irc->fd);
		ipc_child_cmd_takeover(old, to_auth);
	}

	/* TODO: irc_setpass() should do all of this. */
	irc_setpass(irc, NULL);
	irc->status &= ~USTATUS_IDENTIFIED;
	irc_umode_set(irc, "-R", 1);

	if (old) {
		irc_abort(irc, FALSE, NULL);
	}
}

static void ipc_child_cmd_takeover_no(void *data)
{
	ipc_to_master_str("TAKEOVER NO\r\n");
	cmd_identify_finish(data, 0, 0);
}

static const command_t ipc_child_commands[] = {
	{ "die",        0, ipc_child_cmd_die,         0 },
	{ "wallops",    1, ipc_child_cmd_wallops,     0 },
	{ "wall",       1, ipc_child_cmd_wall,        0 },
	{ "opermsg",    1, ipc_child_cmd_opermsg,     0 },
	{ "rehash",     0, ipc_child_cmd_rehash,      0 },
	{ "kill",       2, ipc_child_cmd_kill,        0 },
	{ "hello",      0, ipc_child_cmd_hello,       0 },
	{ "takeover",   1, ipc_child_cmd_takeover,    0 },
	{ NULL }
};

gboolean ipc_child_identify(irc_t *irc)
{
	if (global.conf->runmode == RUNMODE_FORKDAEMON) {
#ifndef NO_FD_PASSING
		if (!ipc_send_fd(global.listen_socket, irc->fd)) {
			ipc_child_disable();
		}

		ipc_to_master_str("IDENTIFY %s :%s\r\n", irc->user->nick, irc->password);
#endif

		return TRUE;
	} else if (global.conf->runmode == RUNMODE_DAEMON) {
		GSList *l;
		irc_t *old = NULL;
		char *to_init[] = { "TAKEOVER", "INIT", NULL };

		for (l = irc_connection_list; l; l = l->next) {
			old = l->data;

			if (irc != old &&
			    irc->user->nick && old->user->nick &&
			    irc->password && old->password &&
			    strcmp(irc->user->nick, old->user->nick) == 0 &&
			    strcmp(irc->password, old->password) == 0) {
				break;
			}
		}
		if (l == NULL || old == NULL ||
		    !set_getbool(&irc->b->set, "allow_takeover") ||
		    !set_getbool(&old->b->set, "allow_takeover")) {
			return FALSE;
		}

		ipc_child_cmd_takeover(irc, to_init);

		return TRUE;
	} else {
		return FALSE;
	}
}

static void ipc_master_takeover_fail(struct bitlbee_child *child, gboolean both)
{
	if (child == NULL || g_slist_find(child_list, child) == NULL) {
		return;
	}

	if (both && child->to_child != NULL) {
		ipc_master_takeover_fail(child->to_child, FALSE);
	}

	if (child->to_fd > -1) {
		/* Send this error only to the new connection, which can be
		   recognised by to_fd being set. */
		if (write(child->ipc_fd, "TAKEOVER FAIL\r\n", 15) != 15) {
			ipc_master_free_one(child);
			return;
		}
		close(child->to_fd);
		child->to_fd = -1;
	}
	child->to_child = NULL;
}

static void ipc_command_exec(void *data, char **cmd, const command_t *commands)
{
	int i, j;

	if (!cmd[0]) {
		return;
	}

	for (i = 0; commands[i].command; i++) {
		if (g_strcasecmp(commands[i].command, cmd[0]) == 0) {
			/* There is no typo in this line: */
			for (j = 1; cmd[j]; j++) {
				;
			}
			j--;

			if (j < commands[i].required_parameters) {
				break;
			}

			if (commands[i].flags & IPC_CMD_TO_CHILDREN) {
				ipc_to_children(cmd);
			} else {
				commands[i].execute(data, cmd);
			}

			break;
		}
	}
}

/* Return just one line. Returns NULL if something broke, an empty string
   on temporary "errors" (EAGAIN and friends). */
static char *ipc_readline(int fd, int *recv_fd)
{
	struct msghdr msg;
	struct iovec iov;
	char ccmsg[CMSG_SPACE(sizeof(recv_fd))];
	struct cmsghdr *cmsg;
	char buf[513], *eol;
	int size;

	/* Because this is internal communication, it should be pretty safe
	   to just peek at the message, find its length (by searching for the
	   end-of-line) and then just read that message. With internal
	   sockets and limites message length, messages should always be
	   complete. Saves us quite a lot of code and buffering. */
	size = recv(fd, buf, sizeof(buf) - 1, MSG_PEEK);
	if (size == 0 || (size < 0 && !sockerr_again())) {
		return NULL;
	} else if (size < 0) { /* && sockerr_again() */
		return(g_strdup(""));
	} else {
		buf[size] = 0;
	}

	if ((eol = strstr(buf, "\r\n")) == NULL) {
		return NULL;
	} else {
		size = eol - buf + 2;
	}

	iov.iov_base = buf;
	iov.iov_len = size;

	memset(&msg, 0, sizeof(msg));
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;
#ifndef NO_FD_PASSING
	msg.msg_control = ccmsg;
	msg.msg_controllen = sizeof(ccmsg);
#endif

	if (recvmsg(fd, &msg, 0) != size) {
		return NULL;
	}

#ifndef NO_FD_PASSING
	if (recv_fd) {
		for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
			if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
				/* Getting more than one shouldn't happen but if it does,
				   make sure we don't leave them around. */
				if (*recv_fd != -1) {
					close(*recv_fd);
				}

				*recv_fd = *(int *) CMSG_DATA(cmsg);
				/*
				fprintf( stderr, "pid %d received fd %d\n", (int) getpid(), *recv_fd );
				*/
			}
		}
	}
#endif

	/*
	fprintf( stderr, "pid %d received: %s", (int) getpid(), buf );
	*/
	return g_strndup(buf, size - 2);
}

gboolean ipc_master_read(gpointer data, gint source, b_input_condition cond)
{
	struct bitlbee_child *child = data;
	char *buf, **cmd;

	if ((buf = ipc_readline(source, &child->to_fd))) {
		cmd = irc_parse_line(buf);
		if (cmd) {
			ipc_command_exec(child, cmd, ipc_master_commands);
			g_free(cmd);
		}
		g_free(buf);
	} else {
		ipc_master_free_fd(source);
	}

	return TRUE;
}

gboolean ipc_child_read(gpointer data, gint source, b_input_condition cond)
{
	char *buf, **cmd;

	if ((buf = ipc_readline(source, &ipc_child_recv_fd))) {
		cmd = irc_parse_line(buf);
		if (cmd) {
			ipc_command_exec(data, cmd, ipc_child_commands);
			g_free(cmd);
		}
		g_free(buf);
	} else {
		ipc_child_disable();
	}

	return TRUE;
}

void ipc_to_master(char **cmd)
{
	if (global.conf->runmode == RUNMODE_FORKDAEMON) {
		char *s = irc_build_line(cmd);
		ipc_to_master_str("%s", s);
		g_free(s);
	} else if (global.conf->runmode == RUNMODE_DAEMON) {
		ipc_command_exec(NULL, cmd, ipc_master_commands);
	}
}

void ipc_to_master_str(char *format, ...)
{
	char *msg_buf;
	va_list params;

	va_start(params, format);
	msg_buf = g_strdup_vprintf(format, params);
	va_end(params);

	if (strlen(msg_buf) > 512) {
		/* Don't send it, it's too long... */
	} else if (global.conf->runmode == RUNMODE_FORKDAEMON) {
		if (global.listen_socket >= 0) {
			if (write(global.listen_socket, msg_buf, strlen(msg_buf)) <= 0) {
				ipc_child_disable();
			}
		}
	} else if (global.conf->runmode == RUNMODE_DAEMON) {
		char **cmd, *s;

		if ((s = strchr(msg_buf, '\r'))) {
			*s = 0;
		}

		cmd = irc_parse_line(msg_buf);
		ipc_command_exec(NULL, cmd, ipc_master_commands);
		g_free(cmd);
	}

	g_free(msg_buf);
}

void ipc_to_children(char **cmd)
{
	if (global.conf->runmode == RUNMODE_FORKDAEMON) {
		char *msg_buf = irc_build_line(cmd);
		ipc_to_children_str("%s", msg_buf);
		g_free(msg_buf);
	} else if (global.conf->runmode == RUNMODE_DAEMON) {
		GSList *l;

		for (l = irc_connection_list; l; l = l->next) {
			ipc_command_exec(l->data, cmd, ipc_child_commands);
		}
	}
}

void ipc_to_children_str(char *format, ...)
{
	char *msg_buf;
	va_list params;

	va_start(params, format);
	msg_buf = g_strdup_vprintf(format, params);
	va_end(params);

	if (strlen(msg_buf) > 512) {
		/* Don't send it, it's too long... */
	} else if (global.conf->runmode == RUNMODE_FORKDAEMON) {
		int msg_len = strlen(msg_buf);
		GSList *l, *next;

		for (l = child_list; l; l = next) {
			struct bitlbee_child *c = l->data;

			next = l->next;
			if (write(c->ipc_fd, msg_buf, msg_len) <= 0) {
				ipc_master_free_one(c);
			}
		}
	} else if (global.conf->runmode == RUNMODE_DAEMON) {
		char **cmd, *s;

		if ((s = strchr(msg_buf, '\r'))) {
			*s = 0;
		}

		cmd = irc_parse_line(msg_buf);
		ipc_to_children(cmd);
		g_free(cmd);
	}

	g_free(msg_buf);
}

static gboolean ipc_send_fd(int fd, int send_fd)
{
	struct msghdr msg;
	struct iovec iov;
	char ccmsg[CMSG_SPACE(sizeof(fd))];
	struct cmsghdr *cmsg;

	memset(&msg, 0, sizeof(msg));
	iov.iov_base = "0x90\r\n";         /* Ja, noppes */
	iov.iov_len = 6;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;

#ifndef NO_FD_PASSING
	msg.msg_control = ccmsg;
	msg.msg_controllen = sizeof(ccmsg);
	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;
	cmsg->cmsg_len = CMSG_LEN(sizeof(send_fd));
	*(int *) CMSG_DATA(cmsg) = send_fd;
	msg.msg_controllen = cmsg->cmsg_len;
#endif

	return sendmsg(fd, &msg, 0) == 6;
}

void ipc_master_free_one(struct bitlbee_child *c)
{
	GSList *l;

	b_event_remove(c->ipc_inpa);
	closesocket(c->ipc_fd);

	if (c->to_fd != -1) {
		close(c->to_fd);
	}

	g_free(c->host);
	g_free(c->nick);
	g_free(c->realname);
	g_free(c->password);
	g_free(c);

	child_list = g_slist_remove(child_list, c);

	/* Also, if any child has a reference to this one, remove it. */
	for (l = child_list; l; l = l->next) {
		struct bitlbee_child *oc = l->data;

		if (oc->to_child == c) {
			ipc_master_takeover_fail(oc, FALSE);
		}
	}
}

void ipc_master_free_fd(int fd)
{
	GSList *l;
	struct bitlbee_child *c;

	for (l = child_list; l; l = l->next) {
		c = l->data;
		if (c->ipc_fd == fd) {
			ipc_master_free_one(c);
			break;
		}
	}
}

void ipc_master_free_all()
{
	while (child_list) {
		ipc_master_free_one(child_list->data);
	}
}

void ipc_child_disable()
{
	b_event_remove(global.listen_watch_source_id);
	close(global.listen_socket);

	global.listen_socket = -1;
}

char *ipc_master_save_state()
{
	char *fn = g_strdup("/tmp/bee-restart.XXXXXX");
	int fd = mkstemp(fn);
	GSList *l;
	FILE *fp;
	int i;

	if (fd == -1) {
		log_message(LOGLVL_ERROR, "Could not create temporary file: %s", strerror(errno));
		g_free(fn);
		return NULL;
	}

	/* This is more convenient now. */
	fp = fdopen(fd, "w");

	for (l = child_list, i = 0; l; l = l->next) {
		i++;
	}

	/* Number of client processes. */
	fprintf(fp, "%d\n", i);

	for (l = child_list; l; l = l->next) {
		fprintf(fp, "%d %d\n", (int) ((struct bitlbee_child*) l->data)->pid,
		        ((struct bitlbee_child*) l->data)->ipc_fd);
	}

	if (fclose(fp) == 0) {
		return fn;
	} else {
		unlink(fn);
		g_free(fn);
		return NULL;
	}
}


static gboolean new_ipc_client(gpointer data, gint serversock, b_input_condition cond)
{
	struct bitlbee_child *child = g_new0(struct bitlbee_child, 1);

	child->to_fd = -1;
	child->ipc_fd = accept(serversock, NULL, 0);
	if (child->ipc_fd == -1) {
		log_message(LOGLVL_WARNING, "Unable to accept connection on UNIX domain socket: %s", strerror(errno));
		return TRUE;
	}

	child->ipc_inpa = b_input_add(child->ipc_fd, B_EV_IO_READ, ipc_master_read, child);

	child_list = g_slist_prepend(child_list, child);

	return TRUE;
}

int ipc_master_listen_socket()
{
	struct sockaddr_un un_addr;
	int serversock;

	if (!IPCSOCKET || !*IPCSOCKET) {
		return 1;
	}

	/* Clean up old socket files that were hanging around.. */
	if (unlink(IPCSOCKET) == -1 && errno != ENOENT) {
		log_message(LOGLVL_ERROR, "Could not remove old IPC socket at %s: %s", IPCSOCKET, strerror(errno));
		return 0;
	}

	un_addr.sun_family = AF_UNIX;
	strcpy(un_addr.sun_path, IPCSOCKET);

	serversock = socket(AF_UNIX, SOCK_STREAM, PF_UNIX);

	if (serversock == -1) {
		log_message(LOGLVL_WARNING, "Unable to create UNIX socket: %s", strerror(errno));
		return 0;
	}

	if (bind(serversock, (struct sockaddr *) &un_addr, sizeof(un_addr)) == -1) {
		log_message(LOGLVL_WARNING, "Unable to bind UNIX socket to %s: %s", IPCSOCKET, strerror(errno));
		return 0;
	}

	if (listen(serversock, 5) == -1) {
		log_message(LOGLVL_WARNING, "Unable to listen on UNIX socket: %s", strerror(errno));
		return 0;
	}

	b_input_add(serversock, B_EV_IO_READ, new_ipc_client, NULL);

	return 1;
}

int ipc_master_load_state(char *statefile)
{
	struct bitlbee_child *child;
	FILE *fp;
	int i, n;

	if (statefile == NULL) {
		return 0;
	}

	fp = fopen(statefile, "r");
	unlink(statefile);      /* Why do it later? :-) */
	if (fp == NULL) {
		return 0;
	}

	if (fscanf(fp, "%d", &n) != 1) {
		log_message(LOGLVL_WARNING, "Could not import state information for child processes.");
		fclose(fp);
		return 0;
	}

	log_message(LOGLVL_INFO, "Importing information for %d child processes.", n);
	for (i = 0; i < n; i++) {
		child = g_new0(struct bitlbee_child, 1);

		if (fscanf(fp, "%d %d", (int *) &child->pid, &child->ipc_fd) != 2) {
			log_message(LOGLVL_WARNING, "Unexpected end of file: Only processed %d clients.", i);
			g_free(child);
			fclose(fp);
			return 0;
		}
		child->ipc_inpa = b_input_add(child->ipc_fd, B_EV_IO_READ, ipc_master_read, child);
		child->to_fd = -1;

		child_list = g_slist_prepend(child_list, child);
	}

	ipc_to_children_str("HELLO\r\n");
	ipc_to_children_str("OPERMSG :New %s master process started (version %s)\r\n", PACKAGE, BITLBEE_VERSION);

	fclose(fp);
	return 1;
}