/* Based on netcat 1.10 RELEASE 960320 written by hobbit@avian.org.
* Released into public domain by the author.
*
- * Copyright (C) 2007 Denis Vlasenko.
+ * Copyright (C) 2007 Denys Vlasenko.
*
- * Licensed under GPLv2, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2, see file LICENSE in this source tree.
*/
/* Author's comments from nc 1.10:
* - source routing
* - multiple DNS checks
* Functionalty which is different from nc 1.10:
- * - Prog in '-e prog' can have prog's parameters and options.
+ * - PROG in '-e PROG' can have ARGS (and options).
* Because of this -e option must be last.
- * - nc doesn't redirect stderr to the network socket for the -e prog.
+//TODO: remove -e incompatibility?
+ * - we don't redirect stderr to the network socket for the -e PROG.
+ * (PROG can do it itself if needed, but sometimes it is NOT wanted!)
* - numeric addresses are printed in (), not [] (IPv6 looks better),
* port numbers are inside (): (1.2.3.4:5678)
* - network read errors are reported on verbose levels > 1
* (nc 1.10 treats them as EOF)
* - TCP connects from wrong ip/ports (if peer ip:port is specified
* on the command line, but accept() says that it came from different addr)
- * are closed, but nc doesn't exit - continues to listen/accept.
+ * are closed, but we don't exit - we continue to listen/accept.
+ * Since bbox 1.22:
+ * - nc exits when _both_ stdin and network are closed.
+ * This makes these two commands:
+ * echo "Yes" | nc 127.0.0.1 1234
+ * echo "no" | nc -lp 1234
+ * exchange their data _and exit_ instead of being stuck.
*/
/* done in nc.c: #include "libbb.h" */
+//usage:#if ENABLE_NC_110_COMPAT
+//usage:
+//usage:#define nc_trivial_usage
+//usage: "[OPTIONS] HOST PORT - connect"
+//usage: IF_NC_SERVER("\n"
+//usage: "nc [OPTIONS] -l -p PORT [HOST] [PORT] - listen"
+//usage: )
+//usage:#define nc_full_usage "\n\n"
+//usage: " -e PROG Run PROG after connect (must be last)"
+//usage: IF_NC_SERVER(
+//usage: "\n -l Listen mode, for inbound connects"
+//usage: "\n -lk With -e, provides persistent server"
+/* -ll does the same as -lk, but its our extension, while -k is BSD'd,
+ * presumably more widely known. Therefore we advertise it, not -ll.
+ * I would like to drop -ll support, but our "small" nc supports it,
+ * and Rob uses it.
+ */
+//usage: )
+//usage: "\n -p PORT Local port"
+//usage: "\n -s ADDR Local address"
+//usage: "\n -w SEC Timeout for connects and final net reads"
+//usage: IF_NC_EXTRA(
+//usage: "\n -i SEC Delay interval for lines sent" /* ", ports scanned" */
+//usage: )
+//usage: "\n -n Don't do DNS resolution"
+//usage: "\n -u UDP mode"
+//usage: "\n -v Verbose"
+//usage: IF_NC_EXTRA(
+//usage: "\n -o FILE Hex dump traffic"
+//usage: "\n -z Zero-I/O mode (scanning)"
+//usage: )
+//usage:#endif
+
+/* "\n -r Randomize local and remote ports" */
+/* "\n -g gateway Source-routing hop point[s], up to 8" */
+/* "\n -G num Source-routing pointer: 4, 8, 12, ..." */
+/* "\nport numbers can be individual or ranges: lo-hi [inclusive]" */
+
+/* -e PROG can take ARGS too: "nc ... -e ls -l", but we don't document it
+ * in help text: nc 1.10 does not allow that. We don't want to entice
+ * users to use this incompatibility */
+
enum {
SLEAZE_PORT = 31337, /* for UDP-scan RTT trick, change if ya want */
BIGSIZ = 8192, /* big buffers */
unsigned wrote_out; /* total stdout bytes */
unsigned wrote_net; /* total net bytes */
#endif
- /* ouraddr is never NULL and goes thru three states as we progress:
+ char *proggie0saved;
+ /* ouraddr is never NULL and goes through three states as we progress:
1 - local address before bind (IP/port possibly zero)
2 - local address after bind (port is nonzero)
3 - local address after connect??/recv/accept (IP and port are nonzero) */
jmp_buf jbuf; /* timer crud */
- /* will malloc up the following globals: */
- fd_set ding1; /* for select loop */
- fd_set ding2;
char bigbuf_in[BIGSIZ]; /* data buffers */
char bigbuf_net[BIGSIZ];
};
#define G (*ptr_to_globals)
-
#define wrote_out (G.wrote_out )
#define wrote_net (G.wrote_net )
#define ouraddr (G.ouraddr )
#define themaddr (G.themaddr )
#define remend (G.remend )
#define jbuf (G.jbuf )
-#define ding1 (G.ding1 )
-#define ding2 (G.ding2 )
#define bigbuf_in (G.bigbuf_in )
#define bigbuf_net (G.bigbuf_net)
#define o_verbose (G.o_verbose )
#else
#define o_interval 0
#endif
+#define INIT_G() do { \
+ SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+} while (0)
+
/* Must match getopt32 call! */
enum {
- OPT_h = (1 << 0),
- OPT_n = (1 << 1),
- OPT_p = (1 << 2),
- OPT_s = (1 << 3),
- OPT_u = (1 << 4),
- OPT_v = (1 << 5),
- OPT_w = (1 << 6),
- OPT_l = (1 << 7) * ENABLE_NC_SERVER,
- OPT_i = (1 << (7+ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
- OPT_o = (1 << (8+ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
- OPT_z = (1 << (9+ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+ OPT_n = (1 << 0),
+ OPT_p = (1 << 1),
+ OPT_s = (1 << 2),
+ OPT_u = (1 << 3),
+ OPT_v = (1 << 4),
+ OPT_w = (1 << 5),
+ OPT_l = (1 << 6) * ENABLE_NC_SERVER,
+ OPT_k = (1 << 7) * ENABLE_NC_SERVER,
+ OPT_i = (1 << (6+2*ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+ OPT_o = (1 << (7+2*ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
+ OPT_z = (1 << (8+2*ENABLE_NC_SERVER)) * ENABLE_NC_EXTRA,
};
#define o_nflag (option_mask32 & OPT_n)
#define o_udpmode (option_mask32 & OPT_u)
-#if ENABLE_NC_SERVER
-#define o_listen (option_mask32 & OPT_l)
-#else
-#define o_listen 0
-#endif
#if ENABLE_NC_EXTRA
#define o_ofile (option_mask32 & OPT_o)
#define o_zero (option_mask32 & OPT_z)
/* Debug: squirt whatever message and sleep a bit so we can see it go by. */
/* Beware: writes to stdOUT... */
#if 0
-#define Debug(...) do { printf(__VA_ARGS__); printf("\n"); fflush(stdout); sleep(1); } while (0)
+#define Debug(...) do { printf(__VA_ARGS__); printf("\n"); fflush_all(); sleep(1); } while (0)
#else
#define Debug(...) do { } while (0)
#endif
if (o_verbose > 1) /* normally we don't care */
fprintf(stderr, SENT_N_RECV_M, wrote_net, wrote_out);
fprintf(stderr, "punt!\n");
- exit(1);
+ kill_myself_with_sig(sig);
}
/* unarm */
}
/* timeout and other signal handling cruft */
-static void tmtravel(int sig)
+static void tmtravel(int sig UNUSED_PARAM)
{
unarm();
longjmp(jbuf, 1);
that would be security-critical, which is why it's ifdefed out by default.
Use at your own hairy risk; if you leave shells lying around behind open
listening ports you deserve to lose!! */
-static int doexec(char **proggie) ATTRIBUTE_NORETURN;
+static int doexec(char **proggie) NORETURN;
static int doexec(char **proggie)
{
+ if (G.proggie0saved)
+ proggie[0] = G.proggie0saved;
xmove_fd(netfd, 0);
dup2(0, 1);
/* dup2(0, 2); - do we *really* want this? NO!
* exec'ed prog can do it yourself, if needed */
- execvp(proggie[0], proggie);
- bb_perror_msg_and_die("exec");
+ BB_EXECVP_or_die(proggie);
}
/* connect_w_timeout:
/* wrap connect inside a timer, and hit it */
arm(o_wait);
if (setjmp(jbuf) == 0) {
- rr = connect(fd, &themaddr->sa, themaddr->len);
+ rr = connect(fd, &themaddr->u.sa, themaddr->len);
unarm();
} else { /* setjmp: connect failed... */
rr = -1;
incoming and returns an open connection *from* someplace. If we were
given host/port args, any connections from elsewhere are rejected. This
in conjunction with local-address binding should limit things nicely... */
-static void dolisten(void)
+static void dolisten(int is_persistent, char **proggie)
{
int rr;
random unknown port is probably not very useful without "netstat". */
if (o_verbose) {
char *addr;
- rr = getsockname(netfd, &ouraddr->sa, &ouraddr->len);
- if (rr < 0)
- bb_perror_msg_and_die("getsockname after bind");
- addr = xmalloc_sockaddr2dotted(&ouraddr->sa);
+ getsockname(netfd, &ouraddr->u.sa, &ouraddr->len);
+ //if (rr < 0)
+ // bb_perror_msg_and_die("getsockname after bind");
+ addr = xmalloc_sockaddr2dotted(&ouraddr->u.sa);
fprintf(stderr, "listening on %s ...\n", addr);
free(addr);
}
remend.len = LSA_SIZEOF_SA;
if (themaddr) {
remend = *themaddr;
- xconnect(netfd, &themaddr->sa, themaddr->len);
+ xconnect(netfd, &themaddr->u.sa, themaddr->len);
}
/* peek first packet and remember peer addr */
arm(o_wait); /* might as well timeout this, too */
/* (*ouraddr) is prefilled with "default" address */
/* and here we block... */
rr = recv_from_to(netfd, NULL, 0, MSG_PEEK, /*was bigbuf_net, BIGSIZ*/
- &remend.sa, &ouraddr->sa, ouraddr->len);
+ &remend.u.sa, &ouraddr->u.sa, ouraddr->len);
if (rr < 0)
bb_perror_msg_and_die("recvfrom");
unarm();
/* Now we learned *to which IP* peer has connected, and we want to anchor
our socket on it, so that our outbound packets will have correct local IP.
Unfortunately, bind() on already bound socket will fail now (EINVAL):
- xbind(netfd, &ouraddr->sa, ouraddr->len);
+ xbind(netfd, &ouraddr->u.sa, ouraddr->len);
Need to read the packet, save data, close this socket and
create new one, and bind() it. TODO */
if (!themaddr)
- xconnect(netfd, &remend.sa, ouraddr->len);
+ xconnect(netfd, &remend.u.sa, ouraddr->len);
} else {
/* TCP */
+ another:
arm(o_wait); /* wrap this in a timer, too; 0 = forever */
if (setjmp(jbuf) == 0) {
again:
remend.len = LSA_SIZEOF_SA;
- rr = accept(netfd, &remend.sa, &remend.len);
+ rr = accept(netfd, &remend.u.sa, &remend.len);
if (rr < 0)
bb_perror_msg_and_die("accept");
- if (themaddr && memcmp(&remend.sa, &themaddr->sa, remend.len) != 0) {
- /* nc 1.10 bails out instead, and its error message
- * is not suppressed by o_verbose */
- if (o_verbose) {
- char *remaddr = xmalloc_sockaddr2dotted(&remend.sa);
- bb_error_msg("connect from wrong ip/port %s ignored", remaddr);
- free(remaddr);
+ if (themaddr) {
+ int sv_port, port, r;
+
+ sv_port = get_nport(&remend.u.sa); /* save */
+ port = get_nport(&themaddr->u.sa);
+ if (port == 0) {
+ /* "nc -nl -p LPORT RHOST" (w/o RPORT!):
+ * we should accept any remote port */
+ set_nport(&remend.u.sa, 0); /* blot out remote port# */
+ }
+ r = memcmp(&remend.u.sa, &themaddr->u.sa, remend.len);
+ set_nport(&remend.u.sa, sv_port); /* restore */
+ if (r != 0) {
+ /* nc 1.10 bails out instead, and its error message
+ * is not suppressed by o_verbose */
+ if (o_verbose) {
+ char *remaddr = xmalloc_sockaddr2dotted(&remend.u.sa);
+ bb_error_msg("connect from wrong ip/port %s ignored", remaddr);
+ free(remaddr);
+ }
+ close(rr);
+ goto again;
}
- close(rr);
- goto again;
}
unarm();
} else
bb_error_msg_and_die("timeout");
+
+ if (is_persistent && proggie) {
+ /* -l -k -e PROG */
+ signal(SIGCHLD, SIG_IGN); /* no zombies please */
+ if (xvfork() != 0) {
+ /* parent: go back and accept more connections */
+ close(rr);
+ goto another;
+ }
+ /* child */
+ signal(SIGCHLD, SIG_DFL);
+ }
+
xmove_fd(rr, netfd); /* dump the old socket, here's our new one */
/* find out what address the connection was *to* on our end, in case we're
doing a listen-on-any on a multihomed machine. This allows one to
offer different services via different alias addresses, such as the
"virtual web site" hack. */
- rr = getsockname(netfd, &ouraddr->sa, &ouraddr->len);
- if (rr < 0)
- bb_perror_msg_and_die("getsockname after accept");
+ getsockname(netfd, &ouraddr->u.sa, &ouraddr->len);
+ //if (rr < 0)
+ // bb_perror_msg_and_die("getsockname after accept");
}
if (o_verbose) {
thing to emerge after all the intervening crud. Doesn't work for UDP on
any machines I've tested, but feel free to surprise me. */
char optbuf[40];
- int x = sizeof(optbuf);
+ socklen_t x = sizeof(optbuf);
rr = getsockopt(netfd, IPPROTO_IP, IP_OPTIONS, optbuf, &x);
- if (rr < 0)
- bb_perror_msg("getsockopt failed");
- else if (x) { /* we've got options, lessee em... */
- bin2hex(bigbuf_net, optbuf, x);
- bigbuf_net[2*x] = '\0';
+ if (rr >= 0 && x) { /* we've got options, lessee em... */
+ *bin2hex(bigbuf_net, optbuf, x) = '\0';
fprintf(stderr, "IP options: %s\n", bigbuf_net);
}
#endif
accept the connection and then reject undesireable ones by closing.
In other words, we need a TCP MSG_PEEK. */
/* bbox: removed most of it */
- lcladdr = xmalloc_sockaddr2dotted(&ouraddr->sa);
- remaddr = xmalloc_sockaddr2dotted(&remend.sa);
- remhostname = o_nflag ? remaddr : xmalloc_sockaddr2host(&remend.sa);
+ lcladdr = xmalloc_sockaddr2dotted(&ouraddr->u.sa);
+ remaddr = xmalloc_sockaddr2dotted(&remend.u.sa);
+ remhostname = o_nflag ? remaddr : xmalloc_sockaddr2host(&remend.u.sa);
fprintf(stderr, "connect to %s from %s (%s)\n",
lcladdr, remhostname, remaddr);
free(lcladdr);
if (!o_nflag)
free(remhostname);
}
+
+ if (proggie)
+ doexec(proggie);
}
/* udptest:
/* Set a temporary connect timeout, so packet filtration doesnt cause
us to hang forever, and hit it */
o_wait = 5; /* enough that we'll notice?? */
- rr = xsocket(ouraddr->sa.sa_family, SOCK_STREAM, 0);
- set_nport(themaddr, htons(SLEAZE_PORT));
+ rr = xsocket(ouraddr->u.sa.sa_family, SOCK_STREAM, 0);
+ set_nport(&themaddr->u.sa, htons(SLEAZE_PORT));
connect_w_timeout(rr);
/* don't need to restore themaddr's port, it's not used anymore */
close(rr);
memset(&stage[11], ' ', 16*3);
x = bc;
}
- sprintf(&stage[1], " %8.8x ", obc); /* xxx: still slow? */
+ sprintf((char *)&stage[1], " %8.8x ", obc); /* xxx: still slow? */
bc -= x; /* fix current count */
obc += x; /* fix current offset */
op = &stage[11]; /* where hex starts */
unsigned rzleft;
unsigned rnleft;
unsigned netretry; /* net-read retry counter */
- unsigned wretry; /* net-write sanity counter */
- unsigned wfirst; /* one-shot flag to skip first net read */
+ unsigned fds_open;
/* if you don't have all this FD_* macro hair in sys/types.h, you'll have to
either find it or do your own bit-bashing: *ding1 |= (1 << fd), etc... */
- FD_SET(netfd, &ding1); /* global: the net is open */
+ fd_set ding1; /* for select loop */
+ fd_set ding2;
+ FD_ZERO(&ding1);
+ FD_SET(netfd, &ding1);
+ FD_SET(STDIN_FILENO, &ding1);
+ fds_open = 2;
+
netretry = 2;
- wfirst = 0;
rzleft = rnleft = 0;
if (o_interval)
sleep(o_interval); /* pause *before* sending stuff, too */
- errno = 0; /* clear from sleep, close, whatever */
/* and now the big ol' select shoveling loop ... */
- while (FD_ISSET(netfd, &ding1)) { /* i.e. till the *net* closes! */
- wretry = 8200; /* more than we'll ever hafta write */
- if (wfirst) { /* any saved stdin buffer? */
- wfirst = 0; /* clear flag for the duration */
- goto shovel; /* and go handle it first */
- }
+ /* nc 1.10 has "while (FD_ISSET(netfd)" here */
+ while (fds_open) {
+ unsigned wretry = 8200; /* net-write sanity counter */
+
ding2 = ding1; /* FD_COPY ain't portable... */
/* some systems, notably linux, crap into their select timers on return, so
we create a expendable copy and give *that* to select. */
/* if we have a timeout AND stdin is closed AND we haven't heard anything
from the net during that time, assume it's dead and close it too. */
if (rr == 0) {
- if (!FD_ISSET(0, &ding1))
+ if (!FD_ISSET(STDIN_FILENO, &ding1)) {
netretry--; /* we actually try a coupla times. */
- if (!netretry) {
- if (o_verbose > 1) /* normally we don't care */
- fprintf(stderr, "net timeout\n");
- close(netfd);
- return 0; /* not an error! */
+ if (!netretry) {
+ if (o_verbose > 1) /* normally we don't care */
+ fprintf(stderr, "net timeout\n");
+ /*close(netfd); - redundant, exit will do it */
+ return 0; /* not an error! */
+ }
}
} /* select timeout */
/* xxx: should we check the exception fds too? The read fds seem to give
/* nc 1.10 doesn't do this */
bb_perror_msg("net read");
}
- FD_CLR(netfd, &ding1); /* net closed, we'll finish up... */
+ FD_CLR(netfd, &ding1); /* net closed */
+ fds_open--;
rzleft = 0; /* can't write anymore: broken pipe */
} else {
rnleft = rr;
goto shovel;
/* okay, suck more stdin */
- if (FD_ISSET(0, &ding2)) { /* stdin: ding! */
- rr = read(0, bigbuf_in, BIGSIZ);
+ if (FD_ISSET(STDIN_FILENO, &ding2)) { /* stdin: ding! */
+ rr = read(STDIN_FILENO, bigbuf_in, BIGSIZ);
/* Considered making reads here smaller for UDP mode, but 8192-byte
mobygrams are kinda fun and exercise the reassembler. */
if (rr <= 0) { /* at end, or fukt, or ... */
- FD_CLR(0, &ding1); /* disable and close stdin */
- close(0);
+ FD_CLR(STDIN_FILENO, &ding1); /* disable stdin */
+ /*close(STDIN_FILENO); - not really necessary */
+ /* Let peer know we have no more data */
+ /* nc 1.10 doesn't do this: */
+ shutdown(netfd, SHUT_WR);
+ fds_open--;
} else {
rzleft = rr;
zp = bigbuf_in;
Geez, why does this look an awful lot like the big loop in "rsh"? ...
not sure if the order of this matters, but write net -> stdout first. */
- /* sanity check. Works because they're both unsigned... */
- if ((rzleft > 8200) || (rnleft > 8200)) {
- holler_error("bogus buffers: %u, %u", rzleft, rnleft);
- rzleft = rnleft = 0;
- }
- /* net write retries sometimes happen on UDP connections */
- if (!wretry) { /* is something hung? */
- holler_error("too many output retries");
- return 1;
- }
if (rnleft) {
- rr = write(1, np, rnleft);
+ rr = write(STDOUT_FILENO, np, rnleft);
if (rr > 0) {
- if (o_ofile)
- oprint('<', np, rr); /* log the stdout */
- np += rr; /* fix up ptrs and whatnot */
- rnleft -= rr; /* will get sanity-checked above */
- wrote_out += rr; /* global count */
+ if (o_ofile) /* log the stdout */
+ oprint('<', (unsigned char *)np, rr);
+ np += rr;
+ rnleft -= rr;
+ wrote_out += rr; /* global count */
}
Debug("wrote %d to stdout, errno %d", rr, errno);
} /* rnleft */
rr = rzleft;
rr = write(netfd, zp, rr); /* one line, or the whole buffer */
if (rr > 0) {
- if (o_ofile)
- oprint('>', zp, rr); /* log what got sent */
+ if (o_ofile) /* log what got sent */
+ oprint('>', (unsigned char *)zp, rr);
zp += rr;
rzleft -= rr;
- wrote_net += rr; /* global count */
+ wrote_net += rr; /* global count */
}
Debug("wrote %d to net, errno %d", rr, errno);
} /* rzleft */
if (o_interval) { /* cycle between slow lines, or ... */
sleep(o_interval);
- errno = 0; /* clear from sleep */
continue; /* ...with hairy select loop... */
}
- if ((rzleft) || (rnleft)) { /* shovel that shit till they ain't */
+ if (rzleft || rnleft) { /* shovel that shit till they ain't */
wretry--; /* none left, and get another load */
+ /* net write retries sometimes happen on UDP connections */
+ if (!wretry) { /* is something hung? */
+ holler_error("too many output retries");
+ return 1;
+ }
goto shovel;
}
- } /* while ding1:netfd is open */
+ } /* while (fds_open) */
/* XXX: maybe want a more graceful shutdown() here, or screw around with
linger times?? I suspect that I don't need to since I'm always doing
} /* readwrite */
/* main: now we pull it all together... */
-int nc_main(int argc, char **argv);
-int nc_main(int argc, char **argv)
+int nc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int nc_main(int argc UNUSED_PARAM, char **argv)
{
- char *str_p, *str_s, *str_w;
- USE_NC_EXTRA(char *str_i, *str_o;)
- char *themdotted = themdotted; /* gcc */
+ char *str_p, *str_s;
+ IF_NC_EXTRA(char *str_i, *str_o;)
+ char *themdotted = themdotted; /* for compiler */
char **proggie;
int x;
+ unsigned cnt_l = 0;
unsigned o_lport = 0;
- /* I was in this barbershop quartet in Skokie IL ... */
- /* round up the usual suspects, i.e. malloc up all the stuff we need */
- PTR_TO_GLOBALS = xzalloc(sizeof(G));
+ INIT_G();
/* catch a signal or two for cleanup */
- signal(SIGINT, catch);
- signal(SIGQUIT, catch);
- signal(SIGTERM, catch);
+ bb_signals(0
+ + (1 << SIGINT)
+ + (1 << SIGQUIT)
+ + (1 << SIGTERM)
+ , catch);
/* and suppress others... */
+ bb_signals(0
#ifdef SIGURG
- signal(SIGURG, SIG_IGN);
+ + (1 << SIGURG)
#endif
- signal(SIGPIPE, SIG_IGN); /* important! */
+ + (1 << SIGPIPE) /* important! */
+ , SIG_IGN);
proggie = argv;
while (*++proggie) {
if (strcmp(*proggie, "-e") == 0) {
*proggie = NULL;
- argc = proggie - argv;
proggie++;
goto e_found;
}
+ /* -<other_opts>e PROG [ARGS] ? */
+ /* (aboriginal linux uses this form) */
+ if (proggie[0][0] == '-') {
+ char *optpos = *proggie + 1;
+ /* Skip all valid opts w/o params */
+ optpos = optpos + strspn(optpos, "nuv"IF_NC_SERVER("lk")IF_NC_EXTRA("z"));
+ if (*optpos == 'e' && !optpos[1]) {
+ *optpos = '\0';
+ proggie++;
+ G.proggie0saved = *proggie;
+ *proggie = NULL; /* terminate argv for getopt32 */
+ goto e_found;
+ }
+ }
}
proggie = NULL;
e_found:
// -g -G -t -r deleted, unimplemented -a deleted too
- opt_complementary = "?2:vv"; /* max 2 params, -v is a counter */
- getopt32(argv, "hnp:s:uvw:" USE_NC_SERVER("l")
- USE_NC_EXTRA("i:o:z"),
- &str_p, &str_s, &str_w
- USE_NC_EXTRA(, &str_i, &str_o, &o_verbose));
+ opt_complementary = "?2:vv:ll:w+"; /* max 2 params; -v and -l are counters; -w N */
+ getopt32(argv, "np:s:uvw:" IF_NC_SERVER("lk")
+ IF_NC_EXTRA("i:o:z"),
+ &str_p, &str_s, &o_wait
+ IF_NC_EXTRA(, &str_i, &str_o), &o_verbose IF_NC_SERVER(, &cnt_l));
argv += optind;
#if ENABLE_NC_EXTRA
if (option_mask32 & OPT_i) /* line-interval time */
o_interval = xatou_range(str_i, 1, 0xffff);
#endif
+#if ENABLE_NC_SERVER
//if (option_mask32 & OPT_l) /* listen mode */
+ if (option_mask32 & OPT_k) /* persistent server mode */
+ cnt_l = 2;
+#endif
//if (option_mask32 & OPT_n) /* numeric-only, no DNS lookups */
//if (option_mask32 & OPT_o) /* hexdump log */
if (option_mask32 & OPT_p) { /* local source port */
//if (option_mask32 & OPT_r) /* randomize various things */
//if (option_mask32 & OPT_u) /* use UDP */
//if (option_mask32 & OPT_v) /* verbose */
- if (option_mask32 & OPT_w) { /* wait time */
- o_wait = xatoi_u(str_w);
- }
+ //if (option_mask32 & OPT_w) /* wait time */
//if (option_mask32 & OPT_z) /* little or no data xfer */
/* We manage our fd's so that they are never 0,1,2 */
if (option_mask32 & OPT_s) { /* local address */
/* if o_lport is still 0, then we will use random port */
ouraddr = xhost2sockaddr(str_s, o_lport);
- x = xsocket(ouraddr->sa.sa_family, x, 0);
+#ifdef BLOAT
+ /* prevent spurious "UDP listen needs !0 port" */
+ o_lport = get_nport(ouraddr);
+ o_lport = ntohs(o_lport);
+#endif
+ x = xsocket(ouraddr->u.sa.sa_family, x, 0);
} else {
/* We try IPv6, then IPv4, unless addr family is
* implicitly set by way of remote addr/port spec */
x = xsocket_type(&ouraddr,
- USE_FEATURE_IPV6((themaddr ? themaddr->sa.sa_family : AF_UNSPEC),)
+ (themaddr ? themaddr->u.sa.sa_family : AF_UNSPEC),
x);
if (o_lport)
- set_nport(ouraddr, htons(o_lport));
+ set_nport(&ouraddr->u.sa, htons(o_lport));
}
xmove_fd(x, netfd);
setsockopt_reuseaddr(netfd);
if (o_udpmode)
socket_want_pktinfo(netfd);
- xbind(netfd, &ouraddr->sa, ouraddr->len);
+ if (!ENABLE_FEATURE_UNIX_LOCAL
+ || cnt_l != 0 /* listen */
+ || ouraddr->u.sa.sa_family != AF_UNIX
+ ) {
+ xbind(netfd, &ouraddr->u.sa, ouraddr->len);
+ }
#if 0
- setsockopt(netfd, SOL_SOCKET, SO_RCVBUF, &o_rcvbuf, sizeof o_rcvbuf);
- setsockopt(netfd, SOL_SOCKET, SO_SNDBUF, &o_sndbuf, sizeof o_sndbuf);
+ setsockopt_SOL_SOCKET_int(netfd, SO_RCVBUF, o_rcvbuf);
+ setsockopt_SOL_SOCKET_int(netfd, SO_SNDBUF, o_sndbuf);
#endif
+#ifdef BLOAT
if (OPT_l && (option_mask32 & (OPT_u|OPT_l)) == (OPT_u|OPT_l)) {
/* apparently UDP can listen ON "port 0",
but that's not useful */
if (!o_lport)
bb_error_msg_and_die("UDP listen needs nonzero -p port");
}
+#endif
- FD_SET(0, &ding1); /* stdin *is* initially open */
if (proggie) {
- close(0); /* won't need stdin */
+ close(STDIN_FILENO); /* won't need stdin */
option_mask32 &= ~OPT_o; /* -o with -e is meaningless! */
}
#if ENABLE_NC_EXTRA
xmove_fd(xopen(str_o, O_WRONLY|O_CREAT|O_TRUNC), ofd);
#endif
- if (o_listen) {
- dolisten();
+ if (cnt_l != 0) {
+ dolisten((cnt_l - 1), proggie);
/* dolisten does its own connect reporting */
- if (proggie) /* -e given? */
- doexec(proggie);
x = readwrite(); /* it even works with UDP! */
} else {
/* Outbound connects. Now we're more picky about args... */
if (!themaddr)
- bb_error_msg_and_die("no destination");
+ bb_show_usage();
remend = *themaddr;
if (o_verbose)
- themdotted = xmalloc_sockaddr2dotted(&themaddr->sa);
+ themdotted = xmalloc_sockaddr2dotted(&themaddr->u.sa);
x = connect_w_timeout(netfd);
if (o_zero && x == 0 && o_udpmode) /* if UDP scanning... */