Magellan Linux

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

    Contents of /trunk/mkinitrd-magellan/busybox/networking/tcpudp.c

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 984 - (show annotations) (download)
    Sun May 30 11:32:42 2010 UTC (13 years, 11 months ago) by niro
    File MIME type: text/plain
    File size: 18614 byte(s) 
    -updated to busybox-1.16.1 and enabled blkid/uuid support in default config
    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 */