Magellan Linux

  • Back to homepage
    • /[magellan-source]/tags/mkinitrd-6_1_11/busybox/networking/tcpudp.c

    Contents of /tags/mkinitrd-6_1_11/busybox/networking/tcpudp.c

    Parent Directory Parent Directory | Revision Log Revision Log

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