X-Git-Url: https://jfr.im/git/irc/rqf/shadowircd.git/blobdiff_plain/d7cff1d11ba8b6a5eb393911b8edda125b2f9bbb..761f82c5d6958148cfcdcb12d6a04e726c14646e:/ssld/ssld.c

diff --git a/ssld/ssld.c b/ssld/ssld.c
index 83ba765..d7d8970 100644
--- a/ssld/ssld.c
+++ b/ssld/ssld.c
@@ -18,7 +18,7 @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  *  USA
  *
- *  $Id: ssld.c 25677 2008-07-06 04:21:42Z androsyn $
+ *  $Id$
  */
 
 
@@ -34,33 +34,38 @@
 #endif
 
 static void setup_signals(void);
+static pid_t ppid;
 
-static inline int32_t buf_to_int32(char *buf)
+static inline int32_t
+buf_to_int32(char *buf)
 {
 	int32_t x;
 	memcpy(&x, buf, sizeof(x));
 	return x;
 }
 
-static inline void int32_to_buf(char *buf, int32_t x)
+static inline void
+int32_to_buf(char *buf, int32_t x)
 {
 	memcpy(buf, &x, sizeof(x));
 	return;
 }
 
-static inline uint16_t buf_to_uint16(char *buf)
+static inline uint16_t
+buf_to_uint16(char *buf)
 {
 	uint16_t x;
 	memcpy(&x, buf, sizeof(x));
 	return x;
 }
 
-static inline void uint16_to_buf(char *buf, uint16_t x)
+static inline void
+uint16_to_buf(char *buf, uint16_t x)
 {
 	memcpy(buf, &x, sizeof(x));
 	return;
 }
- 
+
 
 static char inbuf[READBUF_SIZE];
 #ifdef HAVE_LIBZ
@@ -120,8 +125,8 @@ typedef struct _conn
 #define FLAG_ZIP	0x02
 #define FLAG_CORK	0x04
 #define FLAG_DEAD	0x08
-#define FLAG_SSL_W_WANTS_R 0x10 /* output needs to wait until input possible */
-#define FLAG_SSL_R_WANTS_W 0x20 /* input needs to wait until output possible */
+#define FLAG_SSL_W_WANTS_R 0x10	/* output needs to wait until input possible */
+#define FLAG_SSL_R_WANTS_W 0x20	/* input needs to wait until output possible */
 
 #define IsSSL(x) ((x)->flags & FLAG_SSL)
 #define IsZip(x) ((x)->flags & FLAG_ZIP)
@@ -157,12 +162,12 @@ typedef struct _conn
 static rb_dlink_list connid_hash_table[CONN_HASH_SIZE];
 static rb_dlink_list dead_list;
 
-static void conn_mod_read_cb(rb_fde_t * fd, void *data);
+static void conn_mod_read_cb(rb_fde_t *fd, void *data);
 static void conn_mod_write_sendq(rb_fde_t *, void *data);
 static void conn_plain_write_sendq(rb_fde_t *, void *data);
 static void mod_write_ctl(rb_fde_t *, void *data);
-static void conn_plain_read_cb(rb_fde_t * fd, void *data);
-static void mod_cmd_write_queue(mod_ctl_t *ctl, const void *data, size_t len);
+static void conn_plain_read_cb(rb_fde_t *fd, void *data);
+static void mod_cmd_write_queue(mod_ctl_t * ctl, const void *data, size_t len);
 static const char *remote_closed = "Remote host closed the connection";
 static int ssl_ok;
 #ifdef HAVE_LIBZ
@@ -182,7 +187,7 @@ ssld_alloc(void *unused, size_t count, size_t size)
 static void
 ssld_free(void *unused, void *ptr)
 {
-	rb_free(ptr);	
+	rb_free(ptr);
 }
 #endif
 
@@ -218,7 +223,7 @@ free_conn(conn_t * conn)
 	{
 		zlib_stream_t *stream = conn->stream;
 		inflateEnd(&stream->instream);
-		deflateEnd(&stream->outstream);		
+		deflateEnd(&stream->outstream);
 	}
 #endif
 	rb_free(conn);
