1/* $OpenBSD: netcat.c,v 1.130 2015/07/26 19:12:28 chl Exp $ */
2/*
3 * Copyright (c) 2001 Eric Jackson <ericj@monkey.org>
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 *   notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *   notice, this list of conditions and the following disclaimer in the
13 *   documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 *   derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD$
29 */
30
31/*
32 * Re-written nc(1) for OpenBSD. Original implementation by
33 * *Hobbit* <hobbit@avian.org>.
34 */
35
36#include <errno.h>
37#include <stdio.h>
38#include <sys/arb.h>
39#include <sys/limits.h>
40#include <sys/types.h>
41#include <sys/sbuf.h>
42#include <sys/socket.h>
43#include <sys/sysctl.h>
44#include <sys/qmath.h>
45#include <sys/stats.h>
46#include <sys/time.h>
47#include <sys/uio.h>
48#include <sys/un.h>
49
50#include <netinet/in.h>
51#ifdef IPSEC
52#include <netipsec/ipsec.h>
53#endif
54#include <netinet/tcp.h>
55#include <netinet/ip.h>
56#include <arpa/telnet.h>
57
58#include <err.h>
59#include <getopt.h>
60#include <fcntl.h>
61#include <limits.h>
62#include <netdb.h>
63#include <poll.h>
64#include <signal.h>
65#include <stdarg.h>
66#include <stdlib.h>
67#include <string.h>
68#include <unistd.h>
69#include "atomicio.h"
70
71#ifndef SUN_LEN
72#define SUN_LEN(su) \
73	(sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
74#endif
75
76#define PORT_MAX	65535
77#define PORT_MAX_LEN	6
78#define UNIX_DG_TMP_SOCKET_SIZE	19
79
80#define POLL_STDIN 0
81#define POLL_NETOUT 1
82#define POLL_NETIN 2
83#define POLL_STDOUT 3
84#define BUFSIZE 16384
85
86/* Command Line Options */
87int	dflag;					/* detached, no stdin */
88int	Fflag;					/* fdpass sock to stdout */
89unsigned int iflag;				/* Interval Flag */
90int	kflag;					/* More than one connect */
91int	lflag;					/* Bind to local port */
92int	FreeBSD_Mflag;				/* Measure using stats(3) */
93int	Nflag;					/* shutdown() network socket */
94int	nflag;					/* Don't do name look up */
95int	FreeBSD_Oflag;				/* Do not use TCP options */
96int	FreeBSD_sctp;				/* Use SCTP */
97char   *Pflag;					/* Proxy username */
98char   *pflag;					/* Localport flag */
99int	rflag;					/* Random ports flag */
100char   *sflag;					/* Source Address */
101int	tflag;					/* Telnet Emulation */
102int	uflag;					/* UDP - Default to TCP */
103int	vflag;					/* Verbosity */
104int	xflag;					/* Socks proxy */
105int	zflag;					/* Port Scan Flag */
106int	Dflag;					/* sodebug */
107int	Iflag;					/* TCP receive buffer size */
108int	Oflag;					/* TCP send buffer size */
109int	Sflag;					/* TCP MD5 signature option */
110int	Tflag = -1;				/* IP Type of Service */
111int	rtableid = -1;
112
113int timeout = -1;
114int family = AF_UNSPEC;
115char *portlist[PORT_MAX+1];
116char *unix_dg_tmp_socket;
117
118void	atelnet(int, unsigned char *, unsigned int);
119void	build_ports(char *);
120void	help(void);
121int	local_listen(char *, char *, struct addrinfo);
122void	readwrite(int);
123void	fdpass(int nfd) __attribute__((noreturn));
124int	remote_connect(const char *, const char *, struct addrinfo);
125int	timeout_connect(int, const struct sockaddr *, socklen_t);
126int	socks_connect(const char *, const char *, struct addrinfo,
127	    const char *, const char *, struct addrinfo, int, const char *);
128int	udptest(int);
129int	unix_bind(char *);
130int	unix_connect(char *);
131int	unix_listen(char *);
132void	FreeBSD_stats_setup(int);
133void	FreeBSD_stats_print(int);
134void	set_common_sockopts(int, int);
135int	map_tos(char *, int *);
136void	report_connect(const struct sockaddr *, socklen_t);
137void	usage(int);
138ssize_t drainbuf(int, unsigned char *, size_t *);
139ssize_t fillbuf(int, unsigned char *, size_t *);
140
141#ifdef IPSEC
142void	add_ipsec_policy(int, int, char *);
143
144char	*ipsec_policy[2];
145#endif
146
147int
148main(int argc, char *argv[])
149{
150	int ch, s, ret, socksv, ipsec_count;
151	int numfibs;
152	size_t intsize = sizeof(int);
153	char *host, *uport;
154	struct addrinfo hints;
155	struct servent *sv;
156	socklen_t len;
157	struct sockaddr_storage cliaddr;
158	char *proxy;
159	const char *errstr, *proxyhost = "", *proxyport = NULL;
160	struct addrinfo proxyhints;
161	char unix_dg_tmp_socket_buf[UNIX_DG_TMP_SOCKET_SIZE];
162	struct option longopts[] = {
163		{ "no-tcpopt",	no_argument,	&FreeBSD_Oflag,	1 },
164		{ "sctp",	no_argument,	&FreeBSD_sctp,	1 },
165		{ NULL,		0,		NULL,		0 }
166	};
167
168	ret = 1;
169	ipsec_count = 0;
170	s = 0;
171	socksv = 5;
172	host = NULL;
173	uport = NULL;
174	sv = NULL;
175
176	signal(SIGPIPE, SIG_IGN);
177
178	while ((ch = getopt_long(argc, argv,
179	    "46DdEe:FhI:i:klMNnoO:P:p:rSs:tT:UuV:vw:X:x:z",
180	    longopts, NULL)) != -1) {
181		switch (ch) {
182		case '4':
183			family = AF_INET;
184			break;
185		case '6':
186			family = AF_INET6;
187			break;
188		case 'U':
189			family = AF_UNIX;
190			break;
191		case 'X':
192			if (strcasecmp(optarg, "connect") == 0)
193				socksv = -1; /* HTTP proxy CONNECT */
194			else if (strcmp(optarg, "4") == 0)
195				socksv = 4; /* SOCKS v.4 */
196			else if (strcmp(optarg, "5") == 0)
197				socksv = 5; /* SOCKS v.5 */
198			else
199				errx(1, "unsupported proxy protocol");
200			break;
201		case 'd':
202			dflag = 1;
203			break;
204		case 'e':
205#ifdef IPSEC
206			ipsec_policy[ipsec_count++ % 2] = optarg;
207#else
208			errx(1, "IPsec support unavailable.");
209#endif
210			break;
211		case 'E':
212#ifdef IPSEC
213			ipsec_policy[0] = "in  ipsec esp/transport//require";
214			ipsec_policy[1] = "out ipsec esp/transport//require";
215#else
216			errx(1, "IPsec support unavailable.");
217#endif
218			break;
219		case 'F':
220			Fflag = 1;
221			break;
222		case 'h':
223			help();
224			break;
225		case 'i':
226			iflag = strtonum(optarg, 0, UINT_MAX, &errstr);
227			if (errstr)
228				errx(1, "interval %s: %s", errstr, optarg);
229			break;
230		case 'k':
231			kflag = 1;
232			break;
233		case 'l':
234			lflag = 1;
235			break;
236		case 'M':
237#ifndef WITH_STATS
238			errx(1, "-M requires stats(3) support");
239#else
240			FreeBSD_Mflag = 1;
241#endif
242			break;
243		case 'N':
244			Nflag = 1;
245			break;
246		case 'n':
247			nflag = 1;
248			break;
249		case 'o':
250			fprintf(stderr, "option -o is deprecated.\n");
251			break;
252		case 'P':
253			Pflag = optarg;
254			break;
255		case 'p':
256			pflag = optarg;
257			break;
258		case 'r':
259			rflag = 1;
260			break;
261		case 's':
262			sflag = optarg;
263			break;
264		case 't':
265			tflag = 1;
266			break;
267		case 'u':
268			uflag = 1;
269			break;
270		case 'V':
271			if (sysctlbyname("net.fibs", &numfibs, &intsize, NULL, 0) == -1)
272				errx(1, "Multiple FIBS not supported");
273			rtableid = (int)strtonum(optarg, 0,
274			    numfibs - 1, &errstr);
275			if (errstr)
276				errx(1, "rtable %s: %s", errstr, optarg);
277			break;
278		case 'v':
279			vflag = 1;
280			break;
281		case 'w':
282			timeout = strtonum(optarg, 0, INT_MAX / 1000, &errstr);
283			if (errstr)
284				errx(1, "timeout %s: %s", errstr, optarg);
285			timeout *= 1000;
286			break;
287		case 'x':
288			xflag = 1;
289			if ((proxy = strdup(optarg)) == NULL)
290				err(1, NULL);
291			break;
292		case 'z':
293			zflag = 1;
294			break;
295		case 'D':
296			Dflag = 1;
297			break;
298		case 'I':
299			Iflag = strtonum(optarg, 1, 65536 << 14, &errstr);
300			if (errstr != NULL)
301				errx(1, "TCP receive window %s: %s",
302				    errstr, optarg);
303			break;
304		case 'O':
305			Oflag = strtonum(optarg, 1, 65536 << 14, &errstr);
306			if (errstr != NULL) {
307			    if (strcmp(errstr, "invalid") != 0)
308				errx(1, "TCP send window %s: %s",
309				    errstr, optarg);
310			}
311			break;
312		case 'S':
313			Sflag = 1;
314			break;
315		case 'T':
316			errstr = NULL;
317			errno = 0;
318			if (map_tos(optarg, &Tflag))
319				break;
320			if (strlen(optarg) > 1 && optarg[0] == '0' &&
321			    optarg[1] == 'x')
322				Tflag = (int)strtol(optarg, NULL, 16);
323			else
324				Tflag = (int)strtonum(optarg, 0, 255,
325				    &errstr);
326			if (Tflag < 0 || Tflag > 255 || errstr || errno)
327				errx(1, "illegal tos value %s", optarg);
328			break;
329		case 0:
330			/* Long option. */
331			break;
332		default:
333			usage(1);
334		}
335	}
336	argc -= optind;
337	argv += optind;
338
339	/* Cruft to make sure options are clean, and used properly. */
340	if (argv[0] && !argv[1] && family == AF_UNIX) {
341		host = argv[0];
342		uport = NULL;
343	} else if (argv[0] && !argv[1]) {
344		if  (!lflag)
345			usage(1);
346		uport = argv[0];
347		host = NULL;
348	} else if (argv[0] && argv[1]) {
349		host = argv[0];
350		uport = argv[1];
351	} else
352		usage(1);
353
354	if (lflag && sflag)
355		errx(1, "cannot use -s and -l");
356	if (lflag && pflag)
357		errx(1, "cannot use -p and -l");
358	if (lflag && zflag)
359		errx(1, "cannot use -z and -l");
360	if (!lflag && kflag)
361		errx(1, "must use -l with -k");
362	if (FreeBSD_sctp) {
363		if (uflag)
364			errx(1, "cannot use -u and --sctp");
365		if (family == AF_UNIX)
366			errx(1, "cannot use -U and --sctp");
367	}
368
369	/* Get name of temporary socket for unix datagram client */
370	if ((family == AF_UNIX) && uflag && !lflag) {
371		if (sflag) {
372			unix_dg_tmp_socket = sflag;
373		} else {
374			strlcpy(unix_dg_tmp_socket_buf, "/tmp/nc.XXXXXXXXXX",
375				UNIX_DG_TMP_SOCKET_SIZE);
376			if (mktemp(unix_dg_tmp_socket_buf) == NULL)
377				err(1, "mktemp");
378			unix_dg_tmp_socket = unix_dg_tmp_socket_buf;
379		}
380	}
381
382	/* Initialize addrinfo structure. */
383	if (family != AF_UNIX) {
384		memset(&hints, 0, sizeof(struct addrinfo));
385		hints.ai_family = family;
386		hints.ai_socktype = uflag ? SOCK_DGRAM : SOCK_STREAM;
387		hints.ai_protocol = uflag ? IPPROTO_UDP :
388		    FreeBSD_sctp ? IPPROTO_SCTP : IPPROTO_TCP;
389		if (nflag)
390			hints.ai_flags |= AI_NUMERICHOST;
391	}
392
393	if (xflag) {
394		if (uflag)
395			errx(1, "no proxy support for UDP mode");
396
397		if (FreeBSD_sctp)
398			errx(1, "no proxy support for SCTP mode");
399
400		if (lflag)
401			errx(1, "no proxy support for listen");
402
403		if (family == AF_UNIX)
404			errx(1, "no proxy support for unix sockets");
405
406		/* XXX IPv6 transport to proxy would probably work */
407		if (family == AF_INET6)
408			errx(1, "no proxy support for IPv6");
409
410		if (sflag)
411			errx(1, "no proxy support for local source address");
412
413		proxyhost = strsep(&proxy, ":");
414		proxyport = proxy;
415
416		memset(&proxyhints, 0, sizeof(struct addrinfo));
417		proxyhints.ai_family = family;
418		proxyhints.ai_socktype = SOCK_STREAM;
419		proxyhints.ai_protocol = IPPROTO_TCP;
420		if (nflag)
421			proxyhints.ai_flags |= AI_NUMERICHOST;
422	}
423
424	if (lflag) {
425		int connfd;
426		ret = 0;
427
428		if (family == AF_UNIX) {
429			if (uflag)
430				s = unix_bind(host);
431			else
432				s = unix_listen(host);
433		}
434
435		/* Allow only one connection at a time, but stay alive. */
436		for (;;) {
437			if (family != AF_UNIX)
438				s = local_listen(host, uport, hints);
439			if (s < 0)
440				err(1, NULL);
441			/*
442			 * For UDP and -k, don't connect the socket, let it
443			 * receive datagrams from multiple socket pairs.
444			 */
445			if (uflag && kflag)
446				readwrite(s);
447			/*
448			 * For UDP and not -k, we will use recvfrom() initially
449			 * to wait for a caller, then use the regular functions
450			 * to talk to the caller.
451			 */
452			else if (uflag && !kflag) {
453				int rv, plen;
454				char buf[16384];
455				struct sockaddr_storage z;
456
457				len = sizeof(z);
458				plen = 2048;
459				rv = recvfrom(s, buf, plen, MSG_PEEK,
460				    (struct sockaddr *)&z, &len);
461				if (rv < 0)
462					err(1, "recvfrom");
463
464				rv = connect(s, (struct sockaddr *)&z, len);
465				if (rv < 0)
466					err(1, "connect");
467
468				if (vflag)
469					report_connect((struct sockaddr *)&z, len);
470
471				readwrite(s);
472			} else {
473				len = sizeof(cliaddr);
474				connfd = accept(s, (struct sockaddr *)&cliaddr,
475				    &len);
476				if (connfd == -1) {
477					/* For now, all errnos are fatal */
478					err(1, "accept");
479				}
480				if (vflag)
481					report_connect((struct sockaddr *)&cliaddr, len);
482
483				if (FreeBSD_Mflag)
484					FreeBSD_stats_setup(connfd);
485				readwrite(connfd);
486				close(connfd);
487			}
488
489			if (family != AF_UNIX)
490				close(s);
491			else if (uflag) {
492				if (connect(s, NULL, 0) < 0)
493					err(1, "connect");
494			}
495
496			if (!kflag)
497				break;
498		}
499	} else if (family == AF_UNIX) {
500		ret = 0;
501
502		if ((s = unix_connect(host)) > 0 && !zflag) {
503			readwrite(s);
504			close(s);
505		} else
506			ret = 1;
507
508		if (uflag)
509			unlink(unix_dg_tmp_socket);
510		exit(ret);
511
512	} else {
513		int i = 0;
514
515		/* Construct the portlist[] array. */
516		build_ports(uport);
517
518		/* Cycle through portlist, connecting to each port. */
519		for (i = 0; portlist[i] != NULL; i++) {
520			if (s)
521				close(s);
522
523			if (xflag)
524				s = socks_connect(host, portlist[i], hints,
525				    proxyhost, proxyport, proxyhints, socksv,
526				    Pflag);
527			else
528				s = remote_connect(host, portlist[i], hints);
529
530			if (s < 0)
531				continue;
532
533			ret = 0;
534			if (vflag || zflag) {
535				/* For UDP, make sure we are connected. */
536				if (uflag) {
537					if (udptest(s) == -1) {
538						ret = 1;
539						continue;
540					}
541				}
542
543				/* Don't look up port if -n. */
544				if (nflag)
545					sv = NULL;
546				else {
547					sv = getservbyport(
548					    ntohs(atoi(portlist[i])),
549					    uflag ? "udp" : "tcp");
550				}
551
552				fprintf(stderr,
553				    "Connection to %s %s port [%s/%s] "
554				    "succeeded!\n", host, portlist[i],
555				    uflag ? "udp" : "tcp",
556				    sv ? sv->s_name : "*");
557			}
558			if (Fflag)
559				fdpass(s);
560			else if (!zflag)
561				readwrite(s);
562		}
563	}
564
565	if (s)
566		close(s);
567
568	exit(ret);
569}
570
571/*
572 * unix_bind()
573 * Returns a unix socket bound to the given path
574 */
575int
576unix_bind(char *path)
577{
578	struct sockaddr_un sun;
579	int s;
580
581	/* Create unix domain socket. */
582	if ((s = socket(AF_UNIX, uflag ? SOCK_DGRAM : SOCK_STREAM,
583	     0)) < 0)
584		return (-1);
585
586	memset(&sun, 0, sizeof(struct sockaddr_un));
587	sun.sun_family = AF_UNIX;
588
589	if (strlcpy(sun.sun_path, path, sizeof(sun.sun_path)) >=
590	    sizeof(sun.sun_path)) {
591		close(s);
592		errno = ENAMETOOLONG;
593		return (-1);
594	}
595
596	if (bind(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) < 0) {
597		close(s);
598		return (-1);
599	}
600	return (s);
601}
602
603/*
604 * unix_connect()
605 * Returns a socket connected to a local unix socket. Returns -1 on failure.
606 */
607int
608unix_connect(char *path)
609{
610	struct sockaddr_un sun;
611	int s;
612
613	if (uflag) {
614		if ((s = unix_bind(unix_dg_tmp_socket)) < 0)
615			return (-1);
616	} else {
617		if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
618			return (-1);
619	}
620	(void)fcntl(s, F_SETFD, FD_CLOEXEC);
621
622	memset(&sun, 0, sizeof(struct sockaddr_un));
623	sun.sun_family = AF_UNIX;
624
625	if (strlcpy(sun.sun_path, path, sizeof(sun.sun_path)) >=
626	    sizeof(sun.sun_path)) {
627		close(s);
628		errno = ENAMETOOLONG;
629		return (-1);
630	}
631	if (connect(s, (struct sockaddr *)&sun, SUN_LEN(&sun)) < 0) {
632		close(s);
633		return (-1);
634	}
635	return (s);
636
637}
638
639/*
640 * unix_listen()
641 * Create a unix domain socket, and listen on it.
642 */
643int
644unix_listen(char *path)
645{
646	int s;
647	if ((s = unix_bind(path)) < 0)
648		return (-1);
649
650	if (listen(s, 5) < 0) {
651		close(s);
652		return (-1);
653	}
654	return (s);
655}
656
657/*
658 * remote_connect()
659 * Returns a socket connected to a remote host. Properly binds to a local
660 * port or source address if needed. Returns -1 on failure.
661 */
662int
663remote_connect(const char *host, const char *port, struct addrinfo hints)
664{
665	struct addrinfo *res, *res0;
666	int s, error, on = 1;
667
668	if ((error = getaddrinfo(host, port, &hints, &res)))
669		errx(1, "getaddrinfo: %s", gai_strerror(error));
670
671	res0 = res;
672	do {
673		if ((s = socket(res0->ai_family, res0->ai_socktype,
674		    res0->ai_protocol)) < 0)
675			continue;
676
677		if (rtableid >= 0 && (setsockopt(s, SOL_SOCKET, SO_SETFIB,
678		    &rtableid, sizeof(rtableid)) == -1))
679			err(1, "setsockopt SO_SETFIB");
680
681		/* Bind to a local port or source address if specified. */
682		if (sflag || pflag) {
683			struct addrinfo ahints, *ares;
684
685			/* try IP_BINDANY, but don't insist */
686			setsockopt(s, IPPROTO_IP, IP_BINDANY, &on, sizeof(on));
687			memset(&ahints, 0, sizeof(struct addrinfo));
688			ahints.ai_family = res0->ai_family;
689			ahints.ai_socktype = uflag ? SOCK_DGRAM : SOCK_STREAM;
690			ahints.ai_protocol = uflag ? IPPROTO_UDP : IPPROTO_TCP;
691			ahints.ai_flags = AI_PASSIVE;
692			if ((error = getaddrinfo(sflag, pflag, &ahints, &ares)))
693				errx(1, "getaddrinfo: %s", gai_strerror(error));
694
695			if (bind(s, (struct sockaddr *)ares->ai_addr,
696			    ares->ai_addrlen) < 0)
697				err(1, "bind failed");
698			freeaddrinfo(ares);
699		}
700
701		set_common_sockopts(s, res0->ai_family);
702
703		if (timeout_connect(s, res0->ai_addr, res0->ai_addrlen) == 0)
704			break;
705		else if (vflag)
706			warn("connect to %s port %s (%s) failed", host, port,
707			    uflag ? "udp" : "tcp");
708
709		close(s);
710		s = -1;
711	} while ((res0 = res0->ai_next) != NULL);
712
713	freeaddrinfo(res);
714
715	return (s);
716}
717
718int
719timeout_connect(int s, const struct sockaddr *name, socklen_t namelen)
720{
721	struct pollfd pfd;
722	socklen_t optlen;
723	int flags, optval;
724	int ret;
725
726	if (timeout != -1) {
727		flags = fcntl(s, F_GETFL, 0);
728		if (fcntl(s, F_SETFL, flags | O_NONBLOCK) == -1)
729			err(1, "set non-blocking mode");
730	}
731
732	if ((ret = connect(s, name, namelen)) != 0 && errno == EINPROGRESS) {
733		pfd.fd = s;
734		pfd.events = POLLOUT;
735		if ((ret = poll(&pfd, 1, timeout)) == 1) {
736			optlen = sizeof(optval);
737			if ((ret = getsockopt(s, SOL_SOCKET, SO_ERROR,
738			    &optval, &optlen)) == 0) {
739				errno = optval;
740				ret = optval == 0 ? 0 : -1;
741			}
742		} else if (ret == 0) {
743			errno = ETIMEDOUT;
744			ret = -1;
745		} else
746			err(1, "poll failed");
747	}
748
749	if (timeout != -1 && fcntl(s, F_SETFL, flags) == -1)
750		err(1, "restoring flags");
751
752	return (ret);
753}
754
755/*
756 * local_listen()
757 * Returns a socket listening on a local port, binds to specified source
758 * address. Returns -1 on failure.
759 */
760int
761local_listen(char *host, char *port, struct addrinfo hints)
762{
763	struct addrinfo *res, *res0;
764	int s, ret, x = 1;
765	int error;
766
767	/* Allow nodename to be null. */
768	hints.ai_flags |= AI_PASSIVE;
769
770	/*
771	 * In the case of binding to a wildcard address
772	 * default to binding to an ipv4 address.
773	 */
774	if (host == NULL && hints.ai_family == AF_UNSPEC)
775		hints.ai_family = AF_INET;
776
777	if ((error = getaddrinfo(host, port, &hints, &res)))
778		errx(1, "getaddrinfo: %s", gai_strerror(error));
779
780	res0 = res;
781	do {
782		if ((s = socket(res0->ai_family, res0->ai_socktype,
783		    res0->ai_protocol)) < 0)
784			continue;
785
786		if (rtableid >= 0 && (setsockopt(s, SOL_SOCKET, SO_SETFIB,
787		    &rtableid, sizeof(rtableid)) == -1))
788			err(1, "setsockopt SO_SETFIB");
789
790		ret = setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &x, sizeof(x));
791		if (ret == -1)
792			err(1, NULL);
793
794		if (FreeBSD_Oflag) {
795			if (setsockopt(s, IPPROTO_TCP, TCP_NOOPT,
796			    &FreeBSD_Oflag, sizeof(FreeBSD_Oflag)) == -1)
797				err(1, "disable TCP options");
798		}
799
800		set_common_sockopts(s, res0->ai_family);
801
802		if (bind(s, (struct sockaddr *)res0->ai_addr,
803		    res0->ai_addrlen) == 0)
804			break;
805
806		close(s);
807		s = -1;
808	} while ((res0 = res0->ai_next) != NULL);
809
810	if (!uflag && s != -1) {
811		if (listen(s, 1) < 0)
812			err(1, "listen");
813	}
814
815	freeaddrinfo(res);
816
817	return (s);
818}
819
820/*
821 * readwrite()
822 * Loop that polls on the network file descriptor and stdin.
823 */
824void
825readwrite(int net_fd)
826{
827	struct pollfd pfd[4];
828	int stdin_fd = STDIN_FILENO;
829	int stdout_fd = STDOUT_FILENO;
830	unsigned char netinbuf[BUFSIZE];
831	size_t netinbufpos = 0;
832	unsigned char stdinbuf[BUFSIZE];
833	size_t stdinbufpos = 0;
834	int n, num_fds;
835	int stats_printed = 0;
836	ssize_t ret;
837
838	/* don't read from stdin if requested */
839	if (dflag)
840		stdin_fd = -1;
841
842	/* stdin */
843	pfd[POLL_STDIN].fd = stdin_fd;
844	pfd[POLL_STDIN].events = POLLIN;
845
846	/* network out */
847	pfd[POLL_NETOUT].fd = net_fd;
848	pfd[POLL_NETOUT].events = 0;
849
850	/* network in */
851	pfd[POLL_NETIN].fd = net_fd;
852	pfd[POLL_NETIN].events = POLLIN;
853
854	/* stdout */
855	pfd[POLL_STDOUT].fd = stdout_fd;
856	pfd[POLL_STDOUT].events = 0;
857
858	while (1) {
859		/* both inputs are gone, buffers are empty, we are done */
860		if (pfd[POLL_STDIN].fd == -1 && pfd[POLL_NETIN].fd == -1
861		    && stdinbufpos == 0 && netinbufpos == 0) {
862			if (FreeBSD_Mflag && !stats_printed)
863				FreeBSD_stats_print(net_fd);
864			close(net_fd);
865			return;
866		}
867		/* both outputs are gone, we can't continue */
868		if (pfd[POLL_NETOUT].fd == -1 && pfd[POLL_STDOUT].fd == -1) {
869			if (FreeBSD_Mflag && !stats_printed)
870				FreeBSD_stats_print(net_fd);
871			close(net_fd);
872			return;
873		}
874		/* listen and net in gone, queues empty, done */
875		if (lflag && pfd[POLL_NETIN].fd == -1
876		    && stdinbufpos == 0 && netinbufpos == 0) {
877			if (FreeBSD_Mflag && !stats_printed)
878				FreeBSD_stats_print(net_fd);
879			close(net_fd);
880			return;
881		}
882
883		/* help says -i is for "wait between lines sent". We read and
884		 * write arbitrary amounts of data, and we don't want to start
885		 * scanning for newlines, so this is as good as it gets */
886		if (iflag)
887			sleep(iflag);
888
889		/* poll */
890		num_fds = poll(pfd, 4, timeout);
891
892		/* treat poll errors */
893		if (num_fds == -1) {
894			close(net_fd);
895			err(1, "polling error");
896		}
897
898		/* timeout happened */
899		if (num_fds == 0) {
900			if (FreeBSD_Mflag)
901				FreeBSD_stats_print(net_fd);
902			return;
903		}
904
905		/* treat socket error conditions */
906		for (n = 0; n < 4; n++) {
907			if (pfd[n].revents & (POLLERR|POLLNVAL)) {
908				pfd[n].fd = -1;
909			}
910		}
911		/* reading is possible after HUP */
912		if (pfd[POLL_STDIN].events & POLLIN &&
913		    pfd[POLL_STDIN].revents & POLLHUP &&
914		    ! (pfd[POLL_STDIN].revents & POLLIN))
915				pfd[POLL_STDIN].fd = -1;
916
917		if (pfd[POLL_NETIN].events & POLLIN &&
918		    pfd[POLL_NETIN].revents & POLLHUP &&
919		    ! (pfd[POLL_NETIN].revents & POLLIN))
920				pfd[POLL_NETIN].fd = -1;
921
922		if (pfd[POLL_NETOUT].revents & POLLHUP) {
923			if (Nflag)
924				shutdown(pfd[POLL_NETOUT].fd, SHUT_WR);
925			pfd[POLL_NETOUT].fd = -1;
926		}
927		/* if HUP, stop watching stdout */
928		if (pfd[POLL_STDOUT].revents & POLLHUP)
929			pfd[POLL_STDOUT].fd = -1;
930		/* if no net out, stop watching stdin */
931		if (pfd[POLL_NETOUT].fd == -1)
932			pfd[POLL_STDIN].fd = -1;
933		/* if no stdout, stop watching net in */
934		if (pfd[POLL_STDOUT].fd == -1) {
935			if (pfd[POLL_NETIN].fd != -1)
936				shutdown(pfd[POLL_NETIN].fd, SHUT_RD);
937			pfd[POLL_NETIN].fd = -1;
938		}
939
940		/* try to read from stdin */
941		if (pfd[POLL_STDIN].revents & POLLIN && stdinbufpos < BUFSIZE) {
942			ret = fillbuf(pfd[POLL_STDIN].fd, stdinbuf,
943			    &stdinbufpos);
944			/* error or eof on stdin - remove from pfd */
945			if (ret == 0 || ret == -1)
946				pfd[POLL_STDIN].fd = -1;
947			/* read something - poll net out */
948			if (stdinbufpos > 0)
949				pfd[POLL_NETOUT].events = POLLOUT;
950			/* filled buffer - remove self from polling */
951			if (stdinbufpos == BUFSIZE)
952				pfd[POLL_STDIN].events = 0;
953		}
954		/* try to write to network */
955		if (pfd[POLL_NETOUT].revents & POLLOUT && stdinbufpos > 0) {
956			ret = drainbuf(pfd[POLL_NETOUT].fd, stdinbuf,
957			    &stdinbufpos);
958			if (ret == -1)
959				pfd[POLL_NETOUT].fd = -1;
960			/* buffer empty - remove self from polling */
961			if (stdinbufpos == 0)
962				pfd[POLL_NETOUT].events = 0;
963			/* buffer no longer full - poll stdin again */
964			if (stdinbufpos < BUFSIZE)
965				pfd[POLL_STDIN].events = POLLIN;
966		}
967		/* try to read from network */
968		if (pfd[POLL_NETIN].revents & POLLIN && netinbufpos < BUFSIZE) {
969			ret = fillbuf(pfd[POLL_NETIN].fd, netinbuf,
970			    &netinbufpos);
971			if (ret == -1)
972				pfd[POLL_NETIN].fd = -1;
973			/* eof on net in - remove from pfd */
974			if (ret == 0) {
975				shutdown(pfd[POLL_NETIN].fd, SHUT_RD);
976				pfd[POLL_NETIN].fd = -1;
977			}
978			/* read something - poll stdout */
979			if (netinbufpos > 0)
980				pfd[POLL_STDOUT].events = POLLOUT;
981			/* filled buffer - remove self from polling */
982			if (netinbufpos == BUFSIZE)
983				pfd[POLL_NETIN].events = 0;
984			/* handle telnet */
985			if (tflag)
986				atelnet(pfd[POLL_NETIN].fd, netinbuf,
987				    netinbufpos);
988		}
989		/* try to write to stdout */
990		if (pfd[POLL_STDOUT].revents & POLLOUT && netinbufpos > 0) {
991			ret = drainbuf(pfd[POLL_STDOUT].fd, netinbuf,
992			    &netinbufpos);
993			if (ret == -1)
994				pfd[POLL_STDOUT].fd = -1;
995			/* buffer empty - remove self from polling */
996			if (netinbufpos == 0)
997				pfd[POLL_STDOUT].events = 0;
998			/* buffer no longer full - poll net in again */
999			if (netinbufpos < BUFSIZE)
1000				pfd[POLL_NETIN].events = POLLIN;
1001		}
1002
1003		/* stdin gone and queue empty? */
1004		if (pfd[POLL_STDIN].fd == -1 && stdinbufpos == 0) {
1005			if (pfd[POLL_NETOUT].fd != -1 && Nflag) {
1006				if (FreeBSD_Mflag) {
1007					FreeBSD_stats_print(net_fd);
1008					stats_printed = 1;
1009				}
1010				shutdown(pfd[POLL_NETOUT].fd, SHUT_WR);
1011			}
1012			pfd[POLL_NETOUT].fd = -1;
1013		}
1014		/* net in gone and queue empty? */
1015		if (pfd[POLL_NETIN].fd == -1 && netinbufpos == 0) {
1016			pfd[POLL_STDOUT].fd = -1;
1017		}
1018	}
1019}
1020
1021ssize_t
1022drainbuf(int fd, unsigned char *buf, size_t *bufpos)
1023{
1024	ssize_t n;
1025	ssize_t adjust;
1026
1027	n = write(fd, buf, *bufpos);
1028	/* don't treat EAGAIN, EINTR as error */
1029	if (n == -1 && (errno == EAGAIN || errno == EINTR))
1030		n = -2;
1031	if (n <= 0)
1032		return n;
1033	/* adjust buffer */
1034	adjust = *bufpos - n;
1035	if (adjust > 0)
1036		memmove(buf, buf + n, adjust);
1037	*bufpos -= n;
1038	return n;
1039}
1040
1041
1042ssize_t
1043fillbuf(int fd, unsigned char *buf, size_t *bufpos)
1044{
1045	size_t num = BUFSIZE - *bufpos;
1046	ssize_t n;
1047
1048	n = read(fd, buf + *bufpos, num);
1049	/* don't treat EAGAIN, EINTR as error */
1050	if (n == -1 && (errno == EAGAIN || errno == EINTR))
1051		n = -2;
1052	if (n <= 0)
1053		return n;
1054	*bufpos += n;
1055	return n;
1056}
1057
1058/*
1059 * fdpass()
1060 * Pass the connected file descriptor to stdout and exit.
1061 */
1062void
1063fdpass(int nfd)
1064{
1065	struct msghdr mh;
1066	union {
1067		struct cmsghdr hdr;
1068		char buf[CMSG_SPACE(sizeof(int))];
1069	} cmsgbuf;
1070	struct cmsghdr *cmsg;
1071	struct iovec iov;
1072	char c = '\0';
1073	ssize_t r;
1074	struct pollfd pfd;
1075
1076	/* Avoid obvious stupidity */
1077	if (isatty(STDOUT_FILENO))
1078		errx(1, "Cannot pass file descriptor to tty");
1079
1080	bzero(&mh, sizeof(mh));
1081	bzero(&cmsgbuf, sizeof(cmsgbuf));
1082	bzero(&iov, sizeof(iov));
1083
1084	mh.msg_control = (caddr_t)&cmsgbuf.buf;
1085	mh.msg_controllen = sizeof(cmsgbuf.buf);
1086	cmsg = CMSG_FIRSTHDR(&mh);
1087	cmsg->cmsg_len = CMSG_LEN(sizeof(int));
1088	cmsg->cmsg_level = SOL_SOCKET;
1089	cmsg->cmsg_type = SCM_RIGHTS;
1090	*(int *)CMSG_DATA(cmsg) = nfd;
1091
1092	iov.iov_base = &c;
1093	iov.iov_len = 1;
1094	mh.msg_iov = &iov;
1095	mh.msg_iovlen = 1;
1096
1097	bzero(&pfd, sizeof(pfd));
1098	pfd.fd = STDOUT_FILENO;
1099	pfd.events = POLLOUT;
1100	for (;;) {
1101		r = sendmsg(STDOUT_FILENO, &mh, 0);
1102		if (r == -1) {
1103			if (errno == EAGAIN || errno == EINTR) {
1104				if (poll(&pfd, 1, -1) == -1)
1105					err(1, "poll");
1106				continue;
1107			}
1108			err(1, "sendmsg");
1109		} else if (r != 1)
1110			errx(1, "sendmsg: unexpected return value %zd", r);
1111		else
1112			break;
1113	}
1114	exit(0);
1115}
1116
1117/* Deal with RFC 854 WILL/WONT DO/DONT negotiation. */
1118void
1119atelnet(int nfd, unsigned char *buf, unsigned int size)
1120{
1121	unsigned char *p, *end;
1122	unsigned char obuf[4];
1123
1124	if (size < 3)
1125		return;
1126	end = buf + size - 2;
1127
1128	for (p = buf; p < end; p++) {
1129		if (*p != IAC)
1130			continue;
1131
1132		obuf[0] = IAC;
1133		p++;
1134		if ((*p == WILL) || (*p == WONT))
1135			obuf[1] = DONT;
1136		else if ((*p == DO) || (*p == DONT))
1137			obuf[1] = WONT;
1138		else
1139			continue;
1140
1141		p++;
1142		obuf[2] = *p;
1143		if (atomicio(vwrite, nfd, obuf, 3) != 3)
1144			warn("Write Error!");
1145	}
1146}
1147
1148/*
1149 * build_ports()
1150 * Build an array of ports in portlist[], listing each port
1151 * that we should try to connect to.
1152 */
1153void
1154build_ports(char *p)
1155{
1156	const char *errstr;
1157	char *n;
1158	int hi, lo, cp;
1159	int x = 0;
1160
1161	if ((n = strchr(p, '-')) != NULL) {
1162		*n = '\0';
1163		n++;
1164
1165		/* Make sure the ports are in order: lowest->highest. */
1166		hi = strtonum(n, 1, PORT_MAX, &errstr);
1167		if (errstr)
1168			errx(1, "port number %s: %s", errstr, n);
1169		lo = strtonum(p, 1, PORT_MAX, &errstr);
1170		if (errstr)
1171			errx(1, "port number %s: %s", errstr, p);
1172
1173		if (lo > hi) {
1174			cp = hi;
1175			hi = lo;
1176			lo = cp;
1177		}
1178
1179		/* Load ports sequentially. */
1180		for (cp = lo; cp <= hi; cp++) {
1181			portlist[x] = calloc(1, PORT_MAX_LEN);
1182			if (portlist[x] == NULL)
1183				err(1, NULL);
1184			snprintf(portlist[x], PORT_MAX_LEN, "%d", cp);
1185			x++;
1186		}
1187
1188		/* Randomly swap ports. */
1189		if (rflag) {
1190			int y;
1191			char *c;
1192
1193			for (x = 0; x <= (hi - lo); x++) {
1194				y = (arc4random() & 0xFFFF) % (hi - lo);
1195				c = portlist[x];
1196				portlist[x] = portlist[y];
1197				portlist[y] = c;
1198			}
1199		}
1200	} else {
1201		hi = strtonum(p, 1, PORT_MAX, &errstr);
1202		if (errstr)
1203			errx(1, "port number %s: %s", errstr, p);
1204		portlist[0] = strdup(p);
1205		if (portlist[0] == NULL)
1206			err(1, NULL);
1207	}
1208}
1209
1210/*
1211 * udptest()
1212 * Do a few writes to see if the UDP port is there.
1213 * Fails once PF state table is full.
1214 */
1215int
1216udptest(int s)
1217{
1218	int i, ret;
1219
1220	for (i = 0; i <= 3; i++) {
1221		if (write(s, "X", 1) == 1)
1222			ret = 1;
1223		else
1224			ret = -1;
1225	}
1226	return (ret);
1227}
1228
1229void
1230FreeBSD_stats_setup(int s)
1231{
1232
1233	if (setsockopt(s, IPPROTO_TCP, TCP_STATS,
1234	    &FreeBSD_Mflag, sizeof(FreeBSD_Mflag)) == -1) {
1235		if (errno == EOPNOTSUPP) {
1236			warnx("getsockopt(TCP_STATS) failed; "
1237			    "kernel built without \"options STATS\"?");
1238		}
1239		err(1, "enable TCP_STATS gathering");
1240	}
1241}
1242
1243void
1244FreeBSD_stats_print(int s)
1245{
1246#ifdef WITH_STATS
1247	struct statsblob *statsb;
1248	struct sbuf *sb;
1249	socklen_t sockoptlen;
1250	int error;
1251
1252	/*
1253	 * This usleep is a workaround for TCP_STATS reporting
1254	 * incorrect values for TXPB.
1255	 */
1256	usleep(100000);
1257
1258	sockoptlen = 2048;
1259	statsb = malloc(sockoptlen);
1260	if (statsb == NULL)
1261		err(1, "malloc");
1262	error = getsockopt(s, IPPROTO_TCP, TCP_STATS, statsb, &sockoptlen);
1263	if (error != 0) {
1264		if (errno == EOVERFLOW && statsb->cursz > sockoptlen) {
1265			/* Retry with a larger size. */
1266			sockoptlen = statsb->cursz;
1267			statsb = realloc(statsb, sockoptlen);
1268			if (statsb == NULL)
1269				err(1, "realloc");
1270			error = getsockopt(s, IPPROTO_TCP, TCP_STATS,
1271			    statsb, &sockoptlen);
1272		}
1273		if (error != 0)
1274			err(1, "getsockopt");
1275	}
1276
1277	sb = sbuf_new_auto();
1278	error = stats_blob_tostr(statsb, sb, SB_STRFMT_JSON, SB_TOSTR_META);
1279	if (error != 0)
1280		errc(1, error, "stats_blob_tostr");
1281
1282	error = sbuf_finish(sb);
1283	if (error != 0)
1284		err(1, "sbuf_finish");
1285
1286	fprintf(stderr, "%s\n", sbuf_data(sb));
1287#endif
1288}
1289
1290void
1291set_common_sockopts(int s, int af)
1292{
1293	int x = 1;
1294
1295	if (Sflag) {
1296		if (setsockopt(s, IPPROTO_TCP, TCP_MD5SIG,
1297			&x, sizeof(x)) == -1)
1298			err(1, NULL);
1299	}
1300	if (Dflag) {
1301		if (setsockopt(s, SOL_SOCKET, SO_DEBUG,
1302			&x, sizeof(x)) == -1)
1303			err(1, NULL);
1304	}
1305	if (Tflag != -1) {
1306		int proto, option;
1307
1308		if (af == AF_INET6) {
1309			proto = IPPROTO_IPV6;
1310			option = IPV6_TCLASS;
1311		} else {
1312			proto = IPPROTO_IP;
1313			option = IP_TOS;
1314		}
1315
1316		if (setsockopt(s, proto, option, &Tflag, sizeof(Tflag)) == -1)
1317			err(1, "set IP ToS");
1318	}
1319	if (Iflag) {
1320		if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
1321		    &Iflag, sizeof(Iflag)) == -1)
1322			err(1, "set TCP receive buffer size");
1323	}
1324	if (Oflag) {
1325		if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
1326		    &Oflag, sizeof(Oflag)) == -1)
1327			err(1, "set TCP send buffer size");
1328	}
1329	if (FreeBSD_Oflag) {
1330		if (setsockopt(s, IPPROTO_TCP, TCP_NOOPT,
1331		    &FreeBSD_Oflag, sizeof(FreeBSD_Oflag)) == -1)
1332			err(1, "disable TCP options");
1333	}
1334	if (FreeBSD_Mflag)
1335		FreeBSD_stats_setup(s);
1336#ifdef IPSEC
1337	if (ipsec_policy[0] != NULL)
1338		add_ipsec_policy(s, af, ipsec_policy[0]);
1339	if (ipsec_policy[1] != NULL)
1340		add_ipsec_policy(s, af, ipsec_policy[1]);
1341#endif
1342}
1343
1344int
1345map_tos(char *s, int *val)
1346{
1347	/* DiffServ Codepoints and other TOS mappings */
1348	const struct toskeywords {
1349		const char	*keyword;
1350		int		 val;
1351	} *t, toskeywords[] = {
1352		{ "af11",		IPTOS_DSCP_AF11 },
1353		{ "af12",		IPTOS_DSCP_AF12 },
1354		{ "af13",		IPTOS_DSCP_AF13 },
1355		{ "af21",		IPTOS_DSCP_AF21 },
1356		{ "af22",		IPTOS_DSCP_AF22 },
1357		{ "af23",		IPTOS_DSCP_AF23 },
1358		{ "af31",		IPTOS_DSCP_AF31 },
1359		{ "af32",		IPTOS_DSCP_AF32 },
1360		{ "af33",		IPTOS_DSCP_AF33 },
1361		{ "af41",		IPTOS_DSCP_AF41 },
1362		{ "af42",		IPTOS_DSCP_AF42 },
1363		{ "af43",		IPTOS_DSCP_AF43 },
1364		{ "critical",		IPTOS_PREC_CRITIC_ECP },
1365		{ "cs0",		IPTOS_DSCP_CS0 },
1366		{ "cs1",		IPTOS_DSCP_CS1 },
1367		{ "cs2",		IPTOS_DSCP_CS2 },
1368		{ "cs3",		IPTOS_DSCP_CS3 },
1369		{ "cs4",		IPTOS_DSCP_CS4 },
1370		{ "cs5",		IPTOS_DSCP_CS5 },
1371		{ "cs6",		IPTOS_DSCP_CS6 },
1372		{ "cs7",		IPTOS_DSCP_CS7 },
1373		{ "ef",			IPTOS_DSCP_EF },
1374		{ "inetcontrol",	IPTOS_PREC_INTERNETCONTROL },
1375		{ "lowdelay",		IPTOS_LOWDELAY },
1376		{ "netcontrol",		IPTOS_PREC_NETCONTROL },
1377		{ "reliability",	IPTOS_RELIABILITY },
1378		{ "throughput",		IPTOS_THROUGHPUT },
1379		{ NULL, 		-1 },
1380	};
1381
1382	for (t = toskeywords; t->keyword != NULL; t++) {
1383		if (strcmp(s, t->keyword) == 0) {
1384			*val = t->val;
1385			return (1);
1386		}
1387	}
1388
1389	return (0);
1390}
1391
1392void
1393report_connect(const struct sockaddr *sa, socklen_t salen)
1394{
1395	char remote_host[NI_MAXHOST];
1396	char remote_port[NI_MAXSERV];
1397	int herr;
1398	int flags = NI_NUMERICSERV;
1399
1400	if (nflag)
1401		flags |= NI_NUMERICHOST;
1402
1403	if ((herr = getnameinfo(sa, salen,
1404	    remote_host, sizeof(remote_host),
1405	    remote_port, sizeof(remote_port),
1406	    flags)) != 0) {
1407		if (herr == EAI_SYSTEM)
1408			err(1, "getnameinfo");
1409		else
1410			errx(1, "getnameinfo: %s", gai_strerror(herr));
1411	}
1412
1413	fprintf(stderr,
1414	    "Connection from %s %s "
1415	    "received!\n", remote_host, remote_port);
1416}
1417
1418void
1419help(void)
1420{
1421	usage(0);
1422	fprintf(stderr, "\tCommand Summary:\n\
1423	\t-4		Use IPv4\n\
1424	\t-6		Use IPv6\n\
1425	\t-D		Enable the debug socket option\n\
1426	\t-d		Detach from stdin\n");
1427#ifdef IPSEC
1428	fprintf(stderr, "\
1429	\t-E		Use IPsec ESP\n\
1430	\t-e policy	Use specified IPsec policy\n");
1431#endif
1432	fprintf(stderr, "\
1433	\t-F		Pass socket fd\n\
1434	\t-h		This help text\n\
1435	\t-I length	TCP receive buffer length\n\
1436	\t-i secs\t	Delay interval for lines sent, ports scanned\n\
1437	\t-k		Keep inbound sockets open for multiple connects\n\
1438	\t-l		Listen mode, for inbound connects\n\
1439	\t-N		Shutdown the network socket after EOF on stdin\n\
1440	\t-n		Suppress name/port resolutions\n\
1441	\t--no-tcpopt	Disable TCP options\n\
1442	\t--sctp\t	SCTP mode\n\
1443	\t-O length	TCP send buffer length\n\
1444	\t-P proxyuser\tUsername for proxy authentication\n\
1445	\t-p port\t	Specify local port for remote connects\n\
1446	\t-r		Randomize remote ports\n\
1447	\t-S		Enable the TCP MD5 signature option\n\
1448	\t-s addr\t	Local source address\n\
1449	\t-T toskeyword\tSet IP Type of Service\n\
1450	\t-t		Answer TELNET negotiation\n\
1451	\t-U		Use UNIX domain socket\n\
1452	\t-u		UDP mode\n\
1453	\t-V rtable	Specify alternate routing table\n\
1454	\t-v		Verbose\n\
1455	\t-w secs\t	Timeout for connects and final net reads\n\
1456	\t-X proto	Proxy protocol: \"4\", \"5\" (SOCKS) or \"connect\"\n\
1457	\t-x addr[:port]\tSpecify proxy address and port\n\
1458	\t-z		Zero-I/O mode [used for scanning]\n\
1459	Port numbers can be individual or ranges: lo-hi [inclusive]\n");
1460#ifdef IPSEC
1461	fprintf(stderr, "\tSee ipsec_set_policy(3) for -e argument format\n");
1462#endif
1463	exit(1);
1464}
1465
1466#ifdef IPSEC
1467void
1468add_ipsec_policy(int s, int af, char *policy)
1469{
1470	char *raw;
1471	int e;
1472
1473	raw = ipsec_set_policy(policy, strlen(policy));
1474	if (raw == NULL)
1475		errx(1, "ipsec_set_policy `%s': %s", policy,
1476		     ipsec_strerror());
1477	if (af == AF_INET)
1478		e = setsockopt(s, IPPROTO_IP, IP_IPSEC_POLICY, raw,
1479		    ipsec_get_policylen(raw));
1480	if (af == AF_INET6)
1481		e = setsockopt(s, IPPROTO_IPV6, IPV6_IPSEC_POLICY, raw,
1482		    ipsec_get_policylen(raw));
1483	if (e < 0)
1484		err(1, "ipsec policy cannot be configured");
1485	free(raw);
1486	if (vflag)
1487		fprintf(stderr, "ipsec policy configured: `%s'\n", policy);
1488	return;
1489}
1490#endif /* IPSEC */
1491
1492void
1493usage(int ret)
1494{
1495	fprintf(stderr,
1496#ifdef IPSEC
1497	    "usage: nc [-46DdEFhklNnrStUuvz] [-e policy] [-I length] [-i interval] [-O length]\n"
1498#else
1499	    "usage: nc [-46DdFhklNnrStUuvz] [-I length] [-i interval] [-O length]\n"
1500#endif
1501	    "\t  [--no-tcpopt] [--sctp]\n"
1502	    "\t  [-P proxy_username] [-p source_port] [-s source] [-T ToS]\n"
1503	    "\t  [-V rtable] [-w timeout] [-X proxy_protocol]\n"
1504	    "\t  [-x proxy_address[:port]] [destination] [port]\n");
1505	if (ret)
1506		exit(1);
1507}
1508