busybox/networking/tcpudp.c

/* Based on ipsvd utilities written by Gerrit Pape <pape@smarden.org>
 * which are released into public domain by the author.
 * Homepage: http://smarden.sunsite.dk/ipsvd/
 *
 * Copyright (C) 2007 Denys Vlasenko.
 *
 * Licensed under GPLv2, see file LICENSE in this tarball for details.
 */

/* Based on ipsvd-0.12.1. This tcpsvd accepts all options
 * which are supported by one from ipsvd-0.12.1, but not all are
 * functional. See help text at the end of this file for details.
 *
 * Code inside "#ifdef SSLSVD" is for sslsvd and is currently unused.
 *
 * Busybox version exports TCPLOCALADDR instead of
 * TCPLOCALIP + TCPLOCALPORT pair. ADDR more closely matches reality
 * (which is "struct sockaddr_XXX". Port is not a separate entity,
 * it's just a part of (AF_INET[6]) sockaddr!).
 *
 * TCPORIGDSTADDR is Busybox-specific addition.
 *
 * udp server is hacked up by reusing TCP code. It has the following
 * limitation inherent in Unix DGRAM sockets implementation:
 * - local IP address is retrieved (using recvmsg voodoo) but
 *   child's socket is not bound to it (bind cannot be called on
 *   already bound socket). Thus it still can emit outgoing packets
 *   with wrong source IP...
 * - don't know how to retrieve ORIGDST for udp.
 */

#include "libbb.h"
/* Wants <limits.h> etc, thus included after libbb.h: */
#include <linux/types.h> /* for __be32 etc */
#include <linux/netfilter_ipv4.h>

// TODO: move into this file:
#include "tcpudp_perhost.h"

#ifdef SSLSVD
#include "matrixSsl.h"
#include "ssl_io.h"
#endif

struct globals {
	unsigned verbose;
	unsigned max_per_host;
	unsigned cur_per_host;
	unsigned cnum;
	unsigned cmax;
	char **env_cur;
	char *env_var[1]; /* actually bigger */
};
#define G (*(struct globals*)&bb_common_bufsiz1)
#define verbose      (G.verbose     )
#define max_per_host (G.max_per_host)
#define cur_per_host (G.cur_per_host)
#define cnum         (G.cnum        )
#define cmax         (G.cmax        )
#define env_cur      (G.env_cur     )
#define env_var      (G.env_var     )
#define INIT_G() do { \
	cmax = 30; \
	env_cur = &env_var[0]; \
} while (0)


/* We have to be careful about leaking memory in repeated setenv's */
static void xsetenv_plain(const char *n, const char *v)
{
	char *var = xasprintf("%s=%s", n, v);
	*env_cur++ = var;
	putenv(var);
}

static void xsetenv_proto(const char *proto, const char *n, const char *v)
{
	char *var = xasprintf("%s%s=%s", proto, n, v);
	*env_cur++ = var;
	putenv(var);
}

static void undo_xsetenv(void)
{
	char **pp = env_cur = &env_var[0];
	while (*pp) {
		char *var = *pp;
		*strchrnul(var, '=') = '\0';
		unsetenv(var);
		free(var);
		*pp++ = NULL;
	}
}

static void sig_term_handler(int sig)
{
	if (verbose)
		bb_error_msg("got signal %u, exit", sig);
	kill_myself_with_sig(sig);
}

/* Little bloated, but tries to give accurate info how child exited.
 * Makes easier to spot segfaulting children etc... */
static void print_waitstat(unsigned pid, int wstat)
{
	unsigned e = 0;
	const char *cause = "?exit";

	if (WIFEXITED(wstat)) {
		cause++;
		e = WEXITSTATUS(wstat);
	} else if (WIFSIGNALED(wstat)) {
		cause = "signal";
		e = WTERMSIG(wstat);
	}
	bb_error_msg("end %d %s %d", pid, cause, e);
}

/* Must match getopt32 in main! */
enum {
	OPT_c = (1 << 0),
	OPT_C = (1 << 1),
	OPT_i = (1 << 2),
	OPT_x = (1 << 3),
	OPT_u = (1 << 4),
	OPT_l = (1 << 5),
	OPT_E = (1 << 6),
	OPT_b = (1 << 7),
	OPT_h = (1 << 8),
	OPT_p = (1 << 9),
	OPT_t = (1 << 10),
	OPT_v = (1 << 11),
	OPT_V = (1 << 12),
	OPT_U = (1 << 13), /* from here: sslsvd only */
	OPT_slash = (1 << 14),
	OPT_Z = (1 << 15),
	OPT_K = (1 << 16),
};

static void connection_status(void)
{
	/* "only 1 client max" desn't need this */
	if (cmax > 1)
		bb_error_msg("status %u/%u", cnum, cmax);
}

static void sig_child_handler(int sig UNUSED_PARAM)
{
	int wstat;
	pid_t pid;

	while ((pid = wait_any_nohang(&wstat)) > 0) {
		if (max_per_host)
			ipsvd_perhost_remove(pid);
		if (cnum)
			cnum--;
		if (verbose)
			print_waitstat(pid, wstat);
	}
	if (verbose)
		connection_status();
}