@@ -242,12 +247,12 @@ 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 */
+	char reason[128];	/* must always be under 250 bytes */
 	char buf[256];
 	int len;
 	if(IsDead(conn))
 		return;
-	
+
 	rb_rawbuf_flush(conn->modbuf_out, conn->mod_fd);
 	rb_rawbuf_flush(conn->plainbuf_out, conn->plain_fd);
 	rb_close(conn->mod_fd);
@@ -256,13 +261,13 @@ close_conn(conn_t * conn, int wait_plain, const char *fmt, ...)
 	if(!wait_plain || fmt == NULL)
 	{
 		rb_close(conn->plain_fd);
-	
+
 		if(conn->id >= 0)
 			rb_dlinkDelete(&conn->node, connid_hash(conn->id));
 		rb_dlinkAdd(conn, &conn->node, &dead_list);
 		return;
 	}
-	rb_setselect(conn->plain_fd, RB_SELECT_WRITE|RB_SELECT_READ, NULL, NULL);
+	rb_setselect(conn->plain_fd, RB_SELECT_WRITE | RB_SELECT_READ, NULL, NULL);
 	va_start(ap, fmt);
 	rb_vsnprintf(reason, sizeof(reason), fmt, ap);
 	va_end(ap);
@@ -275,7 +280,7 @@ close_conn(conn_t * conn, int wait_plain, const char *fmt, ...)
 }
 
 static conn_t *
-make_conn(mod_ctl_t *ctl, rb_fde_t * mod_fd, rb_fde_t * plain_fd)
+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;
@@ -302,20 +307,18 @@ check_handshake_flood(void *unused)
 		conn = ptr->data;
 		if(!IsSSL(conn))
 			continue;
-				
+
 		count = rb_ssl_handshake_count(conn->mod_fd);
 		/* nothing needs to do this more than twice in ten seconds i don't think */
 		if(count > 2)
 			close_conn(conn, WAIT_PLAIN, "Handshake flooding");
 		else
 			rb_ssl_clear_handshake_count(conn->mod_fd);
-	} 
-	HASH_WALK_END
-
-}
+	}
+HASH_WALK_END}
 
 static void
-conn_mod_write_sendq(rb_fde_t * fd, void *data)
+conn_mod_write_sendq(rb_fde_t *fd, void *data)
 {
 	conn_t *conn = data;
 	const char *err;
@@ -331,7 +334,7 @@ conn_mod_write_sendq(rb_fde_t * fd, void *data)
 			return;
 	}
 
-	while ((retlen = rb_rawbuf_flush(conn->modbuf_out, fd)) > 0)
+	while((retlen = rb_rawbuf_flush(conn->modbuf_out, fd)) > 0)
 		conn->mod_out += retlen;
 
 	if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
@@ -401,7 +404,7 @@ static void
 common_zlib_deflate(conn_t * conn, void *buf, size_t len)
 {
 	int ret, have;
-	z_stream *outstream = &((zlib_stream_t *)conn->stream)->outstream;
+	z_stream *outstream = &((zlib_stream_t *) conn->stream)->outstream;
 	outstream->next_in = buf;
 	outstream->avail_in = len;
 	outstream->next_out = (Bytef *) outbuf;
@@ -422,7 +425,7 @@ common_zlib_deflate(conn_t * conn, void *buf, size_t len)
 	}
 	if(outstream->avail_in != 0)
 	{
-		/* avail_in isn't empty...*/
+		/* avail_in isn't empty... */
 		close_conn(conn, WAIT_PLAIN, "error compressing data, avail_in != 0");
 		return;
 	}
