[irc/rqf/shadowircd.git] / libratbox / src / helper.c

/*
 *  ircd-ratbox: A slightly useful ircd
 *  helper.c: Starts and deals with ircd helpers
 *  
 *  Copyright (C) 2006 Aaron Sethman <androsyn@ratbox.org>
 *
 *  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
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 *  USA
 *
 *  $Id: helper.c 26092 2008-09-19 15:13:52Z androsyn $
 */
#include <libratbox_config.h>
#include <ratbox_lib.h>
#include <commio-int.h>

struct _rb_helper
{
	char *path;
	buf_head_t sendq;
	buf_head_t recvq;
	rb_fde_t *ifd;
	rb_fde_t *ofd;
	pid_t pid;
	int fork_count;
	rb_helper_cb *read_cb;
	rb_helper_cb *error_cb;
};


/* setup all the stuff a new child needs */
rb_helper *
rb_helper_child(rb_helper_cb * read_cb, rb_helper_cb * error_cb, log_cb * ilog,
		restart_cb * irestart, die_cb * idie, int maxcon, size_t lb_heap_size,
		size_t dh_size, size_t fd_heap_size)
{
	rb_helper *helper;
	int maxfd, x = 0;
	int ifd, ofd;
	char *tifd, *tofd, *tmaxfd;

	tifd = getenv("IFD");
	tofd = getenv("OFD");
	tmaxfd = getenv("MAXFD");

	if(tifd == NULL || tofd == NULL || tmaxfd == NULL)
		return NULL;

	helper = rb_malloc(sizeof(rb_helper));
	ifd = (int)strtol(tifd, NULL, 10);
	ofd = (int)strtol(tofd, NULL, 10);
	maxfd = (int)strtol(tmaxfd, NULL, 10);

#ifndef _WIN32
	for(x = 0; x < maxfd; x++)
	{
		if(x != ifd && x != ofd)
			close(x);
	}
	x = open("/dev/null", O_RDWR);
	if(ifd != 0 && ofd != 0)
		dup2(x, 0);
	if(ifd != 1 && ofd != 1)
		dup2(x, 1);
	if(ifd != 2 && ofd != 2)
		dup2(x, 2);
	if(x > 2)		/* don't undo what we just did */
		close(x);
#else
	x = 0;			/* shut gcc up */
#endif

	rb_lib_init(ilog, irestart, idie, 0, maxfd, dh_size, fd_heap_size);
	rb_linebuf_init(lb_heap_size);
	rb_linebuf_newbuf(&helper->sendq);
	rb_linebuf_newbuf(&helper->recvq);

	helper->ifd = rb_open(ifd, RB_FD_PIPE, "incoming connection");
	helper->ofd = rb_open(ofd, RB_FD_PIPE, "outgoing connection");
	rb_set_nb(helper->ifd);
	rb_set_nb(helper->ofd);

	helper->read_cb = read_cb;
	helper->error_cb = error_cb;
	return helper;
}

/*
 * start_fork_helper
 * starts a new ircd helper
 * note that this function doesn't start doing reading..thats the job of the caller
 */