int tcpudpsvd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int tcpudpsvd_main(int argc UNUSED_PARAM, char **argv)
{
	char *str_C, *str_t;
	char *user;
	struct hcc *hccp;
	const char *instructs;
	char *msg_per_host = NULL;
	unsigned len_per_host = len_per_host; /* gcc */
#ifndef SSLSVD
	struct bb_uidgid_t ugid;
#endif
	bool tcp;
	uint16_t local_port;
	char *preset_local_hostname = NULL;
	char *remote_hostname = remote_hostname; /* for compiler */
	char *remote_addr = remote_addr; /* for compiler */
	len_and_sockaddr *lsa;
	len_and_sockaddr local, remote;
	socklen_t sa_len;
	int pid;
	int sock;
	int conn;
	unsigned backlog = 20;

	INIT_G();

	tcp = (applet_name[0] == 't');

	/* 3+ args, -i at most once, -p implies -h, -v is counter, -b N, -c N */
	opt_complementary = "-3:i--i:ph:vv:b+:c+";
#ifdef SSLSVD
	getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:vU:/:Z:K:",
		&cmax, &str_C, &instructs, &instructs, &user, &preset_local_hostname,
		&backlog, &str_t, &ssluser, &root, &cert, &key, &verbose
	);
#else
	/* "+": stop on first non-option */
	getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:v",
		&cmax, &str_C, &instructs, &instructs, &user, &preset_local_hostname,
		&backlog, &str_t, &verbose
	);
#endif
	if (option_mask32 & OPT_C) { /* -C n[:message] */
		max_per_host = bb_strtou(str_C, &str_C, 10);
		if (str_C[0]) {
			if (str_C[0] != ':')
				bb_show_usage();
			msg_per_host = str_C + 1;
			len_per_host = strlen(msg_per_host);
		}
	}
	if (max_per_host > cmax)
		max_per_host = cmax;
	if (option_mask32 & OPT_u) {
		xget_uidgid(&ugid, user);
	}
#ifdef SSLSVD
	if (option_mask32 & OPT_U) ssluser = optarg;
	if (option_mask32 & OPT_slash) root = optarg;
	if (option_mask32 & OPT_Z) cert = optarg;
	if (option_mask32 & OPT_K) key = optarg;
#endif
	argv += optind;
	if (!argv[0][0] || LONE_CHAR(argv[0], '0'))
		argv[0] = (char*)"0.0.0.0";

	/* Per-IP flood protection is not thought-out for UDP */
	if (!tcp)
		max_per_host = 0;

	bb_sanitize_stdio(); /* fd# 0,1,2 must be opened */

#ifdef SSLSVD
	sslser = user;
	client = 0;
	if ((getuid() == 0) && !(option_mask32 & OPT_u)) {
		xfunc_exitcode = 100;
		bb_error_msg_and_die("-U ssluser must be set when running as root");
	}
	if (option_mask32 & OPT_u)
		if (!uidgid_get(&sslugid, ssluser, 1)) {
			if (errno) {
				bb_perror_msg_and_die("can't get user/group: %s", ssluser);
			}
			bb_error_msg_and_die("unknown user/group %s", ssluser);
		}
	if (!cert) cert = "./cert.pem";
	if (!key) key = cert;
	if (matrixSslOpen() < 0)
		fatal("cannot initialize ssl");
	if (matrixSslReadKeys(&keys, cert, key, 0, ca) < 0) {
		if (client)
			fatal("cannot read cert, key, or ca file");
		fatal("cannot read cert or key file");
	}
	if (matrixSslNewSession(&ssl, keys, 0, SSL_FLAGS_SERVER) < 0)
		fatal("cannot create ssl session");
