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 };
  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(var);
  89                 free(var);
  90                 *pp++ = NULL;
  91         }
  92 }
  93
  94 static void sig_term_handler(int sig)
  95 {
  96         if (verbose)
  97                 bb_error_msg("got signal %u, exit", sig);
  98         kill_myself_with_sig(sig);
  99 }
 100
 101 /* Little bloated, but tries to give accurate info how child exited.
 102  * Makes easier to spot segfaulting children etc... */
 103 static void print_waitstat(unsigned pid, int wstat)
 104 {
 105         unsigned e = 0;
 106         const char *cause = "?exit";
 107
 108         if (WIFEXITED(wstat)) {
 109                 cause++;
 110                 e = WEXITSTATUS(wstat);
 111         } else if (WIFSIGNALED(wstat)) {
 112                 cause = "signal";
 113                 e = WTERMSIG(wstat);
 114         }
 115         bb_error_msg("end %d %s %d", pid, cause, e);
 116 }
 117
 118 /* Must match getopt32 in main! */
 119 enum {
 120         OPT_c = (1 << 0),
 121         OPT_C = (1 << 1),
 122         OPT_i = (1 << 2),
 123         OPT_x = (1 << 3),
 124         OPT_u = (1 << 4),
 125         OPT_l = (1 << 5),
 126         OPT_E = (1 << 6),
 127         OPT_b = (1 << 7),
 128         OPT_h = (1 << 8),
 129         OPT_p = (1 << 9),
 130         OPT_t = (1 << 10),
 131         OPT_v = (1 << 11),
 132         OPT_V = (1 << 12),
 133         OPT_U = (1 << 13), /* from here: sslsvd only */
 134         OPT_slash = (1 << 14),
 135         OPT_Z = (1 << 15),
 136         OPT_K = (1 << 16),
 137 };
 138
 139 static void connection_status(void)
 140 {
 141         /* "only 1 client max" desn't need this */
 142         if (cmax > 1)
 143                 bb_error_msg("status %u/%u", cnum, cmax);
 144 }
 145
 146 static void sig_child_handler(int sig UNUSED_PARAM)
 147 {
 148         int wstat;
 149         pid_t pid;
 150
 151         while ((pid = wait_any_nohang(&wstat)) > 0) {
 152                 if (max_per_host)
 153                         ipsvd_perhost_remove(pid);
 154                 if (cnum)
 155                         cnum--;
 156                 if (verbose)
 157                         print_waitstat(pid, wstat);
 158         }
 159         if (verbose)
 160                 connection_status();
 161 }
 162
 163 int tcpudpsvd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 164 int tcpudpsvd_main(int argc UNUSED_PARAM, char **argv)
 165 {
 166         char *str_C, *str_t;
 167         char *user;
 168         struct hcc *hccp;
 169         const char *instructs;
 170         char *msg_per_host = NULL;
 171         unsigned len_per_host = len_per_host; /* gcc */
 172 #ifndef SSLSVD
 173         struct bb_uidgid_t ugid;
 174 #endif
 175         bool tcp;
 176         uint16_t local_port;
 177         char *preset_local_hostname = NULL;
 178         char *remote_hostname = remote_hostname; /* for compiler */
 179         char *remote_addr = remote_addr; /* for compiler */
 180         len_and_sockaddr *lsa;
 181         len_and_sockaddr local, remote;
 182         socklen_t sa_len;
 183         int pid;
 184         int sock;
 185         int conn;
 186         unsigned backlog = 20;
 187         unsigned opts;
 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         opts = 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         opts = 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 (opts & 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 (opts & OPT_u) {
 219                 xget_uidgid(&ugid, user);
 220         }
 221 #ifdef SSLSVD
 222         if (opts & OPT_U) ssluser = optarg;
 223         if (opts & OPT_slash) root = optarg;
 224         if (opts & OPT_Z) cert = optarg;
 225         if (opts & 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) && !(opts & OPT_u)) {
 241                 xfunc_exitcode = 100;
 242                 bb_error_msg_and_die(bb_msg_you_must_be_root);
 243         }
 244         if (opts & 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("can't initialize ssl");
 255         if (matrixSslReadKeys(&keys, cert, key, 0, ca) < 0) {
 256                 if (client)
 257                         fatal("can't read cert, key, or ca file");
 258                 fatal("can't read cert or key file");
 259         }
 260         if (matrixSslNewSession(&ssl, keys, 0, SSL_FLAGS_SERVER) < 0)
 261                 fatal("can't 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                 close_on_exec_on(sock);
 283         } else { /* udp: needed for recv_from_to to work: */
 284                 socket_want_pktinfo(sock);
 285         }
 286         /* ndelay_off(sock); - it is the default I think? */
 287
 288 #ifndef SSLSVD
 289         if (opts & OPT_u) {
 290                 /* drop permissions */
 291                 xsetgid(ugid.gid);
 292                 xsetuid(ugid.uid);
 293         }
 294 #endif
 295
 296         if (verbose) {
 297                 char *addr = xmalloc_sockaddr2dotted(&lsa->u.sa);
 298                 if (opts & OPT_u)
 299                         bb_error_msg("listening on %s, starting, uid %u, gid %u", addr,
 300                                 (unsigned)ugid.uid, (unsigned)ugid.gid);
 301                 else
 302                         bb_error_msg("listening on %s, starting", addr);
 303                 free(addr);
 304         }
 305
 306         /* Main accept() loop */
 307
 308  again:
 309         hccp = NULL;
 310
 311         while (cnum >= cmax)
 312                 wait_for_any_sig(); /* expecting SIGCHLD */
 313
 314         /* Accept a connection to fd #0 */
 315  again1:
 316         close(0);
 317  again2:
 318         sig_unblock(SIGCHLD);
 319         local.len = remote.len = sa_len;
 320         if (tcp) {
 321                 conn = accept(sock, &remote.u.sa, &remote.len);
 322         } else {
 323                 /* In case recv_from_to won't be able to recover local addr.
 324                  * Also sets port - recv_from_to is unable to do it. */
 325                 local = *lsa;
 326                 conn = recv_from_to(sock, NULL, 0, MSG_PEEK,
 327                                 &remote.u.sa, &local.u.sa, sa_len);
 328         }
 329         sig_block(SIGCHLD);
 330         if (conn < 0) {
 331                 if (errno != EINTR)
 332                         bb_perror_msg(tcp ? "accept" : "recv");
 333                 goto again2;
 334         }
 335         xmove_fd(tcp ? conn : sock, 0);
 336
 337         if (max_per_host) {
 338                 /* Drop connection immediately if cur_per_host > max_per_host
 339                  * (minimizing load under SYN flood) */
 340                 remote_addr = xmalloc_sockaddr2dotted_noport(&remote.u.sa);
 341                 cur_per_host = ipsvd_perhost_add(remote_addr, max_per_host, &hccp);
 342                 if (cur_per_host > max_per_host) {
 343                         /* ipsvd_perhost_add detected that max is exceeded
 344                          * (and did not store ip in connection table) */
 345                         free(remote_addr);
 346                         if (msg_per_host) {
 347                                 /* don't block or test for errors */
 348                                 send(0, msg_per_host, len_per_host, MSG_DONTWAIT);
 349                         }
 350                         goto again1;
 351                 }
 352                 /* NB: remote_addr is not leaked, it is stored in conn table */
 353         }
 354
 355         if (!tcp) {
 356                 /* Voodoo magic: making udp sockets each receive its own
 357                  * packets is not trivial, and I still not sure
 358                  * I do it 100% right.
 359                  * 1) we have to do it before fork()
 360                  * 2) order is important - is it right now? */
 361
 362                 /* Open new non-connected UDP socket for further clients... */
 363                 sock = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
 364                 setsockopt_reuseaddr(sock);
 365                 /* Make plain write/send work for old socket by supplying default
 366                  * destination address. This also restricts incoming packets
 367                  * to ones coming from this remote IP. */
 368                 xconnect(0, &remote.u.sa, sa_len);
 369         /* hole? at this point we have no wildcard udp socket...
 370          * can this cause clients to get "port unreachable" icmp?
 371          * Yup, time window is very small, but it exists (is it?) */
 372                 /* ..."open new socket", continued */
 373                 xbind(sock, &lsa->u.sa, sa_len);
 374                 socket_want_pktinfo(sock);
 375
 376                 /* Doesn't work:
 377                  * we cannot replace fd #0 - we will lose pending packet
 378                  * which is already buffered for us! And we cannot use fd #1
 379                  * instead - it will "intercept" all following packets, but child
 380                  * does not expect data coming *from fd #1*! */
 381 #if 0
 382                 /* Make it so that local addr is fixed to localp->u.sa
 383                  * and we don't accidentally accept packets to other local IPs. */
 384                 /* NB: we possibly bind to the _very_ same_ address & port as the one
 385                  * already bound in parent! This seems to work in Linux.
 386                  * (otherwise we can move socket to fd #0 only if bind succeeds) */
 387                 close(0);
 388                 set_nport(localp, htons(local_port));
 389                 xmove_fd(xsocket(localp->u.sa.sa_family, SOCK_DGRAM, 0), 0);
 390                 setsockopt_reuseaddr(0); /* crucial */
 391                 xbind(0, &localp->u.sa, localp->len);
 392 #endif
 393         }
 394
 395         pid = vfork();
 396         if (pid == -1) {
 397                 bb_perror_msg("vfork");
 398                 goto again;
 399         }
 400
 401         if (pid != 0) {
 402                 /* Parent */
 403                 cnum++;
 404                 if (verbose)
 405                         connection_status();
 406                 if (hccp)
 407                         hccp->pid = pid;
 408                 /* clean up changes done by vforked child */
 409                 undo_xsetenv();
 410                 goto again;
 411         }
 412
 413         /* Child: prepare env, log, and exec prog */
 414
 415         { /* vfork alert! every xmalloc in this block should be freed! */
 416                 char *local_hostname = local_hostname; /* for compiler */
 417                 char *local_addr = NULL;
 418                 char *free_me0 = NULL;
 419                 char *free_me1 = NULL;
 420                 char *free_me2 = NULL;
 421
 422                 if (verbose || !(opts & OPT_E)) {
 423                         if (!max_per_host) /* remote_addr is not yet known */
 424                                 free_me0 = remote_addr = xmalloc_sockaddr2dotted(&remote.u.sa);
 425                         if (opts & OPT_h) {
 426                                 free_me1 = remote_hostname = xmalloc_sockaddr2host_noport(&remote.u.sa);
 427                                 if (!remote_hostname) {
 428                                         bb_error_msg("can't look up hostname for %s", remote_addr);
 429                                         remote_hostname = remote_addr;
 430                                 }
 431                         }
 432                         /* Find out local IP peer connected to.
 433                          * Errors ignored (I'm not paranoid enough to imagine kernel
 434                          * which doesn't know local IP). */
 435                         if (tcp)
 436                                 getsockname(0, &local.u.sa, &local.len);
 437                         /* else: for UDP it is done earlier by parent */
 438                         local_addr = xmalloc_sockaddr2dotted(&local.u.sa);
 439                         if (opts & OPT_h) {
 440                                 local_hostname = preset_local_hostname;
 441                                 if (!local_hostname) {
 442                                         free_me2 = local_hostname = xmalloc_sockaddr2host_noport(&local.u.sa);
 443                                         if (!local_hostname)
 444                                                 bb_error_msg_and_die("can't look up hostname for %s", local_addr);
 445                                 }
 446                                 /* else: local_hostname is not NULL, but is NOT malloced! */
 447                         }
 448                 }
 449                 if (verbose) {
 450                         pid = getpid();
 451                         if (max_per_host) {
 452                                 bb_error_msg("concurrency %s %u/%u",
 453                                         remote_addr,
 454                                         cur_per_host, max_per_host);
 455                         }
 456                         bb_error_msg((opts & OPT_h)
 457                                 ? "start %u %s-%s (%s-%s)"
 458                                 : "start %u %s-%s",
 459                                 pid,
 460                                 local_addr, remote_addr,
 461                                 local_hostname, remote_hostname);
 462                 }
 463
 464                 if (!(opts & OPT_E)) {
 465                         /* setup ucspi env */
 466                         const char *proto = tcp ? "TCP" : "UDP";
 467
 468                         /* Extract "original" destination addr:port
 469                          * from Linux firewall. Useful when you redirect
 470                          * an outbond connection to local handler, and it needs
 471                          * to know where it originally tried to connect */
 472                         if (tcp && getsockopt(0, SOL_IP, SO_ORIGINAL_DST, &local.u.sa, &local.len) == 0) {
 473                                 char *addr = xmalloc_sockaddr2dotted(&local.u.sa);
 474                                 xsetenv_plain("TCPORIGDSTADDR", addr);
 475                                 free(addr);
 476                         }
 477                         xsetenv_plain("PROTO", proto);
 478                         xsetenv_proto(proto, "LOCALADDR", local_addr);
 479                         xsetenv_proto(proto, "REMOTEADDR", remote_addr);
 480                         if (opts & OPT_h) {
 481                                 xsetenv_proto(proto, "LOCALHOST", local_hostname);
 482                                 xsetenv_proto(proto, "REMOTEHOST", remote_hostname);
 483                         }
 484                         //compat? xsetenv_proto(proto, "REMOTEINFO", "");
 485                         /* additional */
 486                         if (cur_per_host > 0) /* can not be true for udp */
 487                                 xsetenv_plain("TCPCONCURRENCY", utoa(cur_per_host));
 488                 }
 489                 free(local_addr);
 490                 free(free_me0);
 491                 free(free_me1);
 492                 free(free_me2);
 493         }
 494
 495         xdup2(0, 1);
 496
 497         signal(SIGPIPE, SIG_DFL); /* this one was SIG_IGNed */
 498         /* Non-ignored signals revert to SIG_DFL on exec anyway */
 499         /*signal(SIGCHLD, SIG_DFL);*/
 500         sig_unblock(SIGCHLD);
 501
 502 #ifdef SSLSVD
 503         strcpy(id, utoa(pid));
 504         ssl_io(0, argv);
 505 #else
 506         BB_EXECVP(argv[0], argv);
 507 #endif
 508         bb_perror_msg_and_die("exec '%s'", argv[0]);
 509 }
 510
 511 /*
 512 tcpsvd [-hpEvv] [-c n] [-C n:msg] [-b n] [-u user] [-l name]
 513         [-i dir|-x cdb] [ -t sec] host port prog
 514
 515 tcpsvd creates a TCP/IP socket, binds it to the address host:port,
 516 and listens on the socket for incoming connections.
 517
 518 On each incoming connection, tcpsvd conditionally runs a program,
 519 with standard input reading from the socket, and standard output
 520 writing to the socket, to handle this connection. tcpsvd keeps
 521 listening on the socket for new connections, and can handle
 522 multiple connections simultaneously.
 523
 524 tcpsvd optionally checks for special instructions depending
 525 on the IP address or hostname of the client that initiated
 526 the connection, see ipsvd-instruct(5).
 527
 528 host
 529     host either is a hostname, or a dotted-decimal IP address,
 530     or 0. If host is 0, tcpsvd accepts connections to any local
 531     IP address.
 532     * busybox accepts IPv6 addresses and host:port pairs too
 533       In this case second parameter is ignored
 534 port
 535     tcpsvd accepts connections to host:port. port may be a name
 536     from /etc/services or a number.
 537 prog
 538     prog consists of one or more arguments. For each connection,
 539     tcpsvd normally runs prog, with file descriptor 0 reading from
 540     the network, and file descriptor 1 writing to the network.
 541     By default it also sets up TCP-related environment variables,
 542     see tcp-environ(5)
 543 -i dir
 544     read instructions for handling new connections from the instructions
 545     directory dir. See ipsvd-instruct(5) for details.
 546     * ignored by busyboxed version
 547 -x cdb
 548     read instructions for handling new connections from the constant database
 549     cdb. The constant database normally is created from an instructions
 550     directory by running ipsvd-cdb(8).
 551     * ignored by busyboxed version
 552 -t sec
 553     timeout. This option only takes effect if the -i option is given.
 554     While checking the instructions directory, check the time of last access
 555     of the file that matches the clients address or hostname if any, discard
 556     and remove the file if it wasn't accessed within the last sec seconds;
 557     tcpsvd does not discard or remove a file if the user's write permission
 558     is not set, for those files the timeout is disabled. Default is 0,
 559     which means that the timeout is disabled.
 560     * ignored by busyboxed version
 561 -l name
 562     local hostname. Do not look up the local hostname in DNS, but use name
 563     as hostname. This option must be set if tcpsvd listens on port 53
 564     to avoid loops.
 565 -u user[:group]
 566     drop permissions. Switch user ID to user's UID, and group ID to user's
 567     primary GID after creating and binding to the socket. If user is followed
 568     by a colon and a group name, the group ID is switched to the GID of group
 569     instead. All supplementary groups are removed.
 570 -c n
 571     concurrency. Handle up to n connections simultaneously. Default is 30.
 572     If there are n connections active, tcpsvd defers acceptance of a new
 573     connection until an active connection is closed.
 574 -C n[:msg]
 575     per host concurrency. Allow only up to n connections from the same IP
 576     address simultaneously. If there are n active connections from one IP
 577     address, new incoming connections from this IP address are closed
 578     immediately. If n is followed by :msg, the message msg is written
 579     to the client if possible, before closing the connection. By default
 580     msg is empty. See ipsvd-instruct(5) for supported escape sequences in msg.
 581
 582     For each accepted connection, the current per host concurrency is
 583     available through the environment variable TCPCONCURRENCY. n and msg
 584     can be overwritten by ipsvd(7) instructions, see ipsvd-instruct(5).
 585     By default tcpsvd doesn't keep track of connections.
 586 -h
 587     Look up the client's hostname in DNS.
 588 -p
 589     paranoid. After looking up the client's hostname in DNS, look up the IP
 590     addresses in DNS for that hostname, and forget about the hostname
 591     if none of the addresses match the client's IP address. You should
 592     set this option if you use hostname based instructions. The -p option
 593     implies the -h option.
 594     * ignored by busyboxed version
 595 -b n
 596     backlog. Allow a backlog of approximately n TCP SYNs. On some systems n
 597     is silently limited. Default is 20.
 598 -E
 599     no special environment. Do not set up TCP-related environment variables.
 600 -v
 601     verbose. Print verbose messsages to standard output.
 602 -vv
 603     more verbose. Print more verbose messages to standard output.
 604     * no difference between -v and -vv in busyboxed version
 605 */