rb_helper *
rb_helper_start(const char *name, const char *fullpath, rb_helper_cb * read_cb,
		rb_helper_cb * error_cb)
{
	rb_helper *helper;
	const char *parv[2];
	char buf[128];
	char fx[16], fy[16];
	rb_fde_t *in_f[2];
	rb_fde_t *out_f[2];
	pid_t pid;

	if(access(fullpath, X_OK) == -1)
		return NULL;

	helper = rb_malloc(sizeof(rb_helper));

	rb_snprintf(buf, sizeof(buf), "%s helper - read", name);
	if(rb_pipe(&in_f[0], &in_f[1], buf) < 0)
	{
		rb_free(helper);
		return NULL;
	}
	rb_snprintf(buf, sizeof(buf), "%s helper - write", name);
	if(rb_pipe(&out_f[0], &out_f[1], buf) < 0)
	{
		rb_free(helper);
		return NULL;
	}

	rb_snprintf(fx, sizeof(fx), "%d", rb_get_fd(in_f[1]));
	rb_snprintf(fy, sizeof(fy), "%d", rb_get_fd(out_f[0]));

	rb_set_nb(in_f[0]);
	rb_set_nb(in_f[1]);
	rb_set_nb(out_f[0]);
	rb_set_nb(out_f[1]);

	rb_setenv("IFD", fy, 1);
	rb_setenv("OFD", fx, 1);
	rb_setenv("MAXFD", "256", 1);

	rb_snprintf(buf, sizeof(buf), "-ircd %s daemon", name);
	parv[0] = buf;
	parv[1] = NULL;

#ifdef _WIN32
	SetHandleInformation((HANDLE) rb_get_fd(in_f[1]), HANDLE_FLAG_INHERIT, 1);
	SetHandleInformation((HANDLE) rb_get_fd(out_f[0]), HANDLE_FLAG_INHERIT, 1);
#endif

	pid = rb_spawn_process(fullpath, (const char **)parv);

	if(pid == -1)
	{
		rb_close(in_f[0]);
		rb_close(in_f[1]);
		rb_close(out_f[0]);
		rb_close(out_f[1]);
		rb_free(helper);
		return NULL;
	}

	rb_close(in_f[1]);
	rb_close(out_f[0]);

	rb_linebuf_newbuf(&helper->sendq);
	rb_linebuf_newbuf(&helper->recvq);

	helper->ifd = in_f[0];
	helper->ofd = out_f[1];
	helper->read_cb = read_cb;
	helper->error_cb = error_cb;
	helper->fork_count = 0;
	helper->pid = pid;

	return helper;
}


void
rb_helper_restart(rb_helper *helper)
{
	helper->error_cb(helper);
}


static void
rb_helper_write_sendq(rb_fde_t *F, void *helper_ptr)
{
	rb_helper *helper = helper_ptr;
	int retlen;

	if(rb_linebuf_len(&helper->sendq) > 0)
	{
		while((retlen = rb_linebuf_flush(F, &helper->sendq)) > 0)
			;;
		if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
		{
			rb_helper_restart(helper);
			return;
		}
	}

	if(rb_linebuf_len(&helper->sendq) > 0)
		rb_setselect(helper->ofd, RB_SELECT_WRITE, rb_helper_write_sendq, helper);
}

void
rb_helper_write_queue(rb_helper *helper, const char *format, ...)
{
	va_list ap;
	va_start(ap, format);
	rb_linebuf_putmsg(&helper->sendq, format, &ap, NULL);
	va_end(ap);
}

void
rb_helper_write_flush(rb_helper *helper)
{
	rb_helper_write_sendq(helper->ofd, helper);
}


void
rb_helper_write(rb_helper *helper, const char *format, ...)
{
	va_list ap;
	va_start(ap, format);
	rb_linebuf_putmsg(&helper->sendq, format, &ap, NULL);
	va_end(ap);
	rb_helper_write_flush(helper);
}

static void
rb_helper_read_cb(rb_fde_t *F, void *data)
{
	rb_helper *helper = (rb_helper *)data;
	static char buf[32768];
	int length;
	if(helper == NULL)
		return;

	while((length = rb_read(helper->ifd, buf, sizeof(buf))) > 0)
	{
		rb_linebuf_parse(&helper->recvq, buf, length, 0);
		helper->read_cb(helper);
	}

	if(length == 0 || (length < 0 && !rb_ignore_errno(errno)))
	{
		rb_helper_restart(helper);
		return;
	}

	rb_setselect(helper->ifd, RB_SELECT_READ, rb_helper_read_cb, helper);
}

void
rb_helper_run(rb_helper *helper)
{
	if(helper == NULL)
		return;
	rb_helper_read_cb(helper->ifd, helper);
}


void
rb_helper_close(rb_helper *helper)
{
	if(helper == NULL)
		return;
	rb_kill(helper->pid, SIGKILL);
	rb_close(helper->ifd);
	rb_close(helper->ofd);
	rb_free(helper);
}

