nc: port nc 1.10 to busybox

1 files changed, 799 insertions, 0 deletions

diff --git a/networking/nc_bloaty.c b/networking/nc_bloaty.c
new file mode 100644
index 0000000..260d205
--- /dev/null
+++ b/networking/nc_bloaty.c
@@ -0,0 +1,799 @@
+/* Based on netcat 1.10 RELEASE 960320 written by hobbit@avian.org.
+ * Released into public domain by the author.
+ *
+ * Copyright (C) 2007 Denis Vlasenko.
+ *
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
+ */
+
+/* Author's comments from nc 1.10:
+ * =====================
+ * Netcat is entirely my own creation, although plenty of other code was used as
+ * examples.  It is freely given away to the Internet community in the hope that
+ * it will be useful, with no restrictions except giving credit where it is due.
+ * No GPLs, Berkeley copyrights or any of that nonsense.  The author assumes NO
+ * responsibility for how anyone uses it.  If netcat makes you rich somehow and
+ * you're feeling generous, mail me a check.  If you are affiliated in any way
+ * with Microsoft Network, get a life.  Always ski in control.  Comments,
+ * questions, and patches to hobbit@avian.org.
+ * ...
+ * Netcat and the associated package is a product of Avian Research, and is freely
+ * available in full source form with no restrictions save an obligation to give
+ * credit where due.
+ * ...
+ * A damn useful little "backend" utility begun 950915 or thereabouts,
+ * as *Hobbit*'s first real stab at some sockets programming.  Something that
+ * should have and indeed may have existed ten years ago, but never became a
+ * standard Unix utility.  IMHO, "nc" could take its place right next to cat,
+ * cp, rm, mv, dd, ls, and all those other cryptic and Unix-like things.
+ * =====================
+ *
+ * Much of author's comments are still retained in the code.
+ *
+ * Functionality removed (rationale):
+ * - miltiple-port ranges, randomized port scanning (use nmap)
+ * - telnet support (use telnet)
+ * - source routing
+ * - multiple DNS checks
+ * Functionalty which is different from nc 1.10:
+ * - Prog in '-e prog' can have prog's parameters and options.
+ *   Because of this -e option must be last.
+ * - nc doesn't redirect stderr to the network socket for the -e prog.
+ */
+
+/* done in nc.c: #include "busybox.h" */
+
+#define SLEAZE_PORT 31337               /* for UDP-scan RTT trick, change if ya want */
+#define BIGSIZ 8192                     /* big buffers */
+
+struct globals {
+	int netfd;
+	int ofd;                     /* hexdump output fd */
+#if ENABLE_LFS
+#define SENT_N_RECV_M "sent %llu, rcvd %llu\n"
+	unsigned long long wrote_out;          /* total stdout bytes */
+	unsigned long long wrote_net;          /* total net bytes */
+#else
+#define SENT_N_RECV_M "sent %u, rcvd %u"
+	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:
+	 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) */
+	struct len_and_sockaddr *ouraddr;
+	/* themaddr is NULL if no peer hostname[:port] specified on command line */
+	struct len_and_sockaddr *themaddr;
+	/* remend is set after connect/recv/accept to the actual ip:port of peer */
+	struct len_and_sockaddr remend;
+
+	/* global cmd flags: */
+	unsigned o_verbose;
+	unsigned o_wait;
+#if ENABLE_NC_EXTRA
+	unsigned o_interval;
+#endif
+
+	jmp_buf jbuf;                /* timer crud */
+	unsigned char *stage;        /* hexdump line buffer */
+
+	/* 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 netfd      (G.netfd     )
+#define ofd        (G.ofd       )
+#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 stage      (G.stage     )
+#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 )
+#define o_wait     (G.o_wait    )
+#if ENABLE_NC_EXTRA
+#define o_interval (G.o_interval)
+#else
+#define o_interval 0
+#endif
+
+/* 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,
+};
+
+#define o_nflag   (option_mask32 & OPT_n)
+#define o_udpmode (option_mask32 & OPT_u)
+#if ENABLE_NC_EXTRA
+#define o_wfile   (option_mask32 & OPT_o)
+#define o_listen  (option_mask32 & OPT_l)
+#define o_zero    (option_mask32 & OPT_z)
+#else
+#define o_wfile   0
+#define o_listen  0
+#define o_zero    0
+#endif
+
+/* Debug macro: squirt whatever message and sleep a bit so we can see it go
+ by.  need to call like Debug((stuff)) [with no ; ] so macro args match!
+ Beware: writes to stdOUT... */
+#if 0
+#define Debug(x) printf x; printf("\n"); fflush(stdout); sleep(1);
+#else
+#define Debug(x)        /* nil... */
+#endif
+
+#define holler_error(...)  do { if (o_verbose) bb_error_msg(__VA_ARGS__); } while(0)
+#define holler_perror(...) do { if (o_verbose) bb_perror_msg(__VA_ARGS__); } while(0)
+
+/* catch: no-brainer interrupt handler */
+static void catch(int sig)
+{
+	errno = 0;
+	if (o_verbose > 1)                /* normally we don't care */
+		fprintf(stderr, SENT_N_RECV_M, wrote_net, wrote_out);
+	fprintf(stderr, "punt!\n");
+}
+
+/* timeout and other signal handling cruft */
+static void tmtravel(int sig)
+{
+	signal(SIGALRM, SIG_IGN);
+	alarm(0);
+	longjmp(jbuf, 1);
+}
+
+/* arm: set the timer.  */
+static void arm(unsigned secs)
+{
+	signal(SIGALRM, tmtravel);
+	alarm(secs);
+}
+
+/* unarm  */
+static void unarm(void)
+{
+	signal(SIGALRM, SIG_IGN);
+	alarm(0);
+}
+
+/* findline:
+ find the next newline in a buffer; return inclusive size of that "line",
+ or the entire buffer size, so the caller knows how much to then write().
+ Not distinguishing \n vs \r\n for the nonce; it just works as is... */
+static unsigned findline(char *buf, unsigned siz)
+{
+	char * p;
+	int x;
+	if (!buf)                        /* various sanity checks... */
+		return 0;
+	if (siz > BIGSIZ)
+		return 0;
+	x = siz;
+	for (p = buf; x > 0; x--) {
+		if (*p == '\n') {
+			x = (int) (p - buf);
+			x++;                        /* 'sokay if it points just past the end! */
+Debug(("findline returning %d", x))
+			return x;
+		}
+		p++;
+	} /* for */
+Debug(("findline returning whole thing: %d", siz))
+	return siz;
+} /* findline */
+
+/* doexec:
+ fiddle all the file descriptors around, and hand off to another prog.  Sort
+ of like a one-off "poor man's inetd".  This is the only section of code
+ 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)
+{
+	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");
+}
+
+/* connect_w_timeout:
+ return an fd for one of
+ an open outbound TCP connection, a UDP stub-socket thingie, or
+ an unconnected TCP or UDP socket to listen on.
+ Examines various global o_blah flags to figure out what to do.
+ lad can be NULL, then socket is not bound to any local ip[:port] */
+static int connect_w_timeout(int fd)
+{
+	int rr;
+
+	/* wrap connect inside a timer, and hit it */
+	arm(o_wait);
+	if (setjmp(jbuf) == 0) {
+		rr = connect(fd, &themaddr->sa, themaddr->len);
+	} else { /* setjmp: connect failed... */
+		rr = -1;
+		errno = ETIMEDOUT; /* fake it */
+	}
+	unarm();
+	return rr;
+}
+
+/* dolisten:
+ listens for
+ 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)
+{
+	int rr;
+	const char *errmsg = errmsg; /* gcc */
+
+	if (!o_udpmode)
+		xlisten(netfd, 1); /* TCP: gotta listen() before we can get */
+
+	/* Various things that follow temporarily trash bigbuf_net, which might contain
+	 a copy of any recvfrom()ed packet, but we'll read() another copy later. */
+
+	/* I can't believe I have to do all this to get my own goddamn bound address
+	 and port number.  It should just get filled in during bind() or something.
+	 All this is only useful if we didn't say -p for listening, since if we
+	 said -p we *know* what port we're listening on.  At any rate we won't bother
+	 with it all unless we wanted to see it, although listening quietly on a
+	 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, ouraddr->len);
+		fprintf(stderr, "listening on [%s] ...\n", addr);
+		free(addr);
+	}
+
+	if (o_udpmode) {
+		/* UDP is a speeeeecial case -- we have to do I/O *and* get the calling
+		 party's particulars all at once, listen() and accept() don't apply.
+		 At least in the BSD universe, however, recvfrom/PEEK is enough to tell
+		 us something came in, and we can set things up so straight read/write
+		 actually does work after all.  Yow.  YMMV on strange platforms!  */
+
+		/* I'm not completely clear on how this works -- BSD seems to make UDP
+		 just magically work in a connect()ed context, but we'll undoubtedly run
+		 into systems this deal doesn't work on.  For now, we apparently have to
+		 issue a connect() on our just-tickled socket so we can write() back.
+		 Again, why the fuck doesn't it just get filled in and taken care of?!
+		 This hack is anything but optimal.  Basically, if you want your listener
+		 to also be able to send data back, you need this connect() line, which
+		 also has the side effect that now anything from a different source or even a
+		 different port on the other end won't show up and will cause ICMP errors.
+		 I guess that's what they meant by "connect".
+		 Let's try to remember what the "U" is *really* for, eh? */
+
+		/* If peer address is specified, connect to it */
+		if (themaddr) {
+			remend = *themaddr;
+			xconnect(netfd, &themaddr->sa, themaddr->len);
+			rr = 0;
+		} else { /* peek first packet and remember peer addr */
+			arm(o_wait);                /* might as well timeout this, too */
+			if (setjmp(jbuf) == 0) {       /* do timeout for initial connect */
+				/* (*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);
+				if (rr < 0)
+					bb_perror_msg_and_die("recvfrom");
+			} else
+				bb_error_msg_and_die("timeout");
+			unarm();
+			rr = connect(netfd, &remend.sa, ouraddr->len);
+			errmsg = "connect";
+		}
+	} else {
+		/* TCP */
+		arm(o_wait); /* wrap this in a timer, too; 0 = forever */
+		if (setjmp(jbuf) == 0) {
+			remend.len = LSA_SIZEOF_SA;
+			rr = accept(netfd, &remend.sa, &remend.len);
+		} else
+			bb_error_msg_and_die("timeout");
+		unarm();
+		errmsg = "accept";
+		if (rr >= 0) {
+			close(netfd); /* dump the old socket */
+			netfd = rr; /* 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);
+			errmsg = "getsockname after accept";
+		}
+	}
+	if (rr < 0)
+		bb_perror_msg_and_die(errmsg);
+
+#if ENABLE_NC_EXTRA && defined(IP_OPTIONS)
+	/* If we can, look for any IP options.  Useful for testing the receiving end of
+	 such things, and is a good exercise in dealing with it.  We do this before
+	 the connect message, to ensure that the connect msg is uniformly the LAST
+	 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. */
+	if (o_verbose) {
+		char optbuf[40];
+		int 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';
+			fprintf(stderr, "IP options: %s\n", bigbuf_net);
+		}
+	}
+#endif
+
+	/* now check out who it is.  We don't care about mismatched DNS names here,
+	 but any ADDR and PORT we specified had better fucking well match the caller.
+	 Converting from addr to inet_ntoa and back again is a bit of a kludge, but
+	 gethostpoop wants a string and there's much gnarlier code out there already,
+	 so I don't feel bad.
+	 The *real* question is why BFD sockets wasn't designed to allow listens for
+	 connections *from* specific hosts/ports, instead of requiring the caller to
+	 accept the connection and then reject undesireable ones by closing.
+	 In other words, we need a TCP MSG_PEEK. */
+	/* bbox: removed most of it */
+	if (o_verbose) {
+		char *lcladdr = xmalloc_sockaddr2dotted(&ouraddr->sa, ouraddr->len);
+		char *remaddr = xmalloc_sockaddr2dotted(&remend.sa, remend.len);
+		char *remhostname = o_nflag ? remaddr : xmalloc_sockaddr2host(&remend.sa, remend.len);
+		fprintf(stderr, "connect to [%s] from %s [%s]\n",
+				lcladdr, remhostname, remaddr);
+		free(lcladdr);
+		free(remaddr);
+		if (!o_nflag)
+			free(remhostname);
+	}
+}
+
+/* udptest:
+ fire a couple of packets at a UDP target port, just to see if it's really
+ there.  On BSD kernels, ICMP host/port-unreachable errors get delivered to
+ our socket as ECONNREFUSED write errors.  On SV kernels, we lose; we'll have
+ to collect and analyze raw ICMP ourselves a la satan's probe_udp_ports
+ backend.  Guess where one could swipe the appropriate code from...
+
+ Use the time delay between writes if given, otherwise use the "tcp ping"
+ trick for getting the RTT.  [I got that idea from pluvius, and warped it.]
+ Return either the original fd, or clean up and return -1. */
+static int udptest(void)
+{
+	int rr;
+
+	rr = write(netfd, bigbuf_in, 1);
+	if (rr != 1)
+		bb_perror_msg("udptest first write");
+
+	if (o_wait)
+		sleep(o_wait);
+	else {
+	/* use the tcp-ping trick: try connecting to a normally refused port, which
+	 causes us to block for the time that SYN gets there and RST gets back.
+	 Not completely reliable, but it *does* mostly work. */
+	/* 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));
+		connect_w_timeout(rr);
+//need to restore port?
+		close(rr);
+		o_wait = 0;                     /* reset it */
+	}
+
+	rr = write(netfd, bigbuf_in, 1);
+	return (rr != 1); /* if rr == 1, return 0 (success) */
+}
+
+/* oprint:
+ Hexdump bytes shoveled either way to a running logfile, in the format:
+ D offset       -  - - - --- 16 bytes --- - - -  -     # .... ascii .....
+ where "which" sets the direction indicator, D:
+ 0 -- sent to network, or ">"
+ 1 -- rcvd and printed to stdout, or "<"
+ and "buf" and "n" are data-block and length.  If the current block generates
+ a partial line, so be it; we *want* that lockstep indication of who sent
+ what when.  Adapted from dgaudet's original example -- but must be ripping
+ *fast*, since we don't want to be too disk-bound... */
+static void oprint(int which, char *buf, int n)
+{
+	int bc;                 /* in buffer count */
+	int obc;                /* current "global" offset */
+	int soc;                /* stage write count */
+	unsigned char *p;       /* main buf ptr; m.b. unsigned here */
+	unsigned char *op;      /* out hexdump ptr */
+	unsigned char *a;       /* out asc-dump ptr */
+	int x;
+
+	if (n == 0)
+		return;
+
+	op = stage;
+	if (which) {
+		*op = '<';
+		obc = wrote_out;                /* use the globals! */
+	} else {
+		*op = '>';
+		obc = wrote_net;
+	}
+	op++;                                /* preload "direction" */
+	*op = ' ';
+	p = (unsigned char *) buf;
+	bc = n;
+	stage[59] = '#';                /* preload separator */
+	stage[60] = ' ';
+
+	while (bc) {                        /* for chunk-o-data ... */
+		x = 16;
+		soc = 78;                        /* len of whole formatted line */
+		if (bc < x) {
+			soc = soc - 16 + bc;        /* fiddle for however much is left */
+			x = (bc * 3) + 11;        /* 2 digits + space per, after D & offset */
+			op = &stage[x];
+			x = 16 - bc;
+			while (x) {
+				*op++ = ' ';                /* preload filler spaces */
+				*op++ = ' ';
+				*op++ = ' ';
+				x--;
+			}
+			x = bc;                        /* re-fix current linecount */
+		} /* if bc < x */
+
+		bc -= x;                        /* fix wrt current line size */
+		sprintf(&stage[2], "%8.8x ", obc);                /* xxx: still slow? */
+		obc += x;                        /* fix current offset */
+		op = &stage[11];                /* where hex starts */
+		a = &stage[61];                /* where ascii starts */
+
+		while (x) {  /* for line of dump, however long ... */
+			*op++ = 0x20 | bb_hexdigits_upcase[*p >> 4];
+			*op++ = 0x20 | bb_hexdigits_upcase[*p & 0x0f];
+			*op++ = ' ';
+			if ((*p > 31) && (*p < 127))
+				*a = *p;                /* printing */
+			else
+				*a = '.';                /* nonprinting, loose def */
+			a++;
+			p++;
+			x--;
+		} /* while x */
+		*a = '\n';                        /* finish the line */
+		xwrite(ofd, stage, soc);
+	} /* while bc */
+}
+
+/* readwrite:
+ handle stdin/stdout/network I/O.  Bwahaha!! -- the select loop from hell.
+ In this instance, return what might become our exit status. */
+static int readwrite(void)
+{
+	int rr;
+	char *zp = zp; /* gcc */  /* stdin buf ptr */
+	char *np = np;            /* net-in buf ptr */
+	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 */
+
+	/* 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 */
+	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 */
+		}
+		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 (o_wait) {
+			struct timeval tmp_timer;
+			tmp_timer.tv_sec = o_wait;
+			tmp_timer.tv_usec = 0;
+			rr = select(16, &ding2, NULL, NULL, &tmp_timer);
+		} else
+			rr = select(16, &ding2, NULL, NULL, NULL);
+		if (rr < 0 && errno != EINTR) {                /* might have gotten ^Zed, etc */
+			holler_perror("select");
+			close(netfd);
+			return 1;
+		}
+	/* 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))
+				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! */
+			}
+		} /* select timeout */
+	/* xxx: should we check the exception fds too?  The read fds seem to give
+	 us the right info, and none of the examples I found bothered. */
+
+	/* Ding!!  Something arrived, go check all the incoming hoppers, net first */
+		if (FD_ISSET(netfd, &ding2)) {                /* net: ding! */
+			rr = read(netfd, bigbuf_net, BIGSIZ);
+			if (rr <= 0) {
+				FD_CLR(netfd, &ding1);                /* net closed, we'll finish up... */
+				rzleft = 0;                        /* can't write anymore: broken pipe */
+			} else {
+				rnleft = rr;
+				np = bigbuf_net;
+			}
+Debug(("got %d from the net, errno %d", rr, errno))
+		} /* net:ding */
+
+	/* if we're in "slowly" mode there's probably still stuff in the stdin
+	 buffer, so don't read unless we really need MORE INPUT!  MORE INPUT! */
+		if (rzleft)
+			goto shovel;
+
+	/* okay, suck more stdin */
+		if (FD_ISSET(0, &ding2)) {                /* stdin: ding! */
+			rr = read(0, 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);
+			} else {
+				rzleft = rr;
+				zp = bigbuf_in;
+			}
+		} /* stdin:ding */
+ shovel:
+	/* now that we've dingdonged all our thingdings, send off the results.
+	 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);
+			if (rr > 0) {
+				if (o_wfile)
+					oprint(1, np, rr);                /* log the stdout */
+				np += rr;                        /* fix up ptrs and whatnot */
+				rnleft -= rr;                        /* will get sanity-checked above */
+				wrote_out += rr;                /* global count */
+			}
+Debug(("wrote %d to stdout, errno %d", rr, errno))
+		} /* rnleft */
+		if (rzleft) {
+			if (o_interval)                        /* in "slowly" mode ?? */
+				rr = findline(zp, rzleft);
+			else
+				rr = rzleft;
+			rr = write(netfd, zp, rr);        /* one line, or the whole buffer */
+			if (rr > 0) {
+				if (o_wfile)
+					oprint(0, zp, rr);                /* log what got sent */
+				zp += rr;
+				rzleft -= rr;
+				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 */
+			wretry--;                        /* none left, and get another load */
+			goto shovel;
+		}
+	} /* while ding1:netfd is 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
+	 blocking reads and writes and my own manual "last ditch" efforts to read
+	 the net again after a timeout.  I haven't seen any screwups yet, but it's
+	 not like my test network is particularly busy... */
+	close(netfd);
+	return 0;
+} /* readwrite */
+
+/* main: now we pull it all together... */
+int nc_main(int argc, char **argv);
+int nc_main(int argc, char **argv)
+{
+	char *str_p, *str_s, *str_w;
+	USE_NC_EXTRA(char *str_i;)
+	char *themdotted = themdotted; /* gcc */
+	char **proggie;
+	int x;
+	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));
+
+	/* catch a signal or two for cleanup */
+	signal(SIGINT, catch);
+	signal(SIGQUIT, catch);
+	signal(SIGTERM, catch);
+	/* and suppress others... */
+#ifdef SIGURG
+	signal(SIGURG, SIG_IGN);
+#endif
+	signal(SIGPIPE, SIG_IGN); /* important! */
+
+	proggie = argv;
+	while (*++proggie) {
+		if (strcmp(*proggie, "-e") == 0) {
+			*proggie = NULL;
+			argc = proggie - argv;
+			proggie++;
+			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(argc, 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, &stage, &o_verbose));
+	argv += optind;
+#if ENABLE_NC_EXTRA
+	if (option_mask32 & OPT_i) /* line-interval time */
+		o_interval = xatou_range(str_i, 1, 0xffff);
+#endif
+	//if (option_mask32 & OPT_l) /* listen mode */
+	//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 */
+		o_lport = bb_lookup_port(str_p, o_udpmode ? "udp" : "tcp", 0);
+		if (!o_lport)
+			bb_error_msg_and_die("bad local port '%s'", str_p);
+	}
+	//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_z) /* little or no data xfer */
+
+	bb_sanitize_stdio();
+
+	/* create & bind network socket */
+	if (option_mask32 & OPT_s) { /* local address */
+		/* if o_port is still 0, then we will use random port */
+		ouraddr = xhost2sockaddr(str_s, o_lport);
+		netfd = xsocket(ouraddr->sa.sa_family, o_udpmode ? SOCK_DGRAM : SOCK_STREAM, 0); //// 0?
+	} else {
+		netfd = xsocket_type(&ouraddr, o_udpmode ? SOCK_DGRAM : SOCK_STREAM);
+		if (o_lport)
+			set_nport(ouraddr, htons(o_lport));
+	}
+	setsockopt_reuseaddr(netfd);
+	if (o_udpmode)
+		socket_want_pktinfo(netfd);
+	xbind(netfd, &ouraddr->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);
+#endif
+
+	if (o_udpmode) {      /* apparently UDP can listen ON */
+		if (!o_lport) /* "port 0",  but that's not useful */
+			bb_error_msg_and_die("UDP listen needs -p arg");
+	}
+
+	FD_SET(0, &ding1);                        /* stdin *is* initially open */
+	if (proggie) {
+		close(0); /* won't need stdin */
+		option_mask32 &= ~OPT_o; /* -o with -e is meaningless! */
+		ofd = 0;
+	}
+	if (o_wfile) {
+		ofd = xopen(stage, O_WRONLY|O_CREAT|O_TRUNC);
+		stage = xzalloc(100);
+	}
+
+	if (argv[0]) {
+		themaddr = xhost2sockaddr(argv[0],
+			argv[1]
+			? bb_lookup_port(argv[1], o_udpmode ? "udp" : "tcp", 0)
+			: 0);
+///what if sa_family won't match??
+	}
+
+	if (o_listen) {
+		dolisten();
+		/* 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");
+
+		remend = *themaddr;
+		if (o_verbose)
+			themdotted = xmalloc_sockaddr2dotted(&themaddr->sa, themaddr->len);
+
+		x = connect_w_timeout(netfd);
+		if (o_zero && x == 0 && o_udpmode)        /* if UDP scanning... */
+			x = udptest();
+		if (x == 0) {                        /* Yow, are we OPEN YET?! */
+			if (o_verbose)
+				fprintf(stderr, "%s [%s] open\n", argv[0], themdotted);
+			if (proggie)                        /* exec is valid for outbound, too */
+				doexec(proggie);
+			if (!o_zero)
+				x = readwrite();
+		} else { /* connect or udptest wasn't successful */
+			x = 1;                                /* exit status */
+			/* if we're scanning at a "one -v" verbosity level, don't print refusals.
+			 Give it another -v if you want to see everything. */
+			if (o_verbose > 1 || (o_verbose && errno != ECONNREFUSED))
+				bb_perror_msg("%s [%s]", argv[0], themdotted);
+		}
+	}
+	if (o_verbose > 1)                /* normally we don't care */
+		fprintf(stderr, SENT_N_RECV_M, wrote_net, wrote_out);
+	return x;
+}