aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--include/libbb.h10
-rw-r--r--include/usage.h31
-rw-r--r--ipsvd/tcpudp.c2
-rw-r--r--libbb/Kbuild1
-rw-r--r--libbb/udp_io.c (renamed from ipsvd/udp_io.c)17
-rw-r--r--libbb/xconnect.c2
-rw-r--r--networking/Config.in2
-rw-r--r--networking/nc.c5
-rw-r--r--networking/nc_bloaty.c799
9 files changed, 857 insertions, 12 deletions
diff --git a/include/libbb.h b/include/libbb.h
index e5413b1a4..91715c16a 100644
--- a/include/libbb.h
+++ b/include/libbb.h
@@ -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);
diff --git a/include/usage.h b/include/usage.h
index c729532e5..fe4cd903c 100644
--- a/include/usage.h
+++ b/include/usage.h
@@ -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 \
diff --git a/ipsvd/tcpudp.c b/ipsvd/tcpudp.c
index d2e34e3e8..8c15d4b3e 100644
--- a/ipsvd/tcpudp.c
+++ b/ipsvd/tcpudp.c
@@ -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
diff --git a/libbb/Kbuild b/libbb/Kbuild
index a3b78ef28..bdf25da09 100644
--- a/libbb/Kbuild
+++ b/libbb/Kbuild
@@ -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
diff --git a/ipsvd/udp_io.c b/libbb/udp_io.c
index 592d98b58..d834a237b 100644
--- a/ipsvd/udp_io.c
+++ b/libbb/udp_io.c
@@ -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
diff --git a/libbb/xconnect.c b/libbb/xconnect.c
index 3c1eec943..8466325c7 100644
--- a/libbb/xconnect.c
+++ b/libbb/xconnect.c
@@ -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;
diff --git a/networking/Config.in b/networking/Config.in
index f78056827..a40770540 100644
--- a/networking/Config.in
+++ b/networking/Config.in
@@ -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
diff --git a/networking/nc.c b/networking/nc.c
index bc7c701fe..e89eb7615 100644
--- a/networking/nc.c
+++ b/networking/nc.c
@@ -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
diff --git a/networking/nc_bloaty.c b/networking/nc_bloaty.c
new file mode 100644
index 000000000..260d2057a
--- /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;
+}