[solanum.git] / wsockd / wsockd.c

/*
 *  wsockd.c: charybdis websockets helper
 *  Copyright (C) 2007 Aaron Sethman <androsyn@ratbox.org>
 *  Copyright (C) 2007 ircd-ratbox development team
 *  Copyright (C) 2016 William Pitcock <nenolod@dereferenced.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
 */

#include "stdinc.h"
#include "sha1.h"

#define MAXPASSFD 4
#ifndef READBUF_SIZE
#define READBUF_SIZE 16384
#endif

#define WEBSOCKET_SERVER_KEY "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
#define WEBSOCKET_ANSWER_STRING_1 "HTTP/1.1 101 Switching Protocols\r\nAccess-Control-Allow-Origin: *\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "
#define WEBSOCKET_ANSWER_STRING_2 "\r\n\r\n"

static void setup_signals(void);
static pid_t ppid;

static inline uint32_t
buf_to_uint32(uint8_t *buf)
{
	uint32_t x;
	memcpy(&x, buf, sizeof(x));
	return x;
}

static inline void
uint32_to_buf(uint8_t *buf, uint32_t x)
{
	memcpy(buf, &x, sizeof(x));
	return;
}

typedef struct _mod_ctl_buf
{
	rb_dlink_node node;
	uint8_t *buf;
	size_t buflen;
	rb_fde_t *F[MAXPASSFD];
	int nfds;
} mod_ctl_buf_t;

typedef struct _mod_ctl
{
	rb_dlink_node node;
	int cli_count;
	rb_fde_t *F;
	rb_fde_t *F_pipe;
	rb_dlink_list readq;
	rb_dlink_list writeq;
} mod_ctl_t;

static mod_ctl_t *mod_ctl;

typedef struct _conn
{
	rb_dlink_node node;
	mod_ctl_t *ctl;

	rawbuf_head_t *modbuf_out;
	rawbuf_head_t *modbuf_in;

	buf_head_t plainbuf_out;
	buf_head_t plainbuf_in;

	uint32_t id;

	rb_fde_t *mod_fd;
	rb_fde_t *plain_fd;
	uint64_t mod_out;
	uint64_t mod_in;
	uint64_t plain_in;
	uint64_t plain_out;
	uint8_t flags;

	char client_key[37];		/* maximum 36 bytes + nul */
} conn_t;

#ifdef _WIN32
char *
strcasestr(const char *s, *find)
{
	char c, sc;
	size_t len;

	if ((c = *find++) != 0) {
		c = tolower((unsigned char)c);
		len = strlen(find);
		do {
			do {
				if ((sc = *s++) == 0)
					return (NULL);
			} while ((char)tolower((unsigned char)sc) != c);
		} while (strnicmp(s, find, len) != 0);
		s--;
	}
	return ((char *)s);
}
#endif

static void close_conn(conn_t * conn, int wait_plain, const char *fmt, ...);
static void conn_mod_read_cb(rb_fde_t *fd, void *data);
static void conn_plain_read_cb(rb_fde_t *fd, void *data);

#define FLAG_CORK	0x01
#define FLAG_DEAD	0x02
#define FLAG_WSOCK	0x04
#define FLAG_KEYED	0x08

#define IsCork(x) ((x)->flags & FLAG_CORK)
#define IsDead(x) ((x)->flags & FLAG_DEAD)
#define IsWS(x)   ((x)->flags & FLAG_WSOCK)
#define IsKeyed(x) ((x)->flags & FLAG_KEYED)

#define SetCork(x) ((x)->flags |= FLAG_CORK)
#define SetDead(x) ((x)->flags |= FLAG_DEAD)
#define SetWS(x)   ((x)->flags |= FLAG_WSOCK)
#define SetKeyed(x) ((x)->flags |= FLAG_KEYED)

#define ClearCork(x) ((x)->flags &= ~FLAG_CORK)
#define ClearDead(x) ((x)->flags &= ~FLAG_DEAD)
#define ClearWS(x)   ((x)->flags &= ~FLAG_WSOCK)
#define ClearKeyed(x) ((x)->flags &= ~FLAG_KEYED)

#define NO_WAIT 0x0
#define WAIT_PLAIN 0x1

#define HASH_WALK_SAFE(i, max, ptr, next, table) for(i = 0; i < max; i++) { RB_DLINK_FOREACH_SAFE(ptr, next, table[i].head)
#define HASH_WALK_END }
#define CONN_HASH_SIZE 2000
#define connid_hash(x)	(&connid_hash_table[(x % CONN_HASH_SIZE)])

static const char *remote_closed = "Remote host closed the connection";

static rb_dlink_list connid_hash_table[CONN_HASH_SIZE];
static rb_dlink_list dead_list;

static void conn_plain_read_shutdown_cb(rb_fde_t *fd, void *data);

#ifndef _WIN32
static void
dummy_handler(int sig)
{
	return;
}
#endif

static void
setup_signals()
{
#ifndef _WIN32
	struct sigaction act;

	act.sa_flags = 0;
	act.sa_handler = SIG_IGN;
	sigemptyset(&act.sa_mask);
	sigaddset(&act.sa_mask, SIGPIPE);
	sigaddset(&act.sa_mask, SIGALRM);
#ifdef SIGTRAP
	sigaddset(&act.sa_mask, SIGTRAP);
#endif

#ifdef SIGWINCH
	sigaddset(&act.sa_mask, SIGWINCH);
	sigaction(SIGWINCH, &act, 0);
#endif
	sigaction(SIGPIPE, &act, 0);
#ifdef SIGTRAP
	sigaction(SIGTRAP, &act, 0);
#endif

	act.sa_handler = dummy_handler;
	sigaction(SIGALRM, &act, 0);
#endif
}

static int
maxconn(void)
{
#if defined(RLIMIT_NOFILE) && defined(HAVE_SYS_RESOURCE_H)
	struct rlimit limit;

	if(!getrlimit(RLIMIT_NOFILE, &limit))
	{
		return limit.rlim_cur;
	}
#endif /* RLIMIT_FD_MAX */
	return MAXCONNECTIONS;
}

static conn_t *
conn_find_by_id(uint32_t id)
{
	rb_dlink_node *ptr;
	conn_t *conn;

	RB_DLINK_FOREACH(ptr, (connid_hash(id))->head)
	{
		conn = ptr->data;
		if(conn->id == id && !IsDead(conn))
			return conn;
	}
	return NULL;
}

static void
conn_add_id_hash(conn_t * conn, uint32_t id)
{
	conn->id = id;
	rb_dlinkAdd(conn, &conn->node, connid_hash(id));
}

static void
free_conn(conn_t * conn)
{
	rb_linebuf_donebuf(&conn->plainbuf_in);
	rb_linebuf_donebuf(&conn->plainbuf_out);

	rb_free_rawbuffer(conn->modbuf_in);
	rb_free_rawbuffer(conn->modbuf_out);

	rb_free(conn);
}

