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