int
rb_helper_read(rb_helper *helper, void *buf, size_t bufsize)
{
	return rb_linebuf_get(&helper->recvq, buf, bufsize, LINEBUF_COMPLETE, LINEBUF_PARSED);
}

void
rb_helper_loop(rb_helper *helper, long delay)
{
	rb_helper_run(helper);
	while(1)
	{
		rb_lib_loop(delay);
	}
}
Commit	Line	Data
b57f37fb WP	1	/*
	2	* ircd-ratbox: A slightly useful ircd
	3	* helper.c: Starts and deals with ircd helpers
	4	*
	5	* Copyright (C) 2006 Aaron Sethman <androsyn@ratbox.org>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
	20	* USA
	21	*
94b4fbf9	22	* $Id: helper.c 26092 2008-09-19 15:13:52Z androsyn $
b57f37fb WP	23	*/
	24	#include <libratbox_config.h>
	25	#include <ratbox_lib.h>
	26	#include <commio-int.h>
	27
	28	struct _rb_helper
	29	{
	30	char *path;
	31	buf_head_t sendq;
	32	buf_head_t recvq;
	33	rb_fde_t *ifd;
	34	rb_fde_t *ofd;
	35	pid_t pid;
	36	int fork_count;
	37	rb_helper_cb *read_cb;
	38	rb_helper_cb *error_cb;
	39	};
	40
	41
	42	/* setup all the stuff a new child needs */
	43	rb_helper *
94b4fbf9 VY	44	rb_helper_child(rb_helper_cb * read_cb, rb_helper_cb * error_cb, log_cb * ilog,
	45	restart_cb * irestart, die_cb * idie, int maxcon, size_t lb_heap_size,
	46	size_t dh_size, size_t fd_heap_size)
b57f37fb WP	47	{
	48	rb_helper *helper;
	49	int maxfd, x = 0;
	50	int ifd, ofd;
	51	char tifd, tofd, *tmaxfd;
94b4fbf9	52
b57f37fb WP	53	tifd = getenv("IFD");
	54	tofd = getenv("OFD");
	55	tmaxfd = getenv("MAXFD");
94b4fbf9	56
b57f37fb WP	57	if(tifd == NULL \|\| tofd == NULL \|\| tmaxfd == NULL)
	58	return NULL;
	59
	60	helper = rb_malloc(sizeof(rb_helper));
94b4fbf9	61	ifd = (int)strtol(tifd, NULL, 10);
b57f37fb WP	62	ofd = (int)strtol(tofd, NULL, 10);
	63	maxfd = (int)strtol(tmaxfd, NULL, 10);
	64
94b4fbf9 VY	65	#ifndef _WIN32
	66	for(x = 0; x < maxfd; x++)
	67	{
	68	if(x != ifd && x != ofd)
	69	close(x);
b57f37fb WP	70	}
	71	x = open("/dev/null", O_RDWR);
	72	if(ifd != 0 && ofd != 0)
	73	dup2(x, 0);
	74	if(ifd != 1 && ofd != 1)
	75	dup2(x, 1);
	76	if(ifd != 2 && ofd != 2)
	77	dup2(x, 2);
94b4fbf9	78	if(x > 2) /* don't undo what we just did */
b57f37fb WP	79	close(x);
b57f37fb WP	80	#else
94b4fbf9	81	x = 0; /* shut gcc up */
b57f37fb WP	82	#endif
	83
	84	rb_lib_init(ilog, irestart, idie, 0, maxfd, dh_size, fd_heap_size);
	85	rb_linebuf_init(lb_heap_size);
	86	rb_linebuf_newbuf(&helper->sendq);
	87	rb_linebuf_newbuf(&helper->recvq);
	88
	89	helper->ifd = rb_open(ifd, RB_FD_PIPE, "incoming connection");
	90	helper->ofd = rb_open(ofd, RB_FD_PIPE, "outgoing connection");
	91	rb_set_nb(helper->ifd);
	92	rb_set_nb(helper->ofd);
94b4fbf9	93
b57f37fb WP	94	helper->read_cb = read_cb;
	95	helper->error_cb = error_cb;
	96	return helper;
	97	}
	98
	99	/*
	100	* start_fork_helper
	101	* starts a new ircd helper
	102	* note that this function doesn't start doing reading..thats the job of the caller
	103	*/
	104
	105	rb_helper *