#endif

	sig_block(SIGCHLD);
	signal(SIGCHLD, sig_child_handler);
	bb_signals(BB_FATAL_SIGS, sig_term_handler);
	signal(SIGPIPE, SIG_IGN);

	if (max_per_host)
		ipsvd_perhost_init(cmax);

	local_port = bb_lookup_port(argv[1], tcp ? "tcp" : "udp", 0);
	lsa = xhost2sockaddr(argv[0], local_port);
	argv += 2;

	sock = xsocket(lsa->u.sa.sa_family, tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
	setsockopt_reuseaddr(sock);
	sa_len = lsa->len; /* I presume sockaddr len stays the same */
	xbind(sock, &lsa->u.sa, sa_len);
	if (tcp)
		xlisten(sock, backlog);
	else /* udp: needed for recv_from_to to work: */
		socket_want_pktinfo(sock);
	/* ndelay_off(sock); - it is the default I think? */

#ifndef SSLSVD
	if (option_mask32 & OPT_u) {
		/* drop permissions */
		xsetgid(ugid.gid);
		xsetuid(ugid.uid);
	}
#endif

	if (verbose) {
		char *addr = xmalloc_sockaddr2dotted(&lsa->u.sa);
		bb_error_msg("listening on %s, starting", addr);
		free(addr);
#ifndef SSLSVD
		if (option_mask32 & OPT_u)
			printf(", uid %u, gid %u",
				(unsigned)ugid.uid, (unsigned)ugid.gid);
#endif
	}

	/* Main accept() loop */

 again:
	hccp = NULL;

	while (cnum >= cmax)
		wait_for_any_sig(); /* expecting SIGCHLD */

	/* Accept a connection to fd #0 */
 again1:
	close(0);
 again2:
	sig_unblock(SIGCHLD);
	local.len = remote.len = sa_len;
	if (tcp) {
		conn = accept(sock, &remote.u.sa, &remote.len);
	} else {
		/* In case recv_from_to won't be able to recover local addr.
		 * Also sets port - recv_from_to is unable to do it. */
		local = *lsa;
		conn = recv_from_to(sock, NULL, 0, MSG_PEEK,
				&remote.u.sa, &local.u.sa, sa_len);
	}
	sig_block(SIGCHLD);
	if (conn < 0) {
		if (errno != EINTR)
			bb_perror_msg(tcp ? "accept" : "recv");
		goto again2;
	}
	xmove_fd(tcp ? conn : sock, 0);

	if (max_per_host) {
		/* Drop connection immediately if cur_per_host > max_per_host
		 * (minimizing load under SYN flood) */
		remote_addr = xmalloc_sockaddr2dotted_noport(&remote.u.sa);
		cur_per_host = ipsvd_perhost_add(remote_addr, max_per_host, &hccp);
		if (cur_per_host > max_per_host) {
			/* ipsvd_perhost_add detected that max is exceeded
			 * (and did not store ip in connection table) */
			free(remote_addr);
			if (msg_per_host) {
				/* don't block or test for errors */
				send(0, msg_per_host, len_per_host, MSG_DONTWAIT);
			}
			goto again1;
		}
		/* NB: remote_addr is not leaked, it is stored in conn table */
	}

	if (!tcp) {
		/* Voodoo magic: making udp sockets each receive its own
		 * packets is not trivial, and I still not sure
		 * I do it 100% right.
		 * 1) we have to do it before fork()
		 * 2) order is important - is it right now? */

		/* Open new non-connected UDP socket for further clients... */
		sock = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
		setsockopt_reuseaddr(sock);
		/* Make plain write/send work for old socket by supplying default
		 * destination address. This also restricts incoming packets
		 * to ones coming from this remote IP. */
		xconnect(0, &remote.u.sa, sa_len);
	/* hole? at this point we have no wildcard udp socket...
	 * can this cause clients to get "port unreachable" icmp?
	 * Yup, time window is very small, but it exists (is it?) */
		/* ..."open new socket", continued */
		xbind(sock, &lsa->u.sa, sa_len);
		socket_want_pktinfo(sock);

		/* Doesn't work:
		 * we cannot replace fd #0 - we will lose pending packet
		 * which is already buffered for us! And we cannot use fd #1
		 * instead - it will "intercept" all following packets, but child
		 * does not expect data coming *from fd #1*! */
#if 0
		/* Make it so that local addr is fixed to localp->u.sa
		 * and we don't accidentally accept packets to other local IPs. */
		/* NB: we possibly bind to the _very_ same_ address & port as the one
		 * already bound in parent! This seems to work in Linux.
		 * (otherwise we can move socket to fd #0 only if bind succeeds) */
		close(0);
		set_nport(localp, htons(local_port));
		xmove_fd(xsocket(localp->u.sa.sa_family, SOCK_DGRAM, 0), 0);
		setsockopt_reuseaddr(0); /* crucial */
		xbind(0, &localp->u.sa, localp->len);
#endif
	}

	pid = vfork();
	if (pid == -1) {
		bb_perror_msg("vfork");
		goto again;
	}

	if (pid != 0) {
		/* Parent */
		cnum++;
		if (verbose)
			connection_status();
		if (hccp)
			hccp->pid = pid;
		/* clean up changes done by vforked child */
		undo_xsetenv();
		goto again;
	}

	/* Child: prepare env, log, and exec prog */

	/* Closing tcp listening socket */
	if (tcp)
		close(sock);

	{ /* vfork alert! every xmalloc in this block should be freed! */
		char *local_hostname = local_hostname; /* for compiler */
		char *local_addr = NULL;
		char *free_me0 = NULL;
		char *free_me1 = NULL;
		char *free_me2 = NULL;

		if (verbose || !(option_mask32 & OPT_E)) {
			if (!max_per_host) /* remote_addr is not yet known */
				free_me0 = remote_addr = xmalloc_sockaddr2dotted(&remote.u.sa);
			if (option_mask32 & OPT_h) {
				free_me1 = remote_hostname = xmalloc_sockaddr2host_noport(&remote.u.sa);
				if (!remote_hostname) {
					bb_error_msg("cannot look up hostname for %s", remote_addr);
					remote_hostname = remote_addr;
				}
			}
			/* Find out local IP peer connected to.
			 * Errors ignored (I'm not paranoid enough to imagine kernel
			 * which doesn't know local IP). */
			if (tcp)
				getsockname(0, &local.u.sa, &local.len);
			/* else: for UDP it is done earlier by parent */
			local_addr = xmalloc_sockaddr2dotted(&local.u.sa);
			if (option_mask32 & OPT_h) {
				local_hostname = preset_local_hostname;
				if (!local_hostname) {
					free_me2 = local_hostname = xmalloc_sockaddr2host_noport(&local.u.sa);
					if (!local_hostname)
						bb_error_msg_and_die("cannot look up hostname for %s", local_addr);
				}
				/* else: local_hostname is not NULL, but is NOT malloced! */
			}
		}
		if (verbose) {
			pid = getpid();
			if (max_per_host) {
				bb_error_msg("concurrency %s %u/%u",
					remote_addr,
					cur_per_host, max_per_host);
			}
			bb_error_msg((option_mask32 & OPT_h)
				? "start %u %s-%s (%s-%s)"
				: "start %u %s-%s",
				pid,
				local_addr, remote_addr,
				local_hostname, remote_hostname);
		}

		if (!(option_mask32 & OPT_E)) {
			/* setup ucspi env */
			const char *proto = tcp ? "TCP" : "UDP";

			/* Extract "original" destination addr:port
			 * from Linux firewall. Useful when you redirect
			 * an outbond connection to local handler, and it needs
			 * to know where it originally tried to connect */
			if (tcp && getsockopt(0, SOL_IP, SO_ORIGINAL_DST, &local.u.sa, &local.len) == 0) {
				char *addr = xmalloc_sockaddr2dotted(&local.u.sa);
				xsetenv_plain("TCPORIGDSTADDR", addr);
				free(addr);
			}
			xsetenv_plain("PROTO", proto);
			xsetenv_proto(proto, "LOCALADDR", local_addr);
			xsetenv_proto(proto, "REMOTEADDR", remote_addr);
			if (option_mask32 & OPT_h) {
				xsetenv_proto(proto, "LOCALHOST", local_hostname);
				xsetenv_proto(proto, "REMOTEHOST", remote_hostname);
			}
			//compat? xsetenv_proto(proto, "REMOTEINFO", "");
			/* additional */
			if (cur_per_host > 0) /* can not be true for udp */
				xsetenv_plain("TCPCONCURRENCY", utoa(cur_per_host));
		}
		free(local_addr);
		free(free_me0);
		free(free_me1);
		free(free_me2);
	}

	xdup2(0, 1);

	signal(SIGPIPE, SIG_DFL); /* this one was SIG_IGNed */
	/* Non-ignored signals revert to SIG_DFL on exec anyway */
	/*signal(SIGCHLD, SIG_DFL);*/
	sig_unblock(SIGCHLD);

#ifdef SSLSVD
	strcpy(id, utoa(pid));
	ssl_io(0, argv);
#else
	BB_EXECVP(argv[0], argv);
#endif
	bb_perror_msg_and_die("exec '%s'", argv[0]);
}

