emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nc: port nc 1.10 to busybox

Browse Source
This commit is contained in:
Denis Vlasenko 2007-04-05 20:26:28 +00:00
parent 00c2c4868a
commit 29fe7265b8
9 changed files with 857 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/libbb.h
View File

@ -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);

31
include/usage.h
View File

@ -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 \

2
ipsvd/tcpudp.c
View File

@ -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

1
libbb/Kbuild
View File

@ -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

17
ipsvd/udp_io.c → libbb/udp_io.c
View File

@ -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

2
libbb/xconnect.c
View File

@ -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;

2
networking/Config.in
View File

@ -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

5
networking/nc.c
View File

@ -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

799
networking/nc_bloaty.c Normal file
View File

@ -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;
}