94b4fbf9 VY	106	rb_helper_start(const char name, const char fullpath, rb_helper_cb * read_cb,
94b4fbf9 VY	107	rb_helper_cb * error_cb)
b57f37fb WP	108	{
	109	rb_helper *helper;
	110	const char *parv[2];
	111	char buf[128];
	112	char fx[16], fy[16];
	113	rb_fde_t *in_f[2];
	114	rb_fde_t *out_f[2];
	115	pid_t pid;
94b4fbf9	116
b57f37fb WP	117	if(access(fullpath, X_OK) == -1)
b57f37fb WP	118	return NULL;
94b4fbf9	119
b57f37fb WP	120	helper = rb_malloc(sizeof(rb_helper));
	121
	122	rb_snprintf(buf, sizeof(buf), "%s helper - read", name);
94b4fbf9	123	if(rb_pipe(&in_f[0], &in_f[1], buf) < 0)
b57f37fb WP	124	{
	125	rb_free(helper);
	126	return NULL;
	127	}
	128	rb_snprintf(buf, sizeof(buf), "%s helper - write", name);
	129	if(rb_pipe(&out_f[0], &out_f[1], buf) < 0)
	130	{
	131	rb_free(helper);
	132	return NULL;
	133	}
94b4fbf9	134
b57f37fb WP	135	rb_snprintf(fx, sizeof(fx), "%d", rb_get_fd(in_f[1]));
b57f37fb WP	136	rb_snprintf(fy, sizeof(fy), "%d", rb_get_fd(out_f[0]));
94b4fbf9	137
b57f37fb WP	138	rb_set_nb(in_f[0]);
	139	rb_set_nb(in_f[1]);
	140	rb_set_nb(out_f[0]);
	141	rb_set_nb(out_f[1]);
94b4fbf9 VY	142
	143	rb_setenv("IFD", fy, 1);
	144	rb_setenv("OFD", fx, 1);
	145	rb_setenv("MAXFD", "256", 1);
	146
b57f37fb WP	147	rb_snprintf(buf, sizeof(buf), "-ircd %s daemon", name);
	148	parv[0] = buf;
	149	parv[1] = NULL;
	150
94b4fbf9 VY	151	#ifdef _WIN32
	152	SetHandleInformation((HANDLE) rb_get_fd(in_f[1]), HANDLE_FLAG_INHERIT, 1);
	153	SetHandleInformation((HANDLE) rb_get_fd(out_f[0]), HANDLE_FLAG_INHERIT, 1);
b57f37fb	154	#endif
94b4fbf9	155
b57f37fb	156	pid = rb_spawn_process(fullpath, (const char **)parv);
94b4fbf9	157
b57f37fb WP	158	if(pid == -1)
	159	{
	160	rb_close(in_f[0]);
	161	rb_close(in_f[1]);
	162	rb_close(out_f[0]);
	163	rb_close(out_f[1]);
	164	rb_free(helper);
	165	return NULL;
	166	}
	167
	168	rb_close(in_f[1]);
	169	rb_close(out_f[0]);
94b4fbf9	170
b57f37fb WP	171	rb_linebuf_newbuf(&helper->sendq);
b57f37fb WP	172	rb_linebuf_newbuf(&helper->recvq);
94b4fbf9	173
b57f37fb WP	174	helper->ifd = in_f[0];
	175	helper->ofd = out_f[1];
	176	helper->read_cb = read_cb;
94b4fbf9	177	helper->error_cb = error_cb;
b57f37fb WP	178	helper->fork_count = 0;
	179	helper->pid = pid;
	180
	181	return helper;
	182	}
	183
	184
	185	void
	186	rb_helper_restart(rb_helper *helper)
	187	{
	188	helper->error_cb(helper);
	189	}
	190
	191
	192	static void
	193	rb_helper_write_sendq(rb_fde_t F, void helper_ptr)
	194	{
	195	rb_helper *helper = helper_ptr;
	196	int retlen;
94b4fbf9	197
b57f37fb WP	198	if(rb_linebuf_len(&helper->sendq) > 0)
	199	{
	200	while((retlen = rb_linebuf_flush(F, &helper->sendq)) > 0)
	201	;;
94b4fbf9 VY	202	if(retlen == 0 \|\| (retlen < 0 && !rb_ignore_errno(errno)))
94b4fbf9 VY	203	{
b57f37fb WP	204	rb_helper_restart(helper);
	205	return;
	206	}
	207	}
	208
	209	if(rb_linebuf_len(&helper->sendq) > 0)
	210	rb_setselect(helper->ofd, RB_SELECT_WRITE, rb_helper_write_sendq, helper);
	211	}
	212
94b4fbf9	213	void
b57f37fb WP	214	rb_helper_write_queue(rb_helper helper, const char format, ...)
	215	{
	216	va_list ap;
	217	va_start(ap, format);
	218	rb_linebuf_putmsg(&helper->sendq, format, &ap, NULL);
	219	va_end(ap);
	220	}
	221
	222	void
	223	rb_helper_write_flush(rb_helper *helper)
	224	{
94b4fbf9	225	rb_helper_write_sendq(helper->ofd, helper);
b57f37fb WP	226	}
	227
	228
	229	void
	230	rb_helper_write(rb_helper helper, const char format, ...)
	231	{
	232	va_list ap;
	233	va_start(ap, format);
	234	rb_linebuf_putmsg(&helper->sendq, format, &ap, NULL);
	235	va_end(ap);
	236	rb_helper_write_flush(helper);
	237	}
	238
	239	static void
	240	rb_helper_read_cb(rb_fde_t F, void data)
	241	{
	242	rb_helper helper = (rb_helper )data;
	243	static char buf[32768];
	244	int length;
	245	if(helper == NULL)
	246	return;
94b4fbf9	247
b57f37fb WP	248	while((length = rb_read(helper->ifd, buf, sizeof(buf))) > 0)
	249	{
	250	rb_linebuf_parse(&helper->recvq, buf, length, 0);
	251	helper->read_cb(helper);
	252	}
	253
	254	if(length == 0 \|\| (length < 0 && !rb_ignore_errno(errno)))
	255	{
	256	rb_helper_restart(helper);
	257	return;
	258	}
94b4fbf9	259
b57f37fb WP	260	rb_setselect(helper->ifd, RB_SELECT_READ, rb_helper_read_cb, helper);
	261	}
	262
	263	void
	264	rb_helper_run(rb_helper *helper)
	265	{
	266	if(helper == NULL)
	267	return;
	268	rb_helper_read_cb(helper->ifd, helper);
	269	}
	270
	271
	272	void
	273	rb_helper_close(rb_helper *helper)
	274	{
	275	if(helper == NULL)
	276	return;
94b4fbf9	277	rb_kill(helper->pid, SIGKILL);
b57f37fb WP	278	rb_close(helper->ifd);
b57f37fb WP	279	rb_close(helper->ofd);
94b4fbf9	280	rb_free(helper);
b57f37fb WP	281	}
	282
	283	int
	284	rb_helper_read(rb_helper helper, void buf, size_t bufsize)
	285	{
	286	return rb_linebuf_get(&helper->recvq, buf, bufsize, LINEBUF_COMPLETE, LINEBUF_PARSED);
	287	}
	288
	289	void
	290	rb_helper_loop(rb_helper *helper, long delay)
	291	{
	292	rb_helper_run(helper);
	293	while(1)
	294	{
	295	rb_lib_loop(delay);
	296	}
	297	}