@@ -433,15 +436,15 @@ common_zlib_deflate(conn_t * conn, void *buf, size_t len)
 static void
 common_zlib_inflate(conn_t * conn, void *buf, size_t len)
 {
-	int ret, have;
-	((zlib_stream_t *)conn->stream)->instream.next_in = buf;
-	((zlib_stream_t *)conn->stream)->instream.avail_in = len;
-	((zlib_stream_t *)conn->stream)->instream.next_out = (Bytef *) outbuf;
-	((zlib_stream_t *)conn->stream)->instream.avail_out = sizeof(outbuf);
+	int ret, have = 0;
+	((zlib_stream_t *) conn->stream)->instream.next_in = buf;
+	((zlib_stream_t *) conn->stream)->instream.avail_in = len;
+	((zlib_stream_t *) conn->stream)->instream.next_out = (Bytef *) outbuf;
+	((zlib_stream_t *) conn->stream)->instream.avail_out = sizeof(outbuf);
 
-	while (((zlib_stream_t *)conn->stream)->instream.avail_in)
+	while(((zlib_stream_t *) conn->stream)->instream.avail_in)
 	{
-		ret = inflate(&((zlib_stream_t *)conn->stream)->instream, Z_NO_FLUSH);
+		ret = inflate(&((zlib_stream_t *) conn->stream)->instream, Z_NO_FLUSH);
 		if(ret != Z_OK)
 		{
 			if(!strncmp("ERROR ", buf, 6))
@@ -452,14 +455,14 @@ common_zlib_inflate(conn_t * conn, void *buf, size_t len)
 			close_conn(conn, WAIT_PLAIN, "Inflate failed: %s", zError(ret));
 			return;
 		}
-		have = sizeof(outbuf) - ((zlib_stream_t *)conn->stream)->instream.avail_out;
+		have = sizeof(outbuf) - ((zlib_stream_t *) conn->stream)->instream.avail_out;
 
-		if(((zlib_stream_t *)conn->stream)->instream.avail_in)
+		if(((zlib_stream_t *) conn->stream)->instream.avail_in)
 		{
 			conn_plain_write(conn, outbuf, have);
 			have = 0;
-			((zlib_stream_t *)conn->stream)->instream.next_out = (Bytef *) outbuf;
-			((zlib_stream_t *)conn->stream)->instream.avail_out = sizeof(outbuf);
+			((zlib_stream_t *) conn->stream)->instream.next_out = (Bytef *) outbuf;
+			((zlib_stream_t *) conn->stream)->instream.avail_out = sizeof(outbuf);
 		}
 	}
 	if(have == 0)
@@ -487,7 +490,7 @@ plain_check_cork(conn_t * conn)
 
 
 static void
-conn_plain_read_cb(rb_fde_t * fd, void *data)
+conn_plain_read_cb(rb_fde_t *fd, void *data)
 {
 	conn_t *conn = data;
 	int length = 0;
@@ -500,7 +503,7 @@ conn_plain_read_cb(rb_fde_t * fd, void *data)
 	if(plain_check_cork(conn))
 		return;
 
-	while (1)
+	while(1)
 	{
 		if(IsDead(conn))
 			return;
@@ -535,7 +538,7 @@ conn_plain_read_cb(rb_fde_t * fd, void *data)
 }
 
 static void
-conn_mod_read_cb(rb_fde_t * fd, void *data)
+conn_mod_read_cb(rb_fde_t *fd, void *data)
 {
 	conn_t *conn = data;
 	const char *err = remote_closed;
@@ -553,7 +556,7 @@ conn_mod_read_cb(rb_fde_t * fd, void *data)
 			return;
 	}
 
-	while (1)
+	while(1)
 	{
 		if(IsDead(conn))
 			return;
@@ -562,7 +565,8 @@ conn_mod_read_cb(rb_fde_t * fd, void *data)
 
 		if(length == 0 || (length < 0 && !rb_ignore_errno(errno)))
 		{
-			if(length == 0) {
+			if(length == 0)
+			{
 				close_conn(conn, WAIT_PLAIN, "%s", remote_closed);
 				return;
 			}
@@ -586,7 +590,7 @@ conn_mod_read_cb(rb_fde_t * fd, void *data)
 			}
 			conn_plain_write_sendq(conn->plain_fd, conn);
 			return;
-		}	
+		}
 		conn->mod_in += length;
 #ifdef HAVE_LIBZ
 		if(IsZip(conn))
@@ -598,7 +602,7 @@ conn_mod_read_cb(rb_fde_t * fd, void *data)
 }
 
 static void
-conn_plain_write_sendq(rb_fde_t * fd, void *data)
+conn_plain_write_sendq(rb_fde_t *fd, void *data)
 {
 	conn_t *conn = data;
 	int retlen;
@@ -606,7 +610,7 @@ conn_plain_write_sendq(rb_fde_t * fd, void *data)
 	if(IsDead(conn))
 		return;
 
-	while ((retlen = rb_rawbuf_flush(conn->plainbuf_out, fd)) > 0)
+	while((retlen = rb_rawbuf_flush(conn->plainbuf_out, fd)) > 0)
 	{
 		conn->plain_out += retlen;
 	}
@@ -615,7 +619,7 @@ conn_plain_write_sendq(rb_fde_t * fd, void *data)
 		close_conn(data, NO_WAIT, NULL);
 		return;
 	}
-	
+
 
 	if(rb_rawbuf_length(conn->plainbuf_out) > 0)
 		rb_setselect(conn->plain_fd, RB_SELECT_WRITE, conn_plain_write_sendq, conn);
@@ -638,7 +642,7 @@ maxconn(void)
 }
 
 static void
