← Commit list

29fe7265b

Denis Vlasenko

2007-04-05

FAILED Duration: 14s

Subject

nc: port nc 1.10 to busybox

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

include/libbb.h +10 -0 include/usage.h +31 -0 ipsvd/tcpudp.c +0 -2 libbb/Kbuild +1 -0 ipsvd/udp_io.c → libbb/udp_io.c +9 -8 libbb/xconnect.c +1 -1 networking/Config.in +1 -1 networking/nc.c +5 -0 networking/nc_bloaty.c +799 -0

include/libbb.h+10 -0

@@ -334,6 +334,7 @@ enum {
	};
	/* Create stream socket, and allocated suitable lsa
	* (lsa of correct size and lsa->sa.sa_family (AF_INET/AF_INET6)) */
+	int xsocket_type(len_and_sockaddr **lsap, int sock_type);
	int xsocket_stream(len_and_sockaddr **lsap);
	/* Create server socket bound to bindaddr:port. bindaddr can be NULL,
	* numeric IP ("N.N.N.N") or numeric IPv6 address,
@@ -388,6 +389,15 @@ struct hostent xgethostbyname(const char name);
	// + inet_common.c has additional IPv4-only stuff


+	void socket_want_pktinfo(int fd);
+	ssize_t send_to_from(int fd, void *buf, size_t len, int flags,
+	const struct sockaddr from, const struct sockaddr to,
+	socklen_t tolen);
+	ssize_t recv_from_to(int fd, void *buf, size_t len, int flags,
+	struct sockaddr from, struct sockaddr to,
+	socklen_t sa_size);
+
+
	extern char xstrdup(const char s);
	extern char xstrndup(const char s, int n);
	extern char safe_strncpy(char dst, const char *src, size_t size);

include/usage.h+31 -0

@@ -2314,6 +2314,8 @@
	" or\n" \
	"$ nameif -c /etc/my_mactab_file\n" \

+	#if !ENABLE_DESKTOP
+
	#if ENABLE_NC_SERVER \|\| ENABLE_NC_EXTRA
	#define NC_OPTIONS_STR "\n\nOptions:"
	#else
@@ -2356,6 +2358,35 @@
	"quit\n" \
	"221 foobar closing connection\n"

+	#else /* DESKTOP nc - much more compatible with nc 1.10 */
+
+	#define nc_trivial_usage \
+	"[-options] hostname port - connect" \
+	USE_NC_SERVER("\nnc [-options] -l -p port [hostname] [port] - listen")
+	#define nc_full_usage \
+	USE_NC_SERVER( \
+	"-l Listen mode, for inbound connects\n" \
+	) \
+	"-n Do not do DNS resolution" \
+	"\n-s addr Local address" \
+	"\n-p port Local port" \
+	"\n-u UDP mode" \
+	"\n-v Verbose (cumulative: -vv)" \
+	"\n-w secs Timeout for connects and final net reads" \
+	USE_NC_EXTRA( \
+	"\n-i sec Delay interval for lines sent" /* ", ports scanned" */ \
+	"\n-o file Hex dump of traffic" \
+	"\n-z Zero-I/O mode (scanning)" \
+	) \
+	"\n-e prog [args] Program to exec after connect (must be last)" \
+	/* "\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]" */
+
+	#endif
+
+
	#define netstat_trivial_usage \
	"[-laenrtuwx]"
	#define netstat_full_usage \

ipsvd/tcpudp.c+0 -2

@@ -33,8 +33,6 @@
	#include <linux/netfilter_ipv4.h> /* wants <limits.h> */

	#include "busybox.h"
-
-	#include "udp_io.c"
	#include "ipsvd_perhost.h"

	#ifdef SSLSVD

libbb/Kbuild+1 -0

@@ -78,6 +78,7 @@ lib-y += skip_whitespace.o
	lib-y += speed_table.o
	lib-y += trim.o
	lib-y += u_signal_names.o
+	lib-y += udp_io.o
	lib-y += uuencode.o
	lib-y += vdprintf.o
	lib-y += verror_msg.o

ipsvd/udp_io.c → libbb/udp_io.c+9 -8

@@ -1,12 +1,13 @@
-	/* Thus far used only by udpsvd.c */
+	/* vi: set sw=4 ts=4: */
+	/*
+	* Utility routines.
+	*
+	* Copyright (C) 2007 Denis Vlasenko
+	*
+	* Licensed under GPL version 2, see file LICENSE in this tarball for details.
+	*/

-	void socket_want_pktinfo(int fd);
-	ssize_t send_to_from(int fd, void *buf, size_t len, int flags,
-	const struct sockaddr from, const struct sockaddr to,
-	socklen_t tolen);
-	ssize_t recv_from_to(int fd, void *buf, size_t len, int flags,
-	struct sockaddr from, struct sockaddr to,
-	socklen_t sa_size);
+	#include "libbb.h"

	/*
	* This asks kernel to let us know dst addr/port of incoming packets

libbb/xconnect.c+1 -1

@@ -208,7 +208,7 @@ len_and_sockaddr* xdotted2sockaddr(const char *host, int port)
	return str2sockaddr(host, port, AF_UNSPEC, AI_NUMERICHOST \| DIE_ON_ERROR);
	}

-	static int xsocket_type(len_and_sockaddr **lsap, int sock_type)
+	int xsocket_type(len_and_sockaddr **lsap, int sock_type)
	{
	len_and_sockaddr *lsa;
	int fd;

networking/Config.in+1 -1

@@ -467,7 +467,7 @@ config NC
	connections.

	config NC_SERVER
-	bool "Netcat server options (-lp)"
+	bool "Netcat server options (-l)"
	default n
	depends on NC
	help

networking/nc.c+5 -0

@@ -9,6 +9,10 @@

	#include "busybox.h"

+	#if ENABLE_DESKTOP
+	#include "nc_bloaty.c"
+	#else
+
	/* Lots of small differences in features
	* when compared to "standard" nc
	*/
@@ -195,3 +199,4 @@ int nc_main(int argc, char **argv)
	}
	}
	}
+	#endif

networking/nc_bloaty.c+799 -0

@@ -0,0 +1,799 @@
+	/* Based on netcat 1.10 RELEASE 960320 written by [email protected].
+	* 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 [email protected].
+	* ...
+	* 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;
+	}