/*
tcpsvd [-hpEvv] [-c n] [-C n:msg] [-b n] [-u user] [-l name]
	[-i dir|-x cdb] [ -t sec] host port prog

tcpsvd creates a TCP/IP socket, binds it to the address host:port,
and listens on the socket for incoming connections.

On each incoming connection, tcpsvd conditionally runs a program,
with standard input reading from the socket, and standard output
writing to the socket, to handle this connection. tcpsvd keeps
listening on the socket for new connections, and can handle
multiple connections simultaneously.

tcpsvd optionally checks for special instructions depending
on the IP address or hostname of the client that initiated
the connection, see ipsvd-instruct(5).

host
    host either is a hostname, or a dotted-decimal IP address,
    or 0. If host is 0, tcpsvd accepts connections to any local
    IP address.
    * busybox accepts IPv6 addresses and host:port pairs too
      In this case second parameter is ignored
port
    tcpsvd accepts connections to host:port. port may be a name
    from /etc/services or a number.
prog
    prog consists of one or more arguments. For each connection,
    tcpsvd normally runs prog, with file descriptor 0 reading from
    the network, and file descriptor 1 writing to the network.
    By default it also sets up TCP-related environment variables,
    see tcp-environ(5)
-i dir
    read instructions for handling new connections from the instructions
    directory dir. See ipsvd-instruct(5) for details.
    * ignored by busyboxed version
-x cdb
    read instructions for handling new connections from the constant database
    cdb. The constant database normally is created from an instructions
    directory by running ipsvd-cdb(8).
    * ignored by busyboxed version
-t sec
    timeout. This option only takes effect if the -i option is given.
    While checking the instructions directory, check the time of last access
    of the file that matches the clients address or hostname if any, discard
    and remove the file if it wasn't accessed within the last sec seconds;
    tcpsvd does not discard or remove a file if the user's write permission
    is not set, for those files the timeout is disabled. Default is 0,
    which means that the timeout is disabled.
    * ignored by busyboxed version
-l name
    local hostname. Do not look up the local hostname in DNS, but use name
    as hostname. This option must be set if tcpsvd listens on port 53
    to avoid loops.
-u user[:group]
    drop permissions. Switch user ID to user's UID, and group ID to user's
    primary GID after creating and binding to the socket. If user is followed
    by a colon and a group name, the group ID is switched to the GID of group
    instead. All supplementary groups are removed.
-c n
    concurrency. Handle up to n connections simultaneously. Default is 30.
    If there are n connections active, tcpsvd defers acceptance of a new
    connection until an active connection is closed.
-C n[:msg]
    per host concurrency. Allow only up to n connections from the same IP
    address simultaneously. If there are n active connections from one IP
    address, new incoming connections from this IP address are closed
    immediately. If n is followed by :msg, the message msg is written
    to the client if possible, before closing the connection. By default
    msg is empty. See ipsvd-instruct(5) for supported escape sequences in msg.

    For each accepted connection, the current per host concurrency is
    available through the environment variable TCPCONCURRENCY. n and msg
    can be overwritten by ipsvd(7) instructions, see ipsvd-instruct(5).
    By default tcpsvd doesn't keep track of connections.
-h
    Look up the client's hostname in DNS.
-p
    paranoid. After looking up the client's hostname in DNS, look up the IP
    addresses in DNS for that hostname, and forget about the hostname
    if none of the addresses match the client's IP address. You should
    set this option if you use hostname based instructions. The -p option
    implies the -h option.
    * ignored by busyboxed version
-b n
    backlog. Allow a backlog of approximately n TCP SYNs. On some systems n
    is silently limited. Default is 20.
-E
    no special environment. Do not set up TCP-related environment variables.
-v
    verbose. Print verbose messsages to standard output.
-vv
    more verbose. Print more verbose messages to standard output.
    * no difference between -v and -vv in busyboxed version
*/
1	niro	816	/* Based on ipsvd utilities written by Gerrit Pape <pape@smarden.org>
2			* which are released into public domain by the author.
3			* Homepage: http://smarden.sunsite.dk/ipsvd/
4			*
5			* Copyright (C) 2007 Denys Vlasenko.
6			*
7			* Licensed under GPLv2, see file LICENSE in this tarball for details.
8			*/
9
10			/* Based on ipsvd-0.12.1. This tcpsvd accepts all options
11			* which are supported by one from ipsvd-0.12.1, but not all are
12			* functional. See help text at the end of this file for details.
13			*
14			* Code inside "#ifdef SSLSVD" is for sslsvd and is currently unused.
15			*
16			* Busybox version exports TCPLOCALADDR instead of
17			* TCPLOCALIP + TCPLOCALPORT pair. ADDR more closely matches reality
18			* (which is "struct sockaddr_XXX". Port is not a separate entity,
19			* it's just a part of (AF_INET[6]) sockaddr!).
20			*
21			* TCPORIGDSTADDR is Busybox-specific addition.
22			*
23			* udp server is hacked up by reusing TCP code. It has the following
24			* limitation inherent in Unix DGRAM sockets implementation:
25			* - local IP address is retrieved (using recvmsg voodoo) but
26			* child's socket is not bound to it (bind cannot be called on
27			* already bound socket). Thus it still can emit outgoing packets
28			* with wrong source IP...
29			* - don't know how to retrieve ORIGDST for udp.
30			*/
31
32			#include "libbb.h"
33			/* Wants <limits.h> etc, thus included after libbb.h: */
34			#include <linux/types.h> /* for __be32 etc */
35			#include <linux/netfilter_ipv4.h>
36
37			// TODO: move into this file:
38			#include "tcpudp_perhost.h"
39
40			#ifdef SSLSVD
41			#include "matrixSsl.h"
42			#include "ssl_io.h"
43			#endif
44
45			struct globals {
46			unsigned verbose;
47			unsigned max_per_host;
48			unsigned cur_per_host;
49			unsigned cnum;
50			unsigned cmax;
51			char **env_cur;
52			char env_var[1]; / actually bigger */
53			};
54			#define G ((struct globals)&bb_common_bufsiz1)
55			#define verbose (G.verbose )
56			#define max_per_host (G.max_per_host)
57			#define cur_per_host (G.cur_per_host)
58			#define cnum (G.cnum )
59			#define cmax (G.cmax )
60			#define env_cur (G.env_cur )
61			#define env_var (G.env_var )
62			#define INIT_G() do { \
63			cmax = 30; \
64			env_cur = &env_var[0]; \
65			} while (0)
66
67
68			/* We have to be careful about leaking memory in repeated setenv's */
69			static void xsetenv_plain(const char n, const char v)
70			{
71			char *var = xasprintf("%s=%s", n, v);
72			*env_cur++ = var;
73			putenv(var);
74			}
75
76			static void xsetenv_proto(const char proto, const char n, const char *v)
77			{
78			char *var = xasprintf("%s%s=%s", proto, n, v);
79			*env_cur++ = var;
80			putenv(var);
81			}
82
83			static void undo_xsetenv(void)
84			{
85			char **pp = env_cur = &env_var[0];
86			while (*pp) {
87			char var = pp;
88			*strchrnul(var, '=') = '\0';
89			unsetenv(var);
90			free(var);
91			*pp++ = NULL;
92			}
93			}
94
95			static void sig_term_handler(int sig)
96			{
97			if (verbose)
98			bb_error_msg("got signal %u, exit", sig);
99			kill_myself_with_sig(sig);
100			}
101
102			/* Little bloated, but tries to give accurate info how child exited.
103			* Makes easier to spot segfaulting children etc... */
104			static void print_waitstat(unsigned pid, int wstat)
105			{
106			unsigned e = 0;
107			const char *cause = "?exit";
108
109			if (WIFEXITED(wstat)) {
110			cause++;
111			e = WEXITSTATUS(wstat);
112			} else if (WIFSIGNALED(wstat)) {
113			cause = "signal";
114			e = WTERMSIG(wstat);
115			}
116			bb_error_msg("end %d %s %d", pid, cause, e);
117			}
118
119			/* Must match getopt32 in main! */
120			enum {
121			OPT_c = (1 << 0),
122			OPT_C = (1 << 1),
123			OPT_i = (1 << 2),
124			OPT_x = (1 << 3),
125			OPT_u = (1 << 4),
126			OPT_l = (1 << 5),
127			OPT_E = (1 << 6),
128			OPT_b = (1 << 7),
129			OPT_h = (1 << 8),
130			OPT_p = (1 << 9),
131			OPT_t = (1 << 10),
132			OPT_v = (1 << 11),
133			OPT_V = (1 << 12),
134			OPT_U = (1 << 13), /* from here: sslsvd only */
135			OPT_slash = (1 << 14),
136			OPT_Z = (1 << 15),
137			OPT_K = (1 << 16),
138			};
139
140			static void connection_status(void)
141			{
142			/* "only 1 client max" desn't need this */
143			if (cmax > 1)
144			bb_error_msg("status %u/%u", cnum, cmax);
145			}
146
147			static void sig_child_handler(int sig UNUSED_PARAM)
148			{
149			int wstat;
150			pid_t pid;
151
152			while ((pid = wait_any_nohang(&wstat)) > 0) {
153			if (max_per_host)
154			ipsvd_perhost_remove(pid);
155			if (cnum)
156			cnum--;
157			if (verbose)
158			print_waitstat(pid, wstat);
159			}
160			if (verbose)
161			connection_status();
162			}
163
164			int tcpudpsvd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
165			int tcpudpsvd_main(int argc UNUSED_PARAM, char **argv)
166			{
167			char str_C, str_t;
168			char *user;
169			struct hcc *hccp;
170			const char *instructs;
171			char *msg_per_host = NULL;
172			unsigned len_per_host = len_per_host; /* gcc */
173			#ifndef SSLSVD
174			struct bb_uidgid_t ugid;
175			#endif
176			bool tcp;
177			uint16_t local_port;
178			char *preset_local_hostname = NULL;
179			char remote_hostname = remote_hostname; / for compiler */
180			char remote_addr = remote_addr; / for compiler */
181			len_and_sockaddr *lsa;
182			len_and_sockaddr local, remote;
183			socklen_t sa_len;
184			int pid;
185			int sock;
186			int conn;
187			unsigned backlog = 20;
188
189			INIT_G();
190
191			tcp = (applet_name[0] == 't');
192
193			/* 3+ args, -i at most once, -p implies -h, -v is counter, -b N, -c N */
194			opt_complementary = "-3:i--i:ph:vv:b+:c+";
195			#ifdef SSLSVD
196			getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:vU:/:Z:K:",
197			&cmax, &str_C, &instructs, &instructs, &user, &preset_local_hostname,
198			&backlog, &str_t, &ssluser, &root, &cert, &key, &verbose
199			);
200			#else
201			/* "+": stop on first non-option */
202			getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:v",
203			&cmax, &str_C, &instructs, &instructs, &user, &preset_local_hostname,
204			&backlog, &str_t, &verbose
205			);
206			#endif
207			if (option_mask32 & OPT_C) { /* -C n[:message] */
208			max_per_host = bb_strtou(str_C, &str_C, 10);
209			if (str_C[0]) {
210			if (str_C[0] != ':')
211			bb_show_usage();
212			msg_per_host = str_C + 1;
213			len_per_host = strlen(msg_per_host);
214			}
215			}
216			if (max_per_host > cmax)
217			max_per_host = cmax;
218			if (option_mask32 & OPT_u) {
219			xget_uidgid(&ugid, user);
220			}
221			#ifdef SSLSVD
222			if (option_mask32 & OPT_U) ssluser = optarg;
223			if (option_mask32 & OPT_slash) root = optarg;
224			if (option_mask32 & OPT_Z) cert = optarg;
225			if (option_mask32 & OPT_K) key = optarg;
226			#endif
227			argv += optind;
228			if (!argv[0][0] \|\| LONE_CHAR(argv[0], '0'))
229			argv[0] = (char*)"0.0.0.0";
230
231			/* Per-IP flood protection is not thought-out for UDP */
232			if (!tcp)
233			max_per_host = 0;
234
235			bb_sanitize_stdio(); /* fd# 0,1,2 must be opened */
236
237			#ifdef SSLSVD
238			sslser = user;
239			client = 0;
240			if ((getuid() == 0) && !(option_mask32 & OPT_u)) {
241			xfunc_exitcode = 100;
242			bb_error_msg_and_die("-U ssluser must be set when running as root");
243			}
244			if (option_mask32 & OPT_u)
245			if (!uidgid_get(&sslugid, ssluser, 1)) {
246			if (errno) {
247			bb_perror_msg_and_die("can't get user/group: %s", ssluser);
248			}
249			bb_error_msg_and_die("unknown user/group %s", ssluser);
250			}
251			if (!cert) cert = "./cert.pem";
252			if (!key) key = cert;
253			if (matrixSslOpen() < 0)
254			fatal("cannot initialize ssl");
255			if (matrixSslReadKeys(&keys, cert, key, 0, ca) < 0) {
256			if (client)
257			fatal("cannot read cert, key, or ca file");
258			fatal("cannot read cert or key file");
259			}
260			if (matrixSslNewSession(&ssl, keys, 0, SSL_FLAGS_SERVER) < 0)
261			fatal("cannot create ssl session");
262			#endif
263
264			sig_block(SIGCHLD);
265			signal(SIGCHLD, sig_child_handler);
266			bb_signals(BB_FATAL_SIGS, sig_term_handler);
267			signal(SIGPIPE, SIG_IGN);
268
269			if (max_per_host)
270			ipsvd_perhost_init(cmax);
271
272			local_port = bb_lookup_port(argv[1], tcp ? "tcp" : "udp", 0);
273			lsa = xhost2sockaddr(argv[0], local_port);
274			argv += 2;
275
276			sock = xsocket(lsa->u.sa.sa_family, tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
277			setsockopt_reuseaddr(sock);
278			sa_len = lsa->len; /* I presume sockaddr len stays the same */
279			xbind(sock, &lsa->u.sa, sa_len);
280			if (tcp)
281			xlisten(sock, backlog);
282			else /* udp: needed for recv_from_to to work: */
283			socket_want_pktinfo(sock);
284			/* ndelay_off(sock); - it is the default I think? */
285
286			#ifndef SSLSVD
287			if (option_mask32 & OPT_u) {
288			/* drop permissions */
289			xsetgid(ugid.gid);
290			xsetuid(ugid.uid);
291			}
292			#endif
293
294			if (verbose) {
295			char *addr = xmalloc_sockaddr2dotted(&lsa->u.sa);
296			bb_error_msg("listening on %s, starting", addr);
297			free(addr);
298			#ifndef SSLSVD
299			if (option_mask32 & OPT_u)
300			printf(", uid %u, gid %u",
301			(unsigned)ugid.uid, (unsigned)ugid.gid);
302			#endif
303			}
304
305			/* Main accept() loop */
306
307			again:
308			hccp = NULL;
309
310			while (cnum >= cmax)
311			wait_for_any_sig(); /* expecting SIGCHLD */
312
313			/* Accept a connection to fd #0 */
314			again1:
315			close(0);
316			again2:
317			sig_unblock(SIGCHLD);
318			local.len = remote.len = sa_len;
319			if (tcp) {
320			conn = accept(sock, &remote.u.sa, &remote.len);
321			} else {
322			/* In case recv_from_to won't be able to recover local addr.
323			* Also sets port - recv_from_to is unable to do it. */
324			local = *lsa;
325			conn = recv_from_to(sock, NULL, 0, MSG_PEEK,
326			&remote.u.sa, &local.u.sa, sa_len);
327			}
328			sig_block(SIGCHLD);
329			if (conn < 0) {
330			if (errno != EINTR)
331			bb_perror_msg(tcp ? "accept" : "recv");
332			goto again2;
333			}
334			xmove_fd(tcp ? conn : sock, 0);
335
336			if (max_per_host) {
337			/* Drop connection immediately if cur_per_host > max_per_host
338			* (minimizing load under SYN flood) */
339			remote_addr = xmalloc_sockaddr2dotted_noport(&remote.u.sa);
340			cur_per_host = ipsvd_perhost_add(remote_addr, max_per_host, &hccp);
341			if (cur_per_host > max_per_host) {
342			/* ipsvd_perhost_add detected that max is exceeded
343			* (and did not store ip in connection table) */
344			free(remote_addr);
345			if (msg_per_host) {
346			/* don't block or test for errors */
347			send(0, msg_per_host, len_per_host, MSG_DONTWAIT);
348			}
349			goto again1;
350			}
351			/* NB: remote_addr is not leaked, it is stored in conn table */
352			}
353
354			if (!tcp) {
355			/* Voodoo magic: making udp sockets each receive its own
356			* packets is not trivial, and I still not sure
357			* I do it 100% right.
358			* 1) we have to do it before fork()
359			* 2) order is important - is it right now? */
360
361			/* Open new non-connected UDP socket for further clients... */
362			sock = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
363			setsockopt_reuseaddr(sock);
364			/* Make plain write/send work for old socket by supplying default
365			* destination address. This also restricts incoming packets
366			* to ones coming from this remote IP. */
367			xconnect(0, &remote.u.sa, sa_len);
368			/* hole? at this point we have no wildcard udp socket...
369			* can this cause clients to get "port unreachable" icmp?
370			* Yup, time window is very small, but it exists (is it?) */
371			/* ..."open new socket", continued */
372			xbind(sock, &lsa->u.sa, sa_len);
373			socket_want_pktinfo(sock);
374
375			/* Doesn't work:
376			* we cannot replace fd #0 - we will lose pending packet
377			* which is already buffered for us! And we cannot use fd #1
378			* instead - it will "intercept" all following packets, but child
379			* does not expect data coming from fd #1! */
380			#if 0
381			/* Make it so that local addr is fixed to localp->u.sa
382			* and we don't accidentally accept packets to other local IPs. */
383			/* NB: we possibly bind to the _very_ same_ address & port as the one
384			* already bound in parent! This seems to work in Linux.
385			* (otherwise we can move socket to fd #0 only if bind succeeds) */
386			close(0);
387			set_nport(localp, htons(local_port));
388			xmove_fd(xsocket(localp->u.sa.sa_family, SOCK_DGRAM, 0), 0);
389			setsockopt_reuseaddr(0); /* crucial */
390			xbind(0, &localp->u.sa, localp->len);
391			#endif
392			}
393
394			pid = vfork();
395			if (pid == -1) {
396			bb_perror_msg("vfork");
397			goto again;
398			}
399
400			if (pid != 0) {
401			/* Parent */
402			cnum++;
403			if (verbose)
404			connection_status();
405			if (hccp)
406			hccp->pid = pid;
407			/* clean up changes done by vforked child */
408			undo_xsetenv();
409			goto again;
410			}
411
412			/* Child: prepare env, log, and exec prog */
413
414			/* Closing tcp listening socket */
415			if (tcp)
416			close(sock);
417
418			{ /* vfork alert! every xmalloc in this block should be freed! */
419			char local_hostname = local_hostname; / for compiler */
420			char *local_addr = NULL;
421			char *free_me0 = NULL;
422			char *free_me1 = NULL;
423			char *free_me2 = NULL;
424
425			if (verbose \|\| !(option_mask32 & OPT_E)) {
426			if (!max_per_host) /* remote_addr is not yet known */
427			free_me0 = remote_addr = xmalloc_sockaddr2dotted(&remote.u.sa);
428			if (option_mask32 & OPT_h) {
429			free_me1 = remote_hostname = xmalloc_sockaddr2host_noport(&remote.u.sa);
430			if (!remote_hostname) {
431			bb_error_msg("cannot look up hostname for %s", remote_addr);
432			remote_hostname = remote_addr;
433			}
434			}
435			/* Find out local IP peer connected to.
436			* Errors ignored (I'm not paranoid enough to imagine kernel
437			* which doesn't know local IP). */
438			if (tcp)
439			getsockname(0, &local.u.sa, &local.len);
440			/* else: for UDP it is done earlier by parent */
441			local_addr = xmalloc_sockaddr2dotted(&local.u.sa);
442			if (option_mask32 & OPT_h) {
443			local_hostname = preset_local_hostname;
444			if (!local_hostname) {
445			free_me2 = local_hostname = xmalloc_sockaddr2host_noport(&local.u.sa);
446			if (!local_hostname)
447			bb_error_msg_and_die("cannot look up hostname for %s", local_addr);
448			}
449			/* else: local_hostname is not NULL, but is NOT malloced! */
450			}
451			}
452			if (verbose) {
453			pid = getpid();
454			if (max_per_host) {
455			bb_error_msg("concurrency %s %u/%u",
456			remote_addr,
457			cur_per_host, max_per_host);
458			}
459			bb_error_msg((option_mask32 & OPT_h)
460			? "start %u %s-%s (%s-%s)"
461			: "start %u %s-%s",
462			pid,
463			local_addr, remote_addr,
464			local_hostname, remote_hostname);
465			}
466
467			if (!(option_mask32 & OPT_E)) {
468			/* setup ucspi env */
469			const char *proto = tcp ? "TCP" : "UDP";
470
471			/* Extract "original" destination addr:port
472			* from Linux firewall. Useful when you redirect
473			* an outbond connection to local handler, and it needs
474			* to know where it originally tried to connect */
475			if (tcp && getsockopt(0, SOL_IP, SO_ORIGINAL_DST, &local.u.sa, &local.len) == 0) {
476			char *addr = xmalloc_sockaddr2dotted(&local.u.sa);
477			xsetenv_plain("TCPORIGDSTADDR", addr);
478			free(addr);
479			}
480			xsetenv_plain("PROTO", proto);
481			xsetenv_proto(proto, "LOCALADDR", local_addr);
482			xsetenv_proto(proto, "REMOTEADDR", remote_addr);
483			if (option_mask32 & OPT_h) {
484			xsetenv_proto(proto, "LOCALHOST", local_hostname);
485			xsetenv_proto(proto, "REMOTEHOST", remote_hostname);
486			}
487			//compat? xsetenv_proto(proto, "REMOTEINFO", "");
488			/* additional */
489			if (cur_per_host > 0) /* can not be true for udp */
490			xsetenv_plain("TCPCONCURRENCY", utoa(cur_per_host));
491			}
492			free(local_addr);
493			free(free_me0);
494			free(free_me1);
495			free(free_me2);
496			}
497
498			xdup2(0, 1);
499
500			signal(SIGPIPE, SIG_DFL); /* this one was SIG_IGNed */
501			/* Non-ignored signals revert to SIG_DFL on exec anyway */
502			/signal(SIGCHLD, SIG_DFL);/
503			sig_unblock(SIGCHLD);
504
505			#ifdef SSLSVD
506			strcpy(id, utoa(pid));
507			ssl_io(0, argv);
508			#else
509			BB_EXECVP(argv[0], argv);
510			#endif
511			bb_perror_msg_and_die("exec '%s'", argv[0]);
512			}
513
514			/*
515			tcpsvd [-hpEvv] [-c n] [-C n:msg] [-b n] [-u user] [-l name]
516			[-i dir\|-x cdb] [ -t sec] host port prog
517
518			tcpsvd creates a TCP/IP socket, binds it to the address host:port,
519			and listens on the socket for incoming connections.
520
521			On each incoming connection, tcpsvd conditionally runs a program,
522			with standard input reading from the socket, and standard output
523			writing to the socket, to handle this connection. tcpsvd keeps
524			listening on the socket for new connections, and can handle
525			multiple connections simultaneously.
526
527			tcpsvd optionally checks for special instructions depending
528			on the IP address or hostname of the client that initiated
529			the connection, see ipsvd-instruct(5).
530
531			host
532			host either is a hostname, or a dotted-decimal IP address,
533			or 0. If host is 0, tcpsvd accepts connections to any local
534			IP address.
535			* busybox accepts IPv6 addresses and host:port pairs too
536			In this case second parameter is ignored
537			port
538			tcpsvd accepts connections to host:port. port may be a name
539			from /etc/services or a number.
540			prog
541			prog consists of one or more arguments. For each connection,
542			tcpsvd normally runs prog, with file descriptor 0 reading from
543			the network, and file descriptor 1 writing to the network.
544			By default it also sets up TCP-related environment variables,
545			see tcp-environ(5)
546			-i dir
547			read instructions for handling new connections from the instructions
548			directory dir. See ipsvd-instruct(5) for details.
549			* ignored by busyboxed version
550			-x cdb
551			read instructions for handling new connections from the constant database
552			cdb. The constant database normally is created from an instructions
553			directory by running ipsvd-cdb(8).
554			* ignored by busyboxed version
555			-t sec
556			timeout. This option only takes effect if the -i option is given.
557			While checking the instructions directory, check the time of last access
558			of the file that matches the clients address or hostname if any, discard
559			and remove the file if it wasn't accessed within the last sec seconds;
560			tcpsvd does not discard or remove a file if the user's write permission
561			is not set, for those files the timeout is disabled. Default is 0,
562			which means that the timeout is disabled.
563			* ignored by busyboxed version
564			-l name
565			local hostname. Do not look up the local hostname in DNS, but use name
566			as hostname. This option must be set if tcpsvd listens on port 53
567			to avoid loops.
568			-u user[:group]
569			drop permissions. Switch user ID to user's UID, and group ID to user's
570			primary GID after creating and binding to the socket. If user is followed
571			by a colon and a group name, the group ID is switched to the GID of group
572			instead. All supplementary groups are removed.
573			-c n
574			concurrency. Handle up to n connections simultaneously. Default is 30.
575			If there are n connections active, tcpsvd defers acceptance of a new
576			connection until an active connection is closed.
577			-C n[:msg]
578			per host concurrency. Allow only up to n connections from the same IP
579			address simultaneously. If there are n active connections from one IP
580			address, new incoming connections from this IP address are closed
581			immediately. If n is followed by :msg, the message msg is written
582			to the client if possible, before closing the connection. By default
583			msg is empty. See ipsvd-instruct(5) for supported escape sequences in msg.
584
585			For each accepted connection, the current per host concurrency is
586			available through the environment variable TCPCONCURRENCY. n and msg
587			can be overwritten by ipsvd(7) instructions, see ipsvd-instruct(5).
588			By default tcpsvd doesn't keep track of connections.
589			-h
590			Look up the client's hostname in DNS.
591			-p
592			paranoid. After looking up the client's hostname in DNS, look up the IP
593			addresses in DNS for that hostname, and forget about the hostname
594			if none of the addresses match the client's IP address. You should
595			set this option if you use hostname based instructions. The -p option
596			implies the -h option.
597			* ignored by busyboxed version
598			-b n
599			backlog. Allow a backlog of approximately n TCP SYNs. On some systems n
600			is silently limited. Default is 20.
601			-E
602			no special environment. Do not set up TCP-related environment variables.
603			-v
604			verbose. Print verbose messsages to standard output.
605			-vv
606			more verbose. Print more verbose messages to standard output.
607			* no difference between -v and -vv in busyboxed version
608			*/