-ssl_process_accept_cb(rb_fde_t * F, int status, struct sockaddr *addr, rb_socklen_t len, void *data)
+ssl_process_accept_cb(rb_fde_t *F, int status, struct sockaddr *addr, rb_socklen_t len, void *data)
 {
 	conn_t *conn = data;
 	if(status == RB_OK)
@@ -653,7 +657,7 @@ ssl_process_accept_cb(rb_fde_t * F, int status, struct sockaddr *addr, rb_sockle
 }
 
 static void
-ssl_process_connect_cb(rb_fde_t * F, int status, void *data)
+ssl_process_connect_cb(rb_fde_t *F, int status, void *data)
 {
 	conn_t *conn = data;
 	if(status == RB_OK)
@@ -686,7 +690,7 @@ ssl_process_accept(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 
 	if(rb_get_type(conn->mod_fd) & RB_FD_UNKNOWN)
 	{
-		
+
 		rb_set_type(conn->mod_fd, RB_FD_SOCKET);
 	}
 	if(rb_get_type(conn->mod_fd) == RB_FD_UNKNOWN)
@@ -730,7 +734,7 @@ process_stats(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 
 	if(id < 0)
 		return;
-	
+
 	odata = &ctlb->buf[5];
 	conn = conn_find_by_id(id);
 
@@ -748,10 +752,10 @@ process_stats(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 
 #ifdef HAVE_LIBZ
 static void
-zlib_send_zip_ready(mod_ctl_t *ctl, conn_t *conn)
+zlib_send_zip_ready(mod_ctl_t * ctl, conn_t * conn)
 {
 	char buf[5];
-	
+
 	buf[0] = 'R';
 	int32_to_buf(&buf[1], conn->id);
 	mod_cmd_write_queue(conn->ctl, buf, sizeof(buf));
@@ -778,22 +782,22 @@ zlib_process(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 	id = buf_to_int32(&ctlb->buf[1]);
 	conn_add_id_hash(conn, id);
 
-	level = (uint8_t) ctlb->buf[5];
+	level = (uint8_t)ctlb->buf[5];
 
 	recvqlen = ctlb->buflen - hdr;
 	recvq_start = &ctlb->buf[6];
 
 	SetZip(conn);
 	conn->stream = rb_malloc(sizeof(zlib_stream_t));
-	instream = &((zlib_stream_t *)conn->stream)->instream;
-	outstream = &((zlib_stream_t *)conn->stream)->outstream;
-	
+	instream = &((zlib_stream_t *) conn->stream)->instream;
+	outstream = &((zlib_stream_t *) conn->stream)->outstream;
+
 	instream->total_in = 0;
 	instream->total_out = 0;
 	instream->zalloc = (alloc_func) ssld_alloc;
 	instream->zfree = (free_func) ssld_free;
 	instream->data_type = Z_ASCII;
-	inflateInit(&((zlib_stream_t *)conn->stream)->instream);
+	inflateInit(&((zlib_stream_t *) conn->stream)->instream);
 
 	outstream->total_in = 0;
 	outstream->total_out = 0;
@@ -804,7 +808,7 @@ zlib_process(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 	if(level > 9)
 		level = Z_DEFAULT_COMPRESSION;
 
-	deflateInit(&((zlib_stream_t *)conn->stream)->outstream, level);
+	deflateInit(&((zlib_stream_t *) conn->stream)->outstream, level);
 	if(recvqlen > 0)
 		common_zlib_inflate(conn, recvq_start, recvqlen);
 	zlib_send_zip_ready(ctl, conn);
@@ -820,8 +824,8 @@ init_prng(mod_ctl_t * ctl, mod_ctl_buf_t * ctl_buf)
 {
 	char *path;
 	prng_seed_t seed_type;
-	
-	seed_type = (prng_seed_t)ctl_buf->buf[1];	
+
+	seed_type = (prng_seed_t) ctl_buf->buf[1];
 	path = &ctl_buf->buf[2];
 	rb_init_prng(path, seed_type);
 }
@@ -847,37 +851,37 @@ ssl_new_keys(mod_ctl_t * ctl, mod_ctl_buf_t * ctl_buf)
 		const char *invalid = "I";
 		mod_cmd_write_queue(ctl, invalid, strlen(invalid));
 		return;
-	} 
+	}
 }
 
 static void
-send_nossl_support(mod_ctl_t *ctl, mod_ctl_buf_t *ctlb)
+send_nossl_support(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 {
 	static const char *nossl_cmd = "N";
 	conn_t *conn;
 	int32_t id;
 
 	if(ctlb != NULL)
-	{	
+	{
 		conn = make_conn(ctl, ctlb->F[0], ctlb->F[1]);
 		id = buf_to_int32(&ctlb->buf[1]);
 
 		if(id >= 0)
 			conn_add_id_hash(conn, id);
 		close_conn(conn, WAIT_PLAIN, "libratbox reports no SSL/TLS support");
-	} 
-	mod_cmd_write_queue(ctl, nossl_cmd, strlen(nossl_cmd));	
+	}
+	mod_cmd_write_queue(ctl, nossl_cmd, strlen(nossl_cmd));
 }
 
 static void
-send_i_am_useless(mod_ctl_t *ctl)
+send_i_am_useless(mod_ctl_t * ctl)
 {
 	static const char *useless = "U";
 	mod_cmd_write_queue(ctl, useless, strlen(useless));
 }
 
 static void
-send_nozlib_support(mod_ctl_t *ctl, mod_ctl_buf_t *ctlb)
+send_nozlib_support(mod_ctl_t * ctl, mod_ctl_buf_t * ctlb)
 {
 	static const char *nozlib_cmd = "z";
 	conn_t *conn;
@@ -890,7 +894,7 @@ send_nozlib_support(mod_ctl_t *ctl, mod_ctl_buf_t *ctlb)
 		if(id >= 0)
 			conn_add_id_hash(conn, id);
 		close_conn(conn, WAIT_PLAIN, "libratbox reports no zlib support");
-	} 
+	}
 	mod_cmd_write_queue(ctl, nozlib_cmd, strlen(nozlib_cmd));
 }
 
@@ -938,8 +942,8 @@ mod_process_cmd_recv(mod_ctl_t * ctl)
 				break;
 			}
 		case 'I':
-				init_prng(ctl, ctl_buf);
-				break;
+			init_prng(ctl, ctl_buf);
+			break;
 		case 'S':
 			{
 				process_stats(ctl, ctl_buf);
@@ -957,7 +961,7 @@ mod_process_cmd_recv(mod_ctl_t * ctl)
 		case 'Z':
 			send_nozlib_support(ctl, ctl_buf);
 			break;
-			
+
 #endif
 		default:
 			break;
@@ -973,7 +977,7 @@ mod_process_cmd_recv(mod_ctl_t * ctl)
 
 
 static void
-mod_read_ctl(rb_fde_t * F, void *data)
+mod_read_ctl(rb_fde_t *F, void *data)
 {
 	mod_ctl_buf_t *ctl_buf;
 	mod_ctl_t *ctl = data;
@@ -997,7 +1001,7 @@ mod_read_ctl(rb_fde_t * F, void *data)
 			rb_dlinkAddTail(ctl_buf, &ctl_buf->node, &ctl->readq);
 		}
 	}
-	while (retlen > 0);
+	while(retlen > 0);
 
 	if(retlen == 0 || (retlen < 0 && !rb_ignore_errno(errno)))
 		exit(0);
@@ -1007,7 +1011,7 @@ mod_read_ctl(rb_fde_t * F, void *data)
 }
 
 static void
-mod_write_ctl(rb_fde_t * F, void *data)
+mod_write_ctl(rb_fde_t *F, void *data)
 {
 	mod_ctl_t *ctl = data;
 	mod_ctl_buf_t *ctl_buf;
@@ -1018,29 +1022,29 @@ mod_write_ctl(rb_fde_t * F, void *data)
 	{
 		ctl_buf = ptr->data;
 		retlen = rb_send_fd_buf(ctl->F, ctl_buf->F, ctl_buf->nfds, ctl_buf->buf,
-					ctl_buf->buflen);
+					ctl_buf->buflen, ppid);
 		if(retlen > 0)
 		{
 			rb_dlinkDelete(ptr, &ctl->writeq);
-			for (x = 0; x < ctl_buf->nfds; x++)
+			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);			
-		
+			exit(0);
+
 		rb_setselect(ctl->F, RB_SELECT_WRITE, mod_write_ctl, ctl);
 	}
 }
 
 
 static void
-read_pipe_ctl(rb_fde_t * F, void *data)
+read_pipe_ctl(rb_fde_t *F, void *data)
 {
 	int retlen;
-	while ((retlen = rb_read(F, inbuf, sizeof(inbuf))) > 0)
+	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.. */
 	}
@@ -1053,29 +1057,34 @@ read_pipe_ctl(rb_fde_t * F, void *data)
 int
 main(int argc, char **argv)
 {
-	const char *s_ctlfd, *s_pipe;
+	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)
+	if(s_ctlfd == NULL || s_pipe == NULL || s_pid == NULL)
 	{
-		fprintf(stderr, "This is ircd-ratbox ssld.  You know you aren't supposed to run me directly?\n");
-		fprintf(stderr, "You get an Id tag for this: $Id: ssld.c 25677 2008-07-06 04:21:42Z androsyn $\n");
+		fprintf(stderr,
+			"This is ircd-ratbox ssld.  You know you aren't supposed to run me directly?\n");
+		fprintf(stderr,
+			"You get an Id tag for this: $Id$\n");
 		fprintf(stderr, "Have a nice life\n");
 		exit(1);
 	}
 
 	ctlfd = atoi(s_ctlfd);
 	pipefd = atoi(s_pipe);
-
-	for (x = 0; x < maxfd; x++)
+	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)
 	{
@@ -1088,12 +1097,11 @@ main(int argc, char **argv)
 		if(x > 2)
 			close(x);
 	}
-
+#endif
 	setup_signals();
 	rb_lib_init(NULL, NULL, NULL, 0, maxfd, 1024, 4096);
 	rb_init_rawbuffers(1024);
-	ssl_ok = rb_supports_ssl();		
-
+	ssl_ok = rb_supports_ssl();
 	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");
@@ -1108,7 +1116,7 @@ main(int argc, char **argv)
 		/* this is really useless... */
 		send_i_am_useless(mod_ctl);
 		/* sleep until the ircd kills us */
-		rb_sleep(2<<30, 0);
+		rb_sleep(2 << 30, 0);
 		exit(1);
 	}
 
@@ -1121,16 +1129,18 @@ main(int argc, char **argv)
 }
 
 
-
+#ifndef _WIN32
 static void
 dummy_handler(int sig)
 {
 	return;
 }
+#endif
 
 static void
 setup_signals()
 {
+#ifndef _WIN32
 	struct sigaction act;
 
 	act.sa_flags = 0;
@@ -1153,5 +1163,5 @@ setup_signals()
 
 	act.sa_handler = dummy_handler;
 	sigaction(SIGALRM, &act, 0);
+#endif
 }
-