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