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 */
87 int dflag; /* detached, no stdin */
88 int Fflag; /* fdpass sock to stdout */
89 unsigned int iflag; /* Interval Flag */
90 int kflag; /* More than one connect */
91 int lflag; /* Bind to local port */
92 int FreeBSD_Mflag; /* Measure using stats(3) */
93 int Nflag; /* shutdown() network socket */
94 int nflag; /* Don't do name look up */
95 int FreeBSD_Oflag; /* Do not use TCP options */
96 int FreeBSD_sctp; /* Use SCTP */
97 char *Pflag; /* Proxy username */
98 char *pflag; /* Localport flag */
99 int rflag; /* Random ports flag */
100 char *sflag; /* Source Address */
101 int tflag; /* Telnet Emulation */
102 int uflag; /* UDP - Default to TCP */
103 int vflag; /* Verbosity */
104 int xflag; /* Socks proxy */
105 int zflag; /* Port Scan Flag */
106 int Dflag; /* sodebug */
107 int Iflag; /* TCP receive buffer size */
108 int Oflag; /* TCP send buffer size */
109 int Sflag; /* TCP MD5 signature option */
110 int Tflag = -1; /* IP Type of Service */
111 int rtableid = -1;
112
113 int timeout = -1;
114 int family = AF_UNSPEC;
115 char *portlist[PORT_MAX+1];
116 char *unix_dg_tmp_socket;
117
118 void atelnet(int, unsigned char *, unsigned int);
119 void build_ports(char *);
120 void help(void);
121 int local_listen(char *, char *, struct addrinfo);
122 void readwrite(int);
123 void fdpass(int nfd) __attribute__((noreturn));
124 int remote_connect(const char *, const char *, struct addrinfo);
125 int timeout_connect(int, const struct sockaddr *, socklen_t);
126 int socks_connect(const char *, const char *, struct addrinfo,
127 const char *, const char *, struct addrinfo, int, const char *);
128 int udptest(int);
129 int unix_bind(char *);
130 int unix_connect(char *);
131 int unix_listen(char *);
132 void FreeBSD_stats_setup(int);
133 void FreeBSD_stats_print(int);
134 void set_common_sockopts(int, int);
135 int map_tos(char *, int *);
136 void report_connect(const struct sockaddr *, socklen_t);
137 void usage(int);
138 ssize_t drainbuf(int, unsigned char *, size_t *);
139 ssize_t fillbuf(int, unsigned char *, size_t *);
140
141 #ifdef IPSEC
142 void add_ipsec_policy(int, int, char *);
143
144 char *ipsec_policy[2];
145 #endif
146
147 int
main(int argc,char * argv[])148 main(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 */
575 int
unix_bind(char * path)576 unix_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 */
607 int
unix_connect(char * path)608 unix_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 */
643 int
unix_listen(char * path)644 unix_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 */
662 int
remote_connect(const char * host,const char * port,struct addrinfo hints)663 remote_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
718 int
timeout_connect(int s,const struct sockaddr * name,socklen_t namelen)719 timeout_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 */
760 int
local_listen(char * host,char * port,struct addrinfo hints)761 local_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 */
824 void
readwrite(int net_fd)825 readwrite(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
1021 ssize_t
drainbuf(int fd,unsigned char * buf,size_t * bufpos)1022 drainbuf(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
1042 ssize_t
fillbuf(int fd,unsigned char * buf,size_t * bufpos)1043 fillbuf(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 */
1062 void
fdpass(int nfd)1063 fdpass(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. */
1118 void
atelnet(int nfd,unsigned char * buf,unsigned int size)1119 atelnet(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 */
1153 void
build_ports(char * p)1154 build_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 */
1215 int
udptest(int s)1216 udptest(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
1229 void
FreeBSD_stats_setup(int s)1230 FreeBSD_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
1243 void
FreeBSD_stats_print(int s)1244 FreeBSD_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
1290 void
set_common_sockopts(int s,int af)1291 set_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
1344 int
map_tos(char * s,int * val)1345 map_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
1392 void
report_connect(const struct sockaddr * sa,socklen_t salen)1393 report_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
1418 void
help(void)1419 help(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
1467 void
add_ipsec_policy(int s,int af,char * policy)1468 add_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
1492 void
usage(int ret)1493 usage(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