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