static void
clean_dead_conns(void *unused)
{
	conn_t *conn;
	rb_dlink_node *ptr, *next;

	RB_DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
	{
		conn = ptr->data;
		free_conn(conn);
	}

	dead_list.tail = dead_list.head = NULL;
}

static void
conn_mod_write_sendq(rb_fde_t *fd, void *data)
{
	conn_t *conn = data;
	const char *err;
	int retlen;

	if(IsDead(conn))
		return;

	while((retlen = rb_rawbuf_flush(conn->modbuf_out, fd)) > 0)
		conn->mod_out += retlen;

	if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
	{
		if(retlen == 0)
			close_conn(conn, WAIT_PLAIN, "%s", remote_closed);
		err = strerror(errno);
		close_conn(conn, WAIT_PLAIN, "Write error: %s", err);
		return;
	}

	if(rb_rawbuf_length(conn->modbuf_out) > 0)
		rb_setselect(conn->mod_fd, RB_SELECT_WRITE, conn_mod_write_sendq, conn);
	else
		rb_setselect(conn->mod_fd, RB_SELECT_WRITE, NULL, NULL);

	if(IsCork(conn) && rb_rawbuf_length(conn->modbuf_out) == 0)
	{
		ClearCork(conn);
		conn_plain_read_cb(conn->plain_fd, conn);
	}
}

static void
conn_mod_write(conn_t * conn, void *data, size_t len)
{
	if(IsDead(conn))	/* no point in queueing to a dead man */
		return;
	rb_rawbuf_append(conn->modbuf_out, data, len);
}

static void
conn_mod_write_frame(conn_t * conn, void *data, size_t len)
{
	if(IsDead(conn))	/* no point in queueing to a dead man */
		return;
}

static void
conn_plain_write(conn_t * conn, void *data, size_t len)
{
	if(IsDead(conn))	/* again no point in queueing to dead men */
		return;
	rb_linebuf_put(&conn->plainbuf_out, data, len);
}

static void
mod_write_ctl(rb_fde_t *F, void *data)
{
	mod_ctl_t *ctl = data;
	mod_ctl_buf_t *ctl_buf;
	rb_dlink_node *ptr, *next;
	int retlen, x;

	RB_DLINK_FOREACH_SAFE(ptr, next, ctl->writeq.head)
	{
		ctl_buf = ptr->data;
		retlen = rb_send_fd_buf(ctl->F, ctl_buf->F, ctl_buf->nfds, ctl_buf->buf,
					ctl_buf->buflen, ppid);
		if(retlen > 0)
		{
			rb_dlinkDelete(ptr, &ctl->writeq);
			for(x = 0; x < ctl_buf->nfds; x++)
				rb_close(ctl_buf->F[x]);
			rb_free(ctl_buf->buf);
			rb_free(ctl_buf);

		}
		if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
			exit(0);

	}
	if(rb_dlink_list_length(&ctl->writeq) > 0)
		rb_setselect(ctl->F, RB_SELECT_WRITE, mod_write_ctl, ctl);
}

static void
mod_cmd_write_queue(mod_ctl_t * ctl, const void *data, size_t len)
{
	mod_ctl_buf_t *ctl_buf;
	ctl_buf = rb_malloc(sizeof(mod_ctl_buf_t));
	ctl_buf->buf = rb_malloc(len);
	ctl_buf->buflen = len;
	memcpy(ctl_buf->buf, data, len);
	ctl_buf->nfds = 0;
	rb_dlinkAddTail(ctl_buf, &ctl_buf->node, &ctl->writeq);
	mod_write_ctl(ctl->F, ctl);
}

static void
close_conn(conn_t * conn, int wait_plain, const char *fmt, ...)
{
	va_list ap;
	char reason[128];	/* must always be under 250 bytes */
	uint8_t buf[256];
	int len;
	if(IsDead(conn))
		return;

	rb_rawbuf_flush(conn->modbuf_out, conn->mod_fd);
	rb_linebuf_flush(conn->plain_fd, &conn->plainbuf_out);
	rb_close(conn->mod_fd);
	SetDead(conn);

	rb_dlinkDelete(&conn->node, connid_hash(conn->id));

	if(!wait_plain || fmt == NULL)
	{
		rb_close(conn->plain_fd);
		rb_dlinkAdd(conn, &conn->node, &dead_list);
		return;
	}

	rb_setselect(conn->plain_fd, RB_SELECT_READ, conn_plain_read_shutdown_cb, conn);
	rb_setselect(conn->plain_fd, RB_SELECT_WRITE, NULL, NULL);

	va_start(ap, fmt);
	vsnprintf(reason, sizeof(reason), fmt, ap);
	va_end(ap);

	buf[0] = 'D';
	uint32_to_buf(&buf[1], conn->id);
	rb_strlcpy((char *) &buf[5], reason, sizeof(buf) - 5);
	len = (strlen(reason) + 1) + 5;
	mod_cmd_write_queue(conn->ctl, buf, len);
}

static conn_t *
make_conn(mod_ctl_t * ctl, rb_fde_t *mod_fd, rb_fde_t *plain_fd)
{
	conn_t *conn = rb_malloc(sizeof(conn_t));
	conn->ctl = ctl;
	conn->mod_fd = mod_fd;
	conn->plain_fd = plain_fd;
	conn->id = -1;
	rb_set_nb(mod_fd);
	rb_set_nb(plain_fd);

	rb_linebuf_newbuf(&conn->plainbuf_in);
	rb_linebuf_newbuf(&conn->plainbuf_out);

	conn->modbuf_in = rb_new_rawbuffer();
	conn->modbuf_out = rb_new_rawbuffer();

	return conn;
}

