networking/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 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 } FIX_ALIASING;
  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                 bb_unsetenv_and_free(var);
  89                 *pp++ = NULL;
  90         }
  91 }
  92
  93 static void sig_term_handler(int sig)
  94 {
  95         if (verbose)
  96                 bb_error_msg("got signal %u, exit", sig);
  97         kill_myself_with_sig(sig);
  98 }
  99
 100 /* Little bloated, but tries to give accurate info how child exited.
 101  * Makes easier to spot segfaulting children etc... */
 102 static void print_waitstat(unsigned pid, int wstat)
 103 {
 104         unsigned e = 0;
 105         const char *cause = "?exit";
 106
 107         if (WIFEXITED(wstat)) {
 108                 cause++;
 109                 e = WEXITSTATUS(wstat);
 110         } else if (WIFSIGNALED(wstat)) {
 111                 cause = "signal";
 112                 e = WTERMSIG(wstat);
 113         }
 114         bb_error_msg("end %d %s %d", pid, cause, e);
 115 }
 116
 117 /* Must match getopt32 in main! */
 118 enum {
 119         OPT_c = (1 << 0),
 120         OPT_C = (1 << 1),
 121         OPT_i = (1 << 2),
 122         OPT_x = (1 << 3),
 123         OPT_u = (1 << 4),
 124         OPT_l = (1 << 5),
 125         OPT_E = (1 << 6),
 126         OPT_b = (1 << 7),
 127         OPT_h = (1 << 8),
 128         OPT_p = (1 << 9),
 129         OPT_t = (1 << 10),
 130         OPT_v = (1 << 11),
 131         OPT_V = (1 << 12),
 132         OPT_U = (1 << 13), /* from here: sslsvd only */
 133         OPT_slash = (1 << 14),
 134         OPT_Z = (1 << 15),
 135         OPT_K = (1 << 16),
 136 };
 137
 138 static void connection_status(void)
 139 {
 140         /* "only 1 client max" desn't need this */
 141         if (cmax > 1)
 142                 bb_error_msg("status %u/%u", cnum, cmax);
 143 }
 144
 145 static void sig_child_handler(int sig UNUSED_PARAM)
 146 {
 147         int wstat;
 148         pid_t pid;
 149
 150         while ((pid = wait_any_nohang(&wstat)) > 0) {
 151                 if (max_per_host)
 152                         ipsvd_perhost_remove(pid);
 153                 if (cnum)
 154                         cnum--;
 155                 if (verbose)
 156                         print_waitstat(pid, wstat);
 157         }
 158         if (verbose)
 159                 connection_status();
 160 }
 161
 162 int tcpudpsvd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 163 int tcpudpsvd_main(int argc UNUSED_PARAM, char **argv)
 164 {
 165         char *str_C, *str_t;
 166         char *user;
 167         struct hcc *hccp;
 168         const char *instructs;
 169         char *msg_per_host = NULL;
 170         unsigned len_per_host = len_per_host; /* gcc */
 171 #ifndef SSLSVD
 172         struct bb_uidgid_t ugid;
 173 #endif
 174         bool tcp;
 175         uint16_t local_port;
 176         char *preset_local_hostname = NULL;
 177         char *remote_hostname = remote_hostname; /* for compiler */
 178         char *remote_addr = remote_addr; /* for compiler */
 179         len_and_sockaddr *lsa;
 180         len_and_sockaddr local, remote;
 181         socklen_t sa_len;
 182         int pid;
 183         int sock;
 184         int conn;
 185         unsigned backlog = 20;
 186         unsigned opts;
 187
 188         INIT_G();
 189
 190         tcp = (applet_name[0] == 't');
 191
 192         /* 3+ args, -i at most once, -p implies -h, -v is counter, -b N, -c N */
 193         opt_complementary = "-3:i--i:ph:vv:b+:c+";
 194 #ifdef SSLSVD
 195         opts = getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:vU:/:Z:K:",
 196                 &cmax, &str_C, &instructs, &instructs, &user, &preset_local_hostname,
 197                 &backlog, &str_t, &ssluser, &root, &cert, &key, &verbose
 198         );
 199 #else
 200         /* "+": stop on first non-option */
 201         opts = getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:v",
 202                 &cmax, &str_C, &instructs, &instructs, &user, &preset_local_hostname,
 203                 &backlog, &str_t, &verbose
 204         );
 205 #endif
 206         if (opts & OPT_C) { /* -C n[:message] */
 207                 max_per_host = bb_strtou(str_C, &str_C, 10);
 208                 if (str_C[0]) {
 209                         if (str_C[0] != ':')
 210                                 bb_show_usage();
 211                         msg_per_host = str_C + 1;
 212                         len_per_host = strlen(msg_per_host);
 213                 }
 214         }
 215         if (max_per_host > cmax)
 216                 max_per_host = cmax;
 217         if (opts & OPT_u) {
 218                 xget_uidgid(&ugid, user);
 219         }
 220 #ifdef SSLSVD
 221         if (opts & OPT_U) ssluser = optarg;
 222         if (opts & OPT_slash) root = optarg;
 223         if (opts & OPT_Z) cert = optarg;
 224         if (opts & OPT_K) key = optarg;
 225 #endif
 226         argv += optind;
 227         if (!argv[0][0] || LONE_CHAR(argv[0], '0'))
 228                 argv[0] = (char*)"0.0.0.0";
 229
 230         /* Per-IP flood protection is not thought-out for UDP */
 231         if (!tcp)
 232                 max_per_host = 0;
 233
 234         bb_sanitize_stdio(); /* fd# 0,1,2 must be opened */
 235
 236 #ifdef SSLSVD
 237         sslser = user;
 238         client = 0;
 239         if ((getuid() == 0) && !(opts & OPT_u)) {
 240                 xfunc_exitcode = 100;
 241                 bb_error_msg_and_die(bb_msg_you_must_be_root);
 242         }
 243         if (opts & OPT_u)
 244                 if (!uidgid_get(&sslugid, ssluser, 1)) {
 245                         if (errno) {
 246                                 bb_perror_msg_and_die("can't get user/group: %s", ssluser);
 247                         }
 248                         bb_error_msg_and_die("unknown user/group %s", ssluser);
 249                 }
 250         if (!cert) cert = "./cert.pem";
 251         if (!key) key = cert;
 252         if (matrixSslOpen() < 0)
 253                 fatal("can't initialize ssl");
 254         if (matrixSslReadKeys(&keys, cert, key, 0, ca) < 0) {
 255                 if (client)
 256                         fatal("can't read cert, key, or ca file");
 257                 fatal("can't read cert or key file");
 258         }
 259         if (matrixSslNewSession(&ssl, keys, 0, SSL_FLAGS_SERVER) < 0)
 260                 fatal("can't create ssl session");
 261 #endif
 262
 263         sig_block(SIGCHLD);
 264         signal(SIGCHLD, sig_child_handler);
 265         bb_signals(BB_FATAL_SIGS, sig_term_handler);
 266         signal(SIGPIPE, SIG_IGN);
 267
 268         if (max_per_host)
 269                 ipsvd_perhost_init(cmax);
 270
 271         local_port = bb_lookup_port(argv[1], tcp ? "tcp" : "udp", 0);
 272         lsa = xhost2sockaddr(argv[0], local_port);
 273         argv += 2;
 274
 275         sock = xsocket(lsa->u.sa.sa_family, tcp ? SOCK_STREAM : SOCK_DGRAM, 0);
 276         setsockopt_reuseaddr(sock);
 277         sa_len = lsa->len; /* I presume sockaddr len stays the same */
 278         xbind(sock, &lsa->u.sa, sa_len);
 279         if (tcp) {
 280                 xlisten(sock, backlog);
 281                 close_on_exec_on(sock);
 282         } else { /* udp: needed for recv_from_to to work: */
 283                 socket_want_pktinfo(sock);
 284         }
 285         /* ndelay_off(sock); - it is the default I think? */
 286
 287 #ifndef SSLSVD
 288         if (opts & OPT_u) {
 289                 /* drop permissions */
 290                 xsetgid(ugid.gid);
 291                 xsetuid(ugid.uid);
 292         }
 293 #endif
 294
 295         if (verbose) {
 296                 char *addr = xmalloc_sockaddr2dotted(&lsa->u.sa);
 297                 if (opts & OPT_u)
 298                         bb_error_msg("listening on %s, starting, uid %u, gid %u", addr,
 299                                 (unsigned)ugid.uid, (unsigned)ugid.gid);
 300                 else
 301                         bb_error_msg("listening on %s, starting", addr);
 302                 free(addr);
 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         { /* vfork alert! every xmalloc in this block should be freed! */
 415                 char *local_hostname = local_hostname; /* for compiler */
 416                 char *local_addr = NULL;
 417                 char *free_me0 = NULL;
 418                 char *free_me1 = NULL;
 419                 char *free_me2 = NULL;
 420
 421                 if (verbose || !(opts & OPT_E)) {
 422                         if (!max_per_host) /* remote_addr is not yet known */
 423                                 free_me0 = remote_addr = xmalloc_sockaddr2dotted(&remote.u.sa);
 424                         if (opts & OPT_h) {
 425                                 free_me1 = remote_hostname = xmalloc_sockaddr2host_noport(&remote.u.sa);
 426                                 if (!remote_hostname) {
 427                                         bb_error_msg("can't look up hostname for %s", remote_addr);
 428                                         remote_hostname = remote_addr;
 429                                 }
 430                         }
 431                         /* Find out local IP peer connected to.
 432                          * Errors ignored (I'm not paranoid enough to imagine kernel
 433                          * which doesn't know local IP). */
 434                         if (tcp)
 435                                 getsockname(0, &local.u.sa, &local.len);
 436                         /* else: for UDP it is done earlier by parent */
 437                         local_addr = xmalloc_sockaddr2dotted(&local.u.sa);
 438                         if (opts & OPT_h) {
 439                                 local_hostname = preset_local_hostname;
 440                                 if (!local_hostname) {
 441                                         free_me2 = local_hostname = xmalloc_sockaddr2host_noport(&local.u.sa);
 442                                         if (!local_hostname)
 443                                                 bb_error_msg_and_die("can't look up hostname for %s", local_addr);
 444                                 }
 445                                 /* else: local_hostname is not NULL, but is NOT malloced! */
 446                         }
 447                 }
 448                 if (verbose) {
 449                         pid = getpid();
 450                         if (max_per_host) {
 451                                 bb_error_msg("concurrency %s %u/%u",
 452                                         remote_addr,
 453                                         cur_per_host, max_per_host);
 454                         }
 455                         bb_error_msg((opts & OPT_h)
 456                                 ? "start %u %s-%s (%s-%s)"
 457                                 : "start %u %s-%s",
 458                                 pid,
 459                                 local_addr, remote_addr,
 460                                 local_hostname, remote_hostname);
 461                 }
 462
 463                 if (!(opts & OPT_E)) {
 464                         /* setup ucspi env */
 465                         const char *proto = tcp ? "TCP" : "UDP";
 466
 467                         /* Extract "original" destination addr:port
 468                          * from Linux firewall. Useful when you redirect
 469                          * an outbond connection to local handler, and it needs
 470                          * to know where it originally tried to connect */
 471                         if (tcp && getsockopt(0, SOL_IP, SO_ORIGINAL_DST, &local.u.sa, &local.len) == 0) {
 472                                 char *addr = xmalloc_sockaddr2dotted(&local.u.sa);
 473                                 xsetenv_plain("TCPORIGDSTADDR", addr);
 474                                 free(addr);
 475                         }
 476                         xsetenv_plain("PROTO", proto);
 477                         xsetenv_proto(proto, "LOCALADDR", local_addr);
 478                         xsetenv_proto(proto, "REMOTEADDR", remote_addr);
 479                         if (opts & OPT_h) {
 480                                 xsetenv_proto(proto, "LOCALHOST", local_hostname);
 481                                 xsetenv_proto(proto, "REMOTEHOST", remote_hostname);
 482                         }
 483                         //compat? xsetenv_proto(proto, "REMOTEINFO", "");
 484                         /* additional */
 485                         if (cur_per_host > 0) /* can not be true for udp */
 486                                 xsetenv_plain("TCPCONCURRENCY", utoa(cur_per_host));
 487                 }
 488                 free(local_addr);
 489                 free(free_me0);
 490                 free(free_me1);
 491                 free(free_me2);
 492         }
 493
 494         xdup2(0, 1);
 495
 496         signal(SIGPIPE, SIG_DFL); /* this one was SIG_IGNed */
 497         /* Non-ignored signals revert to SIG_DFL on exec anyway */
 498         /*signal(SIGCHLD, SIG_DFL);*/
 499         sig_unblock(SIGCHLD);
 500
 501 #ifdef SSLSVD
 502         strcpy(id, utoa(pid));
 503         ssl_io(0, argv);
 504         bb_perror_msg_and_die("can't execute '%s'", argv[0]);
 505 #else
 506         BB_EXECVP_or_die(argv);
 507 #endif
 508 }
 509
 510 /*
 511 tcpsvd [-hpEvv] [-c n] [-C n:msg] [-b n] [-u user] [-l name]
 512         [-i dir|-x cdb] [ -t sec] host port prog
 513
 514 tcpsvd creates a TCP/IP socket, binds it to the address host:port,
 515 and listens on the socket for incoming connections.
 516
 517 On each incoming connection, tcpsvd conditionally runs a program,
 518 with standard input reading from the socket, and standard output
 519 writing to the socket, to handle this connection. tcpsvd keeps
 520 listening on the socket for new connections, and can handle
 521 multiple connections simultaneously.
 522
 523 tcpsvd optionally checks for special instructions depending
 524 on the IP address or hostname of the client that initiated
 525 the connection, see ipsvd-instruct(5).
 526
 527 host
 528     host either is a hostname, or a dotted-decimal IP address,
 529     or 0. If host is 0, tcpsvd accepts connections to any local
 530     IP address.
 531     * busybox accepts IPv6 addresses and host:port pairs too
 532       In this case second parameter is ignored
 533 port
 534     tcpsvd accepts connections to host:port. port may be a name
 535     from /etc/services or a number.
 536 prog
 537     prog consists of one or more arguments. For each connection,
 538     tcpsvd normally runs prog, with file descriptor 0 reading from
 539     the network, and file descriptor 1 writing to the network.
 540     By default it also sets up TCP-related environment variables,
 541     see tcp-environ(5)
 542 -i dir
 543     read instructions for handling new connections from the instructions
 544     directory dir. See ipsvd-instruct(5) for details.
 545     * ignored by busyboxed version
 546 -x cdb
 547     read instructions for handling new connections from the constant database
 548     cdb. The constant database normally is created from an instructions
 549     directory by running ipsvd-cdb(8).
 550     * ignored by busyboxed version
 551 -t sec
 552     timeout. This option only takes effect if the -i option is given.
 553     While checking the instructions directory, check the time of last access
 554     of the file that matches the clients address or hostname if any, discard
 555     and remove the file if it wasn't accessed within the last sec seconds;
 556     tcpsvd does not discard or remove a file if the user's write permission
 557     is not set, for those files the timeout is disabled. Default is 0,
 558     which means that the timeout is disabled.
 559     * ignored by busyboxed version
 560 -l name
 561     local hostname. Do not look up the local hostname in DNS, but use name
 562     as hostname. This option must be set if tcpsvd listens on port 53
 563     to avoid loops.
 564 -u user[:group]
 565     drop permissions. Switch user ID to user's UID, and group ID to user's
 566     primary GID after creating and binding to the socket. If user is followed
 567     by a colon and a group name, the group ID is switched to the GID of group
 568     instead. All supplementary groups are removed.
 569 -c n
 570     concurrency. Handle up to n connections simultaneously. Default is 30.
 571     If there are n connections active, tcpsvd defers acceptance of a new
 572     connection until an active connection is closed.
 573 -C n[:msg]
 574     per host concurrency. Allow only up to n connections from the same IP
 575     address simultaneously. If there are n active connections from one IP
 576     address, new incoming connections from this IP address are closed
 577     immediately. If n is followed by :msg, the message msg is written
 578     to the client if possible, before closing the connection. By default
 579     msg is empty. See ipsvd-instruct(5) for supported escape sequences in msg.
 580
 581     For each accepted connection, the current per host concurrency is
 582     available through the environment variable TCPCONCURRENCY. n and msg
 583     can be overwritten by ipsvd(7) instructions, see ipsvd-instruct(5).
 584     By default tcpsvd doesn't keep track of connections.
 585 -h
 586     Look up the client's hostname in DNS.
 587 -p
 588     paranoid. After looking up the client's hostname in DNS, look up the IP
 589     addresses in DNS for that hostname, and forget about the hostname
 590     if none of the addresses match the client's IP address. You should
 591     set this option if you use hostname based instructions. The -p option
 592     implies the -h option.
 593     * ignored by busyboxed version
 594 -b n
 595     backlog. Allow a backlog of approximately n TCP SYNs. On some systems n
 596     is silently limited. Default is 20.
 597 -E
 598     no special environment. Do not set up TCP-related environment variables.
 599 -v
 600     verbose. Print verbose messsages to standard output.
 601 -vv
 602     more verbose. Print more verbose messages to standard output.
 603     * no difference between -v and -vv in busyboxed version
 604 */