static void
cleanup_bad_message(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
{
	int i;

	/* XXX should log this somehow */
	for (i = 0; i < ctlb->nfds; i++)
		rb_close(ctlb->F[i]);
}

static void
conn_mod_handshake_process(conn_t *conn)
{
	char inbuf[READBUF_SIZE];

	while (1)
	{
		char *p = NULL;

		size_t dolen = rb_rawbuf_get(conn->modbuf_in, inbuf, sizeof inbuf);
		if (!dolen)
			break;

		if ((p = strcasestr(inbuf, "Sec-WebSocket-Key:")) != NULL)
		{
			char *start, *end;

			start = p + strlen("Sec-WebSocket-Key:");

			for (; start < (inbuf + READBUF_SIZE) && *start; start++)
			{
				if (*start != ' ' && *start != '\t')
					break;
			}

			for (end = start; end < (inbuf + READBUF_SIZE) && *end; end++)
			{
				if (*end == '\r' || *end == '\n')
				{
					*end = '\0';
					break;
				}
			}

			rb_strlcpy(conn->client_key, start, sizeof(conn->client_key));
			SetKeyed(conn);
		}
	}

	if (IsKeyed(conn))
	{
		SHA1 sha1;
		uint8_t digest[SHA1_DIGEST_LENGTH];
		char *resp;

		sha1_init(&sha1);
		sha1_update(&sha1, (uint8_t *) conn->client_key, strlen(conn->client_key));
		sha1_update(&sha1, (uint8_t *) WEBSOCKET_SERVER_KEY, strlen(WEBSOCKET_SERVER_KEY));
		sha1_final(&sha1, digest);

		resp = (char *) rb_base64_encode(digest, SHA1_DIGEST_LENGTH);

		conn_mod_write(conn, WEBSOCKET_ANSWER_STRING_1, strlen(WEBSOCKET_ANSWER_STRING_1));
		conn_mod_write(conn, resp, strlen(resp));
		conn_mod_write(conn, WEBSOCKET_ANSWER_STRING_2, strlen(WEBSOCKET_ANSWER_STRING_2));

		rb_free(resp);
	}

	conn_mod_write_sendq(conn->mod_fd, conn);
}

static void
conn_mod_read_cb(rb_fde_t *fd, void *data)
{
	char inbuf[READBUF_SIZE];
	conn_t *conn = data;
	int length = 0;
	if (conn == NULL)
		return;

	if (IsDead(conn))
		return;

	while (1)
	{
		if (IsDead(conn))
			return;

		length = rb_read(fd, inbuf, sizeof(inbuf));

                if (length < 0)
		{
			if (rb_ignore_errno(errno))
				rb_setselect(fd, RB_SELECT_READ, conn_mod_read_cb, conn);
			else
				close_conn(conn, NO_WAIT, "Connection closed");

			return;
		}
		else if (length == 0)
		{
			close_conn(conn, NO_WAIT, "Connection closed");
			return;
		}

		rb_rawbuf_append(conn->modbuf_in, inbuf, length);
		if (!IsKeyed(conn))
			conn_mod_handshake_process(conn);

		if (length < sizeof(inbuf))
		{
			rb_setselect(fd, RB_SELECT_READ, conn_mod_read_cb, conn);
			return;
		}
	}
}

static bool
plain_check_cork(conn_t * conn)
{
	if(rb_rawbuf_length(conn->modbuf_out) >= 4096)
	{
		/* if we have over 4k pending outbound, don't read until
		 * we've cleared the queue */
		SetCork(conn);
		rb_setselect(conn->plain_fd, RB_SELECT_READ, NULL, NULL);
		/* try to write */
		conn_mod_write_sendq(conn->mod_fd, conn);
		return true;
	}

	return false;
}

static void
conn_plain_process_recvq(conn_t *conn)
{
	char inbuf[READBUF_SIZE];

	while (1)
	{
		size_t dolen = rb_linebuf_get(&conn->plainbuf_in, inbuf, sizeof inbuf, LINEBUF_COMPLETE, LINEBUF_PARSED);
		if (!dolen)
			break;

		conn_mod_write_frame(conn, inbuf, dolen);
	}
}

static void
conn_plain_read_cb(rb_fde_t *fd, void *data)
{
	char inbuf[READBUF_SIZE];
	conn_t *conn = data;
	int length = 0;
	if(conn == NULL)
		return;

	if(IsDead(conn))
		return;

	if(plain_check_cork(conn))
		return;

	while(1)
	{
		if(IsDead(conn))
			return;

		length = rb_read(conn->plain_fd, inbuf, sizeof(inbuf));

		if(length == 0 || (length < 0 && !rb_ignore_errno(errno)))
		{
			close_conn(conn, NO_WAIT, NULL);
			return;
		}

		if(length < 0)
		{
			rb_setselect(conn->plain_fd, RB_SELECT_READ, conn_plain_read_cb, conn);
			conn_plain_process_recvq(conn);
			return;
		}
		conn->plain_in += length;

		(void) rb_linebuf_parse(&conn->plainbuf_in, inbuf, sizeof(inbuf), 0);

		if(IsDead(conn))
			return;
		if(plain_check_cork(conn))
			return;
	}
}

static void
conn_plain_read_shutdown_cb(rb_fde_t *fd, void *data)
{
	char inbuf[READBUF_SIZE];
	conn_t *conn = data;
	int length = 0;

	if(conn == NULL)
		return;

	while(1)
	{
		length = rb_read(conn->plain_fd, inbuf, sizeof(inbuf));

		if(length == 0 || (length < 0 && !rb_ignore_errno(errno)))
		{
			rb_close(conn->plain_fd);
			rb_dlinkAdd(conn, &conn->node, &dead_list);
			return;
		}

		if(length < 0)
		{
			rb_setselect(conn->plain_fd, RB_SELECT_READ, conn_plain_read_shutdown_cb, conn);
			return;
		}
	}
}

static void
wsock_process(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
{
	conn_t *conn;
	uint32_t id;

	conn = make_conn(ctl, ctlb->F[0], ctlb->F[1]);

	id = buf_to_uint32(&ctlb->buf[1]);
	conn_add_id_hash(conn, id);
	SetWS(conn);

	if(rb_get_type(conn->mod_fd) & RB_FD_UNKNOWN)
		rb_set_type(conn->mod_fd, RB_FD_SOCKET);

	if(rb_get_type(conn->plain_fd) == RB_FD_UNKNOWN)
		rb_set_type(conn->plain_fd, RB_FD_SOCKET);

	conn_mod_read_cb(conn->mod_fd, conn);
}

static void
mod_process_cmd_recv(mod_ctl_t * ctl)
{
	rb_dlink_node *ptr, *next;
	mod_ctl_buf_t *ctl_buf;

	RB_DLINK_FOREACH_SAFE(ptr, next, ctl->readq.head)
	{
		ctl_buf = ptr->data;

		switch (*ctl_buf->buf)
		{
		case 'A':
			{
				if (ctl_buf->nfds != 2 || ctl_buf->buflen != 5)
				{
					cleanup_bad_message(ctl, ctl_buf);
					break;
				}
				wsock_process(ctl, ctl_buf);
				break;
			}
		default:
			break;
			/* Log unknown commands */
		}
		rb_dlinkDelete(ptr, &ctl->readq);
		rb_free(ctl_buf->buf);
		rb_free(ctl_buf);
	}

}

static void
mod_read_ctl(rb_fde_t *F, void *data)
{
	mod_ctl_buf_t *ctl_buf;
	mod_ctl_t *ctl = data;
	int retlen;
	int i;

	do
	{
		ctl_buf = rb_malloc(sizeof(mod_ctl_buf_t));
		ctl_buf->buf = rb_malloc(READBUF_SIZE);
		ctl_buf->buflen = READBUF_SIZE;
		retlen = rb_recv_fd_buf(ctl->F, ctl_buf->buf, ctl_buf->buflen, ctl_buf->F,
					MAXPASSFD);
		if(retlen <= 0)
		{
			rb_free(ctl_buf->buf);
			rb_free(ctl_buf);
		}
		else
		{
			ctl_buf->buflen = retlen;
			rb_dlinkAddTail(ctl_buf, &ctl_buf->node, &ctl->readq);
			for (i = 0; i < MAXPASSFD && ctl_buf->F[i] != NULL; i++)
				;
			ctl_buf->nfds = i;
		}
	}
	while(retlen > 0);

	if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
		exit(0);

	mod_process_cmd_recv(ctl);
	rb_setselect(ctl->F, RB_SELECT_READ, mod_read_ctl, ctl);
}

static void
read_pipe_ctl(rb_fde_t *F, void *data)
{
	char inbuf[READBUF_SIZE];
	int retlen;
	while((retlen = rb_read(F, inbuf, sizeof(inbuf))) > 0)
	{
		;;		/* we don't do anything with the pipe really, just care if the other process dies.. */
	}
	if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
		exit(0);
	rb_setselect(F, RB_SELECT_READ, read_pipe_ctl, NULL);
}

int
main(int argc, char **argv)
{
	const char *s_ctlfd, *s_pipe, *s_pid;
	int ctlfd, pipefd, x, maxfd;
	maxfd = maxconn();

	s_ctlfd = getenv("CTL_FD");
	s_pipe = getenv("CTL_PIPE");
	s_pid = getenv("CTL_PPID");

	if(s_ctlfd == NULL || s_pipe == NULL || s_pid == NULL)
	{
		fprintf(stderr,
			"This is the charybdis wsockd for internal ircd use.\n");
		fprintf(stderr,
			"You aren't supposed to run me directly. Exiting.\n");
		exit(1);
	}

	ctlfd = atoi(s_ctlfd);
	pipefd = atoi(s_pipe);
	ppid = atoi(s_pid);
	x = 0;
#ifndef _WIN32
	for(x = 0; x < maxfd; x++)
	{
		if(x != ctlfd && x != pipefd && x > 2)
			close(x);
	}
	x = open("/dev/null", O_RDWR);

	if(x >= 0)
	{
		if(ctlfd != 0 && pipefd != 0)
			dup2(x, 0);
		if(ctlfd != 1 && pipefd != 1)
			dup2(x, 1);
		if(ctlfd != 2 && pipefd != 2)
			dup2(x, 2);
		if(x > 2)
			close(x);
	}
#endif
	setup_signals();
	rb_lib_init(NULL, NULL, NULL, 0, maxfd, 1024, 4096);
	rb_linebuf_init(4096);
	rb_init_rawbuffers(4096);

	mod_ctl = rb_malloc(sizeof(mod_ctl_t));
	mod_ctl->F = rb_open(ctlfd, RB_FD_SOCKET, "ircd control socket");
	mod_ctl->F_pipe = rb_open(pipefd, RB_FD_PIPE, "ircd pipe");
	rb_set_nb(mod_ctl->F);
	rb_set_nb(mod_ctl->F_pipe);
	rb_event_addish("clean_dead_conns", clean_dead_conns, NULL, 10);
	read_pipe_ctl(mod_ctl->F_pipe, NULL);
	mod_read_ctl(mod_ctl->F, mod_ctl);

	rb_lib_loop(0);
	return 0;
}
Commit	Line	Data
caebeeca AC	1	/*
	2	* wsockd.c: charybdis websockets helper
	3	* Copyright (C) 2007 Aaron Sethman <androsyn@ratbox.org>
	4	* Copyright (C) 2007 ircd-ratbox development team
	5	* Copyright (C) 2016 William Pitcock <nenolod@dereferenced.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	*/
	22
	23	#include "stdinc.h"
1160f6c9	24	#include "sha1.h"
caebeeca AC	25
	26	#define MAXPASSFD 4
	27	#ifndef READBUF_SIZE
	28	#define READBUF_SIZE 16384
	29	#endif
	30
1160f6c9 AC	31	#define WEBSOCKET_SERVER_KEY "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
	32	#define WEBSOCKET_ANSWER_STRING_1 "HTTP/1.1 101 Switching Protocols\r\nAccess-Control-Allow-Origin: *\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "
	33	#define WEBSOCKET_ANSWER_STRING_2 "\r\n\r\n"
	34
caebeeca AC	35	static void setup_signals(void);
	36	static pid_t ppid;
	37
	38	static inline uint32_t
	39	buf_to_uint32(uint8_t *buf)
	40	{
	41	uint32_t x;
	42	memcpy(&x, buf, sizeof(x));
	43	return x;
	44	}
	45
	46	static inline void
	47	uint32_to_buf(uint8_t *buf, uint32_t x)
	48	{
	49	memcpy(buf, &x, sizeof(x));
	50	return;
	51	}
	52
	53	typedef struct _mod_ctl_buf
	54	{
	55	rb_dlink_node node;
	56	uint8_t *buf;
	57	size_t buflen;
	58	rb_fde_t *F[MAXPASSFD];
	59	int nfds;
	60	} mod_ctl_buf_t;
	61
	62	typedef struct _mod_ctl
	63	{
	64	rb_dlink_node node;
	65	int cli_count;
	66	rb_fde_t *F;
	67	rb_fde_t *F_pipe;
	68	rb_dlink_list readq;
	69	rb_dlink_list writeq;
	70	} mod_ctl_t;
	71
	72	static mod_ctl_t *mod_ctl;
	73
	74	typedef struct _conn
	75	{
	76	rb_dlink_node node;
	77	mod_ctl_t *ctl;
1c8c63cb	78
1160f6c9 AC	79	rawbuf_head_t *modbuf_out;
1160f6c9 AC	80	rawbuf_head_t *modbuf_in;
1c8c63cb AC	81
	82	buf_head_t plainbuf_out;
	83	buf_head_t plainbuf_in;
caebeeca AC	84
	85	uint32_t id;
	86
	87	rb_fde_t *mod_fd;
	88	rb_fde_t *plain_fd;
	89	uint64_t mod_out;
	90	uint64_t mod_in;
	91	uint64_t plain_in;
	92	uint64_t plain_out;
	93	uint8_t flags;
1160f6c9 AC	94
1160f6c9 AC	95	char client_key[37]; /* maximum 36 bytes + nul */
caebeeca AC	96	} conn_t;
caebeeca AC	97
37052804 AC	98	#ifdef _WIN32
	99	char *
	100	strcasestr(const char s, find)
	101	{
	102	char c, sc;
	103	size_t len;
	104
	105	if ((c = *find++) != 0) {
	106	c = tolower((unsigned char)c);
	107	len = strlen(find);
	108	do {
	109	do {
	110	if ((sc = *s++) == 0)
	111	return (NULL);
	112	} while ((char)tolower((unsigned char)sc) != c);
	113	} while (strnicmp(s, find, len) != 0);
	114	s--;
	115	}
	116	return ((char *)s);
	117	}
	118	#endif
	119
1160f6c9 AC	120	static void close_conn(conn_t * conn, int wait_plain, const char *fmt, ...);
	121	static void conn_mod_read_cb(rb_fde_t fd, void data);
	122	static void conn_plain_read_cb(rb_fde_t fd, void data);
	123
caebeeca AC	124	#define FLAG_CORK 0x01
	125	#define FLAG_DEAD 0x02
	126	#define FLAG_WSOCK 0x04
1160f6c9	127	#define FLAG_KEYED 0x08
caebeeca AC	128
	129	#define IsCork(x) ((x)->flags & FLAG_CORK)
	130	#define IsDead(x) ((x)->flags & FLAG_DEAD)
	131	#define IsWS(x) ((x)->flags & FLAG_WSOCK)
1160f6c9	132	#define IsKeyed(x) ((x)->flags & FLAG_KEYED)
caebeeca AC	133
	134	#define SetCork(x) ((x)->flags \|= FLAG_CORK)
	135	#define SetDead(x) ((x)->flags \|= FLAG_DEAD)
	136	#define SetWS(x) ((x)->flags \|= FLAG_WSOCK)
1160f6c9	137	#define SetKeyed(x) ((x)->flags \|= FLAG_KEYED)
caebeeca AC	138
	139	#define ClearCork(x) ((x)->flags &= ~FLAG_CORK)
	140	#define ClearDead(x) ((x)->flags &= ~FLAG_DEAD)
	141	#define ClearWS(x) ((x)->flags &= ~FLAG_WSOCK)
1160f6c9	142	#define ClearKeyed(x) ((x)->flags &= ~FLAG_KEYED)
caebeeca AC	143
	144	#define NO_WAIT 0x0
	145	#define WAIT_PLAIN 0x1
	146
	147	#define HASH_WALK_SAFE(i, max, ptr, next, table) for(i = 0; i < max; i++) { RB_DLINK_FOREACH_SAFE(ptr, next, table[i].head)
	148	#define HASH_WALK_END }
	149	#define CONN_HASH_SIZE 2000
	150	#define connid_hash(x) (&connid_hash_table[(x % CONN_HASH_SIZE)])
	151
1160f6c9 AC	152	static const char *remote_closed = "Remote host closed the connection";
1160f6c9 AC	153
caebeeca AC	154	static rb_dlink_list connid_hash_table[CONN_HASH_SIZE];
	155	static rb_dlink_list dead_list;
	156
05e0aa9a AC	157	static void conn_plain_read_shutdown_cb(rb_fde_t fd, void data);
05e0aa9a AC	158
caebeeca AC	159	#ifndef _WIN32
	160	static void
	161	dummy_handler(int sig)
	162	{
	163	return;
	164	}
	165	#endif
	166
	167	static void
	168	setup_signals()
	169	{
	170	#ifndef _WIN32
	171	struct sigaction act;
	172
	173	act.sa_flags = 0;
	174	act.sa_handler = SIG_IGN;
	175	sigemptyset(&act.sa_mask);
	176	sigaddset(&act.sa_mask, SIGPIPE);
	177	sigaddset(&act.sa_mask, SIGALRM);
	178	#ifdef SIGTRAP
	179	sigaddset(&act.sa_mask, SIGTRAP);
	180	#endif
	181
	182	#ifdef SIGWINCH
	183	sigaddset(&act.sa_mask, SIGWINCH);
	184	sigaction(SIGWINCH, &act, 0);
	185	#endif
	186	sigaction(SIGPIPE, &act, 0);
	187	#ifdef SIGTRAP
	188	sigaction(SIGTRAP, &act, 0);
	189	#endif
	190
	191	act.sa_handler = dummy_handler;
	192	sigaction(SIGALRM, &act, 0);
	193	#endif
	194	}
	195
	196	static int
	197	maxconn(void)
	198	{
	199	#if defined(RLIMIT_NOFILE) && defined(HAVE_SYS_RESOURCE_H)
	200	struct rlimit limit;
	201
	202	if(!getrlimit(RLIMIT_NOFILE, &limit))
	203	{
	204	return limit.rlim_cur;
	205	}
	206	#endif /* RLIMIT_FD_MAX */
	207	return MAXCONNECTIONS;
	208	}
	209
	210	static conn_t *
	211	conn_find_by_id(uint32_t id)
	212	{
	213	rb_dlink_node *ptr;
	214	conn_t *conn;
	215
	216	RB_DLINK_FOREACH(ptr, (connid_hash(id))->head)
	217	{
	218	conn = ptr->data;
	219	if(conn->id == id && !IsDead(conn))
	220	return conn;
	221	}
	222	return NULL;
223	}
224
225	static void
226	conn_add_id_hash(conn_t * conn, uint32_t id)
227	{
228	conn->id = id;
229	rb_dlinkAdd(conn, &conn->node, connid_hash(id));
230	}
231
232	static void
233	free_conn(conn_t * conn)
234	{
1c8c63cb AC	235	rb_linebuf_donebuf(&conn->plainbuf_in);
	236	rb_linebuf_donebuf(&conn->plainbuf_out);
	237
1160f6c9 AC	238	rb_free_rawbuffer(conn->modbuf_in);
1160f6c9 AC	239	rb_free_rawbuffer(conn->modbuf_out);
1c8c63cb	240
caebeeca AC	241	rb_free(conn);
	242	}
	243
	244	static void
	245	clean_dead_conns(void *unused)
	246	{
	247	conn_t *conn;
	248	rb_dlink_node ptr, next;
	249
	250	RB_DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
	251	{
	252	conn = ptr->data;
	253	free_conn(conn);
	254	}
	255
	256	dead_list.tail = dead_list.head = NULL;
	257	}
	258
1160f6c9 AC	259	static void
	260	conn_mod_write_sendq(rb_fde_t fd, void data)
	261	{
	262	conn_t *conn = data;
	263	const char *err;
	264	int retlen;
	265
	266	if(IsDead(conn))
	267	return;
	268
	269	while((retlen = rb_rawbuf_flush(conn->modbuf_out, fd)) > 0)
	270	conn->mod_out += retlen;
	271
	272	if(retlen == 0 \|\| (retlen < 0 && !rb_ignore_errno(errno)))
	273	{
	274	if(retlen == 0)
	275	close_conn(conn, WAIT_PLAIN, "%s", remote_closed);
	276	err = strerror(errno);
	277	close_conn(conn, WAIT_PLAIN, "Write error: %s", err);
	278	return;
	279	}
	280
	281	if(rb_rawbuf_length(conn->modbuf_out) > 0)
	282	rb_setselect(conn->mod_fd, RB_SELECT_WRITE, conn_mod_write_sendq, conn);
	283	else
	284	rb_setselect(conn->mod_fd, RB_SELECT_WRITE, NULL, NULL);
	285
	286	if(IsCork(conn) && rb_rawbuf_length(conn->modbuf_out) == 0)
	287	{
	288	ClearCork(conn);
	289	conn_plain_read_cb(conn->plain_fd, conn);
	290	}
	291	}
	292
	293	static void
	294	conn_mod_write(conn_t * conn, void *data, size_t len)
	295	{
	296	if(IsDead(conn)) /* no point in queueing to a dead man */
	297	return;
	298	rb_rawbuf_append(conn->modbuf_out, data, len);
	299	}
	300
f297042b AC	301	static void
	302	conn_mod_write_frame(conn_t * conn, void *data, size_t len)
	303	{
	304	if(IsDead(conn)) /* no point in queueing to a dead man */
	305	return;
	306	}
	307
1160f6c9 AC	308	static void
	309	conn_plain_write(conn_t * conn, void *data, size_t len)
	310	{
	311	if(IsDead(conn)) /* again no point in queueing to dead men */
	312	return;
	313	rb_linebuf_put(&conn->plainbuf_out, data, len);
	314	}
	315
05e0aa9a AC	316	static void
	317	mod_write_ctl(rb_fde_t F, void data)
	318	{
	319	mod_ctl_t *ctl = data;
	320	mod_ctl_buf_t *ctl_buf;
	321	rb_dlink_node ptr, next;
	322	int retlen, x;
	323
	324	RB_DLINK_FOREACH_SAFE(ptr, next, ctl->writeq.head)
	325	{
	326	ctl_buf = ptr->data;
	327	retlen = rb_send_fd_buf(ctl->F, ctl_buf->F, ctl_buf->nfds, ctl_buf->buf,
	328	ctl_buf->buflen, ppid);
	329	if(retlen > 0)
	330	{
	331	rb_dlinkDelete(ptr, &ctl->writeq);
	332	for(x = 0; x < ctl_buf->nfds; x++)
	333	rb_close(ctl_buf->F[x]);
	334	rb_free(ctl_buf->buf);
	335	rb_free(ctl_buf);
	336
	337	}
	338	if(retlen == 0 \|\| (retlen < 0 && !rb_ignore_errno(errno)))
	339	exit(0);
	340
	341	}
	342	if(rb_dlink_list_length(&ctl->writeq) > 0)
	343	rb_setselect(ctl->F, RB_SELECT_WRITE, mod_write_ctl, ctl);
	344	}
	345
	346	static void
	347	mod_cmd_write_queue(mod_ctl_t * ctl, const void *data, size_t len)
	348	{
	349	mod_ctl_buf_t *ctl_buf;
	350	ctl_buf = rb_malloc(sizeof(mod_ctl_buf_t));
	351	ctl_buf->buf = rb_malloc(len);
	352	ctl_buf->buflen = len;
	353	memcpy(ctl_buf->buf, data, len);
	354	ctl_buf->nfds = 0;
	355	rb_dlinkAddTail(ctl_buf, &ctl_buf->node, &ctl->writeq);
	356	mod_write_ctl(ctl->F, ctl);
	357	}
	358
	359	static void
	360	close_conn(conn_t * conn, int wait_plain, const char *fmt, ...)
	361	{
	362	va_list ap;
	363	char reason[128]; /* must always be under 250 bytes */
	364	uint8_t buf[256];
	365	int len;
	366	if(IsDead(conn))
	367	return;
	368
1160f6c9	369	rb_rawbuf_flush(conn->modbuf_out, conn->mod_fd);
1c8c63cb	370	rb_linebuf_flush(conn->plain_fd, &conn->plainbuf_out);
05e0aa9a AC	371	rb_close(conn->mod_fd);
	372	SetDead(conn);
	373
	374	rb_dlinkDelete(&conn->node, connid_hash(conn->id));
	375
	376	if(!wait_plain \|\| fmt == NULL)
	377	{
	378	rb_close(conn->plain_fd);
	379	rb_dlinkAdd(conn, &conn->node, &dead_list);
	380	return;
	381	}
	382
	383	rb_setselect(conn->plain_fd, RB_SELECT_READ, conn_plain_read_shutdown_cb, conn);
	384	rb_setselect(conn->plain_fd, RB_SELECT_WRITE, NULL, NULL);
	385
	386	va_start(ap, fmt);
	387	vsnprintf(reason, sizeof(reason), fmt, ap);
	388	va_end(ap);
	389
	390	buf[0] = 'D';
	391	uint32_to_buf(&buf[1], conn->id);
	392	rb_strlcpy((char *) &buf[5], reason, sizeof(buf) - 5);
	393	len = (strlen(reason) + 1) + 5;
	394	mod_cmd_write_queue(conn->ctl, buf, len);
	395	}
	396
caebeeca AC	397	static conn_t *
	398	make_conn(mod_ctl_t * ctl, rb_fde_t mod_fd, rb_fde_t plain_fd)
	399	{
	400	conn_t *conn = rb_malloc(sizeof(conn_t));
	401	conn->ctl = ctl;
caebeeca AC	402	conn->mod_fd = mod_fd;
	403	conn->plain_fd = plain_fd;
	404	conn->id = -1;
caebeeca AC	405	rb_set_nb(mod_fd);
caebeeca AC	406	rb_set_nb(plain_fd);
1c8c63cb AC	407
	408	rb_linebuf_newbuf(&conn->plainbuf_in);
	409	rb_linebuf_newbuf(&conn->plainbuf_out);
	410
1160f6c9 AC	411	conn->modbuf_in = rb_new_rawbuffer();
1160f6c9 AC	412	conn->modbuf_out = rb_new_rawbuffer();
1c8c63cb	413
caebeeca AC	414	return conn;
	415	}
	416
	417	static void
	418	cleanup_bad_message(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
	419	{
	420	int i;
	421
	422	/* XXX should log this somehow */
	423	for (i = 0; i < ctlb->nfds; i++)
	424	rb_close(ctlb->F[i]);
	425	}
	426
1c8c63cb AC	427	static void
	428	conn_mod_handshake_process(conn_t *conn)
	429	{
	430	char inbuf[READBUF_SIZE];
	431
	432	while (1)
	433	{
1160f6c9 AC	434	char *p = NULL;
	435
	436	size_t dolen = rb_rawbuf_get(conn->modbuf_in, inbuf, sizeof inbuf);
1c8c63cb AC	437	if (!dolen)
1c8c63cb AC	438	break;
1160f6c9 AC	439
	440	if ((p = strcasestr(inbuf, "Sec-WebSocket-Key:")) != NULL)
	441	{
	442	char start, end;
	443
	444	start = p + strlen("Sec-WebSocket-Key:");
	445
	446	for (; start < (inbuf + READBUF_SIZE) && *start; start++)
	447	{
	448	if (start != ' ' && start != '\t')
	449	break;
	450	}
	451
	452	for (end = start; end < (inbuf + READBUF_SIZE) && *end; end++)
	453	{
	454	if (end == '\r' \|\| end == '\n')
	455	{
	456	*end = '\0';
	457	break;
	458	}
	459	}
	460
	461	rb_strlcpy(conn->client_key, start, sizeof(conn->client_key));
	462	SetKeyed(conn);
	463	}
	464	}
	465
	466	if (IsKeyed(conn))
	467	{
	468	SHA1 sha1;
	469	uint8_t digest[SHA1_DIGEST_LENGTH];
	470	char *resp;
	471
	472	sha1_init(&sha1);
	473	sha1_update(&sha1, (uint8_t *) conn->client_key, strlen(conn->client_key));
	474	sha1_update(&sha1, (uint8_t *) WEBSOCKET_SERVER_KEY, strlen(WEBSOCKET_SERVER_KEY));
	475	sha1_final(&sha1, digest);
	476
	477	resp = (char *) rb_base64_encode(digest, SHA1_DIGEST_LENGTH);
	478
	479	conn_mod_write(conn, WEBSOCKET_ANSWER_STRING_1, strlen(WEBSOCKET_ANSWER_STRING_1));
	480	conn_mod_write(conn, resp, strlen(resp));
	481	conn_mod_write(conn, WEBSOCKET_ANSWER_STRING_2, strlen(WEBSOCKET_ANSWER_STRING_2));
	482
	483	rb_free(resp);
1c8c63cb	484	}
1160f6c9 AC	485
1160f6c9 AC	486	conn_mod_write_sendq(conn->mod_fd, conn);
1c8c63cb AC	487	}
1c8c63cb AC	488
caebeeca	489	static void
f297042b	490	conn_mod_read_cb(rb_fde_t fd, void data)
05e0aa9a AC	491	{
	492	char inbuf[READBUF_SIZE];
	493	conn_t *conn = data;
	494	int length = 0;
	495	if (conn == NULL)
	496	return;
	497
	498	if (IsDead(conn))
	499	return;
	500
	501	while (1)
	502	{
	503	if (IsDead(conn))
	504	return;
	505
1c8c63cb AC	506	length = rb_read(fd, inbuf, sizeof(inbuf));
	507
	508	if (length < 0)
	509	{
	510	if (rb_ignore_errno(errno))
f297042b	511	rb_setselect(fd, RB_SELECT_READ, conn_mod_read_cb, conn);
1c8c63cb AC	512	else
	513	close_conn(conn, NO_WAIT, "Connection closed");
	514
	515	return;
	516	}
	517	else if (length == 0)
05e0aa9a AC	518	{
	519	close_conn(conn, NO_WAIT, "Connection closed");
	520	return;
	521	}
1c8c63cb	522
1160f6c9	523	rb_rawbuf_append(conn->modbuf_in, inbuf, length);
f297042b AC	524	if (!IsKeyed(conn))
f297042b AC	525	conn_mod_handshake_process(conn);
1c8c63cb AC	526
	527	if (length < sizeof(inbuf))
	528	{
f297042b	529	rb_setselect(fd, RB_SELECT_READ, conn_mod_read_cb, conn);
1c8c63cb AC	530	return;
1c8c63cb AC	531	}
05e0aa9a AC	532	}
	533	}
	534
f297042b AC	535	static bool
	536	plain_check_cork(conn_t * conn)
	537	{
	538	if(rb_rawbuf_length(conn->modbuf_out) >= 4096)
	539	{
	540	/* if we have over 4k pending outbound, don't read until
	541	* we've cleared the queue */
	542	SetCork(conn);
	543	rb_setselect(conn->plain_fd, RB_SELECT_READ, NULL, NULL);
	544	/* try to write */
	545	conn_mod_write_sendq(conn->mod_fd, conn);
	546	return true;
	547	}
	548
	549	return false;
	550	}
	551
05e0aa9a	552	static void
f297042b	553	conn_plain_process_recvq(conn_t *conn)
05e0aa9a	554	{
f297042b AC	555	char inbuf[READBUF_SIZE];
	556
	557	while (1)
	558	{
	559	size_t dolen = rb_linebuf_get(&conn->plainbuf_in, inbuf, sizeof inbuf, LINEBUF_COMPLETE, LINEBUF_PARSED);
	560	if (!dolen)
	561	break;
	562
	563	conn_mod_write_frame(conn, inbuf, dolen);
	564	}
05e0aa9a AC	565	}
	566
	567	static void
	568	conn_plain_read_cb(rb_fde_t fd, void data)
	569	{
f297042b AC	570	char inbuf[READBUF_SIZE];
	571	conn_t *conn = data;
	572	int length = 0;
	573	if(conn == NULL)
	574	return;
	575
	576	if(IsDead(conn))
	577	return;
	578
	579	if(plain_check_cork(conn))
	580	return;
	581
	582	while(1)
	583	{
	584	if(IsDead(conn))
	585	return;
	586
	587	length = rb_read(conn->plain_fd, inbuf, sizeof(inbuf));
	588
	589	if(length == 0 \|\| (length < 0 && !rb_ignore_errno(errno)))
	590	{
	591	close_conn(conn, NO_WAIT, NULL);
	592	return;
	593	}
	594
	595	if(length < 0)
	596	{
	597	rb_setselect(conn->plain_fd, RB_SELECT_READ, conn_plain_read_cb, conn);
	598	conn_plain_process_recvq(conn);
	599	return;
	600	}
	601	conn->plain_in += length;
	602
	603	(void) rb_linebuf_parse(&conn->plainbuf_in, inbuf, sizeof(inbuf), 0);
	604
	605	if(IsDead(conn))
	606	return;
	607	if(plain_check_cork(conn))
	608	return;
	609	}
05e0aa9a AC	610	}
	611
	612	static void
	613	conn_plain_read_shutdown_cb(rb_fde_t fd, void data)
	614	{
	615	char inbuf[READBUF_SIZE];
	616	conn_t *conn = data;
	617	int length = 0;
	618
	619	if(conn == NULL)
	620	return;
	621
	622	while(1)
	623	{
	624	length = rb_read(conn->plain_fd, inbuf, sizeof(inbuf));
	625
	626	if(length == 0 \|\| (length < 0 && !rb_ignore_errno(errno)))
	627	{
	628	rb_close(conn->plain_fd);
	629	rb_dlinkAdd(conn, &conn->node, &dead_list);
	630	return;
	631	}
	632
	633	if(length < 0)
	634	{
	635	rb_setselect(conn->plain_fd, RB_SELECT_READ, conn_plain_read_shutdown_cb, conn);
	636	return;
	637	}
	638	}
	639	}
	640
	641	static void
	642	wsock_process(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
caebeeca AC	643	{
	644	conn_t *conn;
	645	uint32_t id;
	646
	647	conn = make_conn(ctl, ctlb->F[0], ctlb->F[1]);
	648
	649	id = buf_to_uint32(&ctlb->buf[1]);
	650	conn_add_id_hash(conn, id);
	651	SetWS(conn);
	652
	653	if(rb_get_type(conn->mod_fd) & RB_FD_UNKNOWN)
	654	rb_set_type(conn->mod_fd, RB_FD_SOCKET);
	655
	656	if(rb_get_type(conn->plain_fd) == RB_FD_UNKNOWN)
	657	rb_set_type(conn->plain_fd, RB_FD_SOCKET);
	658
f297042b	659	conn_mod_read_cb(conn->mod_fd, conn);
caebeeca AC	660	}
	661
	662	static void
	663	mod_process_cmd_recv(mod_ctl_t * ctl)
	664	{
	665	rb_dlink_node ptr, next;
	666	mod_ctl_buf_t *ctl_buf;
	667
	668	RB_DLINK_FOREACH_SAFE(ptr, next, ctl->readq.head)
	669	{
	670	ctl_buf = ptr->data;
	671
	672	switch (*ctl_buf->buf)
	673	{
	674	case 'A':
	675	{
	676	if (ctl_buf->nfds != 2 \|\| ctl_buf->buflen != 5)
	677	{
	678	cleanup_bad_message(ctl, ctl_buf);
	679	break;
	680	}
05e0aa9a	681	wsock_process(ctl, ctl_buf);
caebeeca AC	682	break;
	683	}
	684	default:
	685	break;
	686	/* Log unknown commands */
	687	}
	688	rb_dlinkDelete(ptr, &ctl->readq);
	689	rb_free(ctl_buf->buf);
	690	rb_free(ctl_buf);
	691	}
	692
	693	}
	694
	695	static void
	696	mod_read_ctl(rb_fde_t F, void data)
	697	{
	698	mod_ctl_buf_t *ctl_buf;
	699	mod_ctl_t *ctl = data;
	700	int retlen;
	701	int i;
	702
	703	do
	704	{
	705	ctl_buf = rb_malloc(sizeof(mod_ctl_buf_t));
	706	ctl_buf->buf = rb_malloc(READBUF_SIZE);
	707	ctl_buf->buflen = READBUF_SIZE;
	708	retlen = rb_recv_fd_buf(ctl->F, ctl_buf->buf, ctl_buf->buflen, ctl_buf->F,
	709	MAXPASSFD);
	710	if(retlen <= 0)
	711	{
	712	rb_free(ctl_buf->buf);
	713	rb_free(ctl_buf);
	714	}
	715	else
	716	{
	717	ctl_buf->buflen = retlen;
	718	rb_dlinkAddTail(ctl_buf, &ctl_buf->node, &ctl->readq);
	719	for (i = 0; i < MAXPASSFD && ctl_buf->F[i] != NULL; i++)
	720	;
	721	ctl_buf->nfds = i;
	722	}
	723	}
	724	while(retlen > 0);
	725
	726	if(retlen == 0 \|\| (retlen < 0 && !rb_ignore_errno(errno)))
	727	exit(0);
	728
	729	mod_process_cmd_recv(ctl);
	730	rb_setselect(ctl->F, RB_SELECT_READ, mod_read_ctl, ctl);
	731	}
	732
caebeeca AC	733	static void
	734	read_pipe_ctl(rb_fde_t F, void data)
	735	{
	736	char inbuf[READBUF_SIZE];
	737	int retlen;
	738	while((retlen = rb_read(F, inbuf, sizeof(inbuf))) > 0)
	739	{
	740	;; /* we don't do anything with the pipe really, just care if the other process dies.. */
	741	}
	742	if(retlen == 0 \|\| (retlen < 0 && !rb_ignore_errno(errno)))
	743	exit(0);
	744	rb_setselect(F, RB_SELECT_READ, read_pipe_ctl, NULL);
	745	}
	746
	747	int
	748	main(int argc, char **argv)
	749	{
	750	const char s_ctlfd, s_pipe, *s_pid;
	751	int ctlfd, pipefd, x, maxfd;
	752	maxfd = maxconn();
	753
	754	s_ctlfd = getenv("CTL_FD");
	755	s_pipe = getenv("CTL_PIPE");
	756	s_pid = getenv("CTL_PPID");
	757
	758	if(s_ctlfd == NULL \|\| s_pipe == NULL \|\| s_pid == NULL)
	759	{
	760	fprintf(stderr,
	761	"This is the charybdis wsockd for internal ircd use.\n");
	762	fprintf(stderr,
	763	"You aren't supposed to run me directly. Exiting.\n");
	764	exit(1);
	765	}
	766
	767	ctlfd = atoi(s_ctlfd);
	768	pipefd = atoi(s_pipe);
	769	ppid = atoi(s_pid);
	770	x = 0;
	771	#ifndef _WIN32
	772	for(x = 0; x < maxfd; x++)
	773	{
	774	if(x != ctlfd && x != pipefd && x > 2)
	775	close(x);
	776	}
	777	x = open("/dev/null", O_RDWR);
	778
	779	if(x >= 0)
	780	{
	781	if(ctlfd != 0 && pipefd != 0)
	782	dup2(x, 0);
	783	if(ctlfd != 1 && pipefd != 1)
	784	dup2(x, 1);
	785	if(ctlfd != 2 && pipefd != 2)
	786	dup2(x, 2);
	787	if(x > 2)
	788	close(x);
	789	}
	790	#endif
	791	setup_signals();
	792	rb_lib_init(NULL, NULL, NULL, 0, maxfd, 1024, 4096);
1c8c63cb	793	rb_linebuf_init(4096);
1160f6c9	794	rb_init_rawbuffers(4096);
caebeeca AC	795
	796	mod_ctl = rb_malloc(sizeof(mod_ctl_t));
	797	mod_ctl->F = rb_open(ctlfd, RB_FD_SOCKET, "ircd control socket");
	798	mod_ctl->F_pipe = rb_open(pipefd, RB_FD_PIPE, "ircd pipe");
	799	rb_set_nb(mod_ctl->F);
	800	rb_set_nb(mod_ctl->F_pipe);
	801	rb_event_addish("clean_dead_conns", clean_dead_conns, NULL, 10);
	802	read_pipe_ctl(mod_ctl->F_pipe, NULL);
	803	mod_read_ctl(mod_ctl->F, mod_ctl);
	804
	805	rb_lib_loop(0);
	806	return 0;
	807	}