1 /*
2  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  * Copyright (c) 2017, Joyent, Inc.
5  */
6 
7 /*
8  * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997
9  *	The Regents of the University of California.  All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that: (1) source code distributions
13  * retain the above copyright notice and this paragraph in its entirety, (2)
14  * distributions including binary code include the above copyright notice and
15  * this paragraph in its entirety in the documentation or other materials
16  * provided with the distribution, and (3) all advertising materials mentioning
17  * features or use of this software display the following acknowledgement:
18  * ``This product includes software developed by the University of California,
19  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
20  * the University nor the names of its contributors may be used to endorse
21  * or promote products derived from this software without specific prior
22  * written permission.
23  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
24  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
26  *
27  *
28  * @(#)$Header: traceroute.c,v 1.49 97/06/13 02:30:23 leres Exp $ (LBL)
29  */
30 
31 #include <sys/param.h>
32 #include <sys/file.h>
33 #include <sys/ioctl.h>
34 #include <sys/socket.h>
35 #include <sys/time.h>
36 #include <sys/sysmacros.h>
37 
38 #include <netinet/in_systm.h>
39 #include <netinet/in.h>
40 #include <netinet/ip.h>
41 #include <netinet/ip_var.h>
42 #include <netinet/ip_icmp.h>
43 #include <netinet/udp.h>
44 #include <netinet/udp_var.h>
45 #include <netinet/ip6.h>
46 #include <netinet/icmp6.h>
47 
48 #include <arpa/inet.h>
49 
50 #include <ctype.h>
51 #include <errno.h>
52 #include <malloc.h>
53 #include <memory.h>
54 #include <netdb.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <strings.h>
58 #include <unistd.h>
59 #include <libintl.h>
60 #include <locale.h>
61 #include <signal.h>
62 #include <setjmp.h>
63 #include <limits.h>
64 #include <zone.h>
65 #include <thread.h>
66 #include <synch.h>
67 
68 #include <priv_utils.h>
69 
70 #include <libinetutil.h>
71 #include "traceroute.h"
72 
73 #define	MAX_SEQ			65535	/* max sequence value for ICMP */
74 #define	MAX_TRAFFIC_CLASS	255	/* max traffic class for IPv6 */
75 #define	MAX_FLOW_LABEL		0xFFFFF	/* max flow label for IPv6 */
76 #define	MAX_TOS			255	/* max type-of-service for IPv4 */
77 #define	STR_LEN			30
78 
79 /* store the information about a host */
80 struct hostinfo {
81 	char *name;		/* hostname */
82 	int family;		/* address family of the IP addresses */
83 	int num_addr;			/* number of IP addresses */
84 	union any_in_addr *addrs;	/* list of IP addresses */
85 };
86 
87 /* used to store a bunch of protocol specific values */
88 struct pr_set {
89 	int family;		/* AF_INET or AF_INET6 */
90 	char name[STR_LEN];	/* "IPv4" or "IPv6" */
91 	char icmp[STR_LEN];	/* "icmp" or "ipv6-icmp" */
92 	int icmp_minlen;
93 	int addr_len;
94 	int ip_hdr_len;
95 	int packlen;
96 	int sock_size;		/* size of sockaddr_in or sockaddr_in6 */
97 	struct sockaddr *to;
98 	struct sockaddr *from;
99 	void *from_sin_addr;
100 	union any_in_addr *gwIPlist;
101 	/* pointers to v4/v6 functions */
102 	struct ip *(*set_buffers_fn) (int);
103 	int (*check_reply_fn)(struct msghdr *, int, int, uchar_t *, uchar_t *);
104 	boolean_t (*print_icmp_other_fn)(uchar_t, uchar_t);
105 	void (*print_addr_fn)(uchar_t *, int, struct sockaddr *);
106 
107 };
108 
109 /*
110  * LBNL bug fixed: in LBNL traceroute 'uchar_t packet[512];'
111  * Not sufficient to hold the complete packet for ECHO REPLY of a big probe.
112  * Packet size is reported incorrectly in such a case.
113  * Also this buffer needs to be 32 bit aligned. In the future the alignment
114  * requirement will be increased to 64 bit. So, let's use 64 bit alignment now.
115  */
116 static uint64_t packet[(IP_MAXPACKET + 1)/8];	/* received packet */
117 
118 static struct ip *outip4;	/* output buffer to send as an IPv4 datagram */
119 static struct ip *outip6;	/* output buffer to send as an IPv6 datagram */
120 
121 /* Used to store the ancillary data that comes with the received packets */
122 static uint64_t ancillary_data[(IP_MAXPACKET + 1)/8];
123 
124 /* first get the gw names, later you'll resolve them based on the family */
125 static char *gwlist[MAXMAX_GWS];		/* gateway names list */
126 static union any_in_addr gwIPlist[MAX_GWS];	/* gateway IPv4 address list */
127 static union any_in_addr gwIP6list[MAX_GWS6];	/* gateway IPv6 address list */
128 
129 static int family_input = AF_UNSPEC;	/* User supplied protocol family */
130 static int rcvsock4;		/* receive (icmp) socket file descriptor */
131 static int sndsock4;		/* send (udp/icmp) socket file descriptor */
132 static int rcvsock6;		/* receive (icmp6) socket file descriptor */
133 static int sndsock6;		/* send (udp6/icmp6) socket file descriptor */
134 int gw_count = 0;		/* number of gateways */
135 static struct sockaddr_in whereto;	/* Who to try to reach */
136 static struct sockaddr_in6 whereto6;
137 static struct sockaddr_in wherefrom;	/* Who we are */
138 static struct sockaddr_in6 wherefrom6;
139 static int packlen_input = 0;		/* user input for packlen */
140 
141 char *prog;
142 static char *source_input = NULL; /* this is user arg. source, doesn't change */
143 static char *source = NULL;	/* this gets modified after name lookup */
144 char *hostname;
145 static char *device = NULL;   	/* interface name */
146 static struct pr_set *pr4;	/* protocol info for IPv4 */
147 static struct pr_set *pr6;	/* protocol info for IPv6 */
148 static struct ifaddrlist *al4;	/* list of interfaces */
149 static struct ifaddrlist *al6;	/* list of interfaces */
150 static uint_t if_index = 0;	/* interface index */
151 static int num_v4 = 0;		/* count of IPv4 addresses */
152 static int num_v6 = 0;		/* count of IPv6 addresses */
153 static int num_ifs4 = 0;	/* count of local IPv4 interfaces */
154 static int num_ifs6 = 0;	/* count of local IPv6 interfaces */
155 
156 static int nprobes = 3;		/* number of probes */
157 static int max_ttl = 30;	/* max number of hops */
158 static int first_ttl = 1;	/* initial number of hops */
159 ushort_t ident;			/* used to authenticate replies */
160 ushort_t port = 32768 + 666;	/* start udp dest port # for probe packets */
161 
162 static int options = 0;		/* socket options */
163 boolean_t verbose = _B_FALSE;	/* verbose output */
164 static int waittime = 5;	/* time to wait for response (in seconds) */
165 static struct timeval delay = {0, 0}; /* delay between consecutive probe */
166 boolean_t nflag = _B_FALSE;	/* print addresses numerically */
167 static boolean_t showttl = _B_FALSE; /* print the ttl(hop limit) of recvd pkt */
168 boolean_t useicmp = _B_FALSE;  	/* use icmp echo instead of udp packets */
169 boolean_t docksum = _B_TRUE;	/* calculate checksums */
170 static boolean_t collect_stat = _B_FALSE;	/* print statistics */
171 boolean_t settos = _B_FALSE;   	/* set type-of-service field */
172 int dontfrag = 0;		/* IP*_DONTFRAG */
173 static int max_timeout = 5;	/* quit after this consecutive timeouts */
174 static boolean_t probe_all = _B_FALSE;	/* probe all the IFs of the target */
175 static boolean_t pick_src = _B_FALSE;	/* traceroute picks the src address */
176 
177 /*
178  * flow and class are specific to IPv6, tos and off are specific to IPv4.
179  * Each protocol uses the ones that are specific to itself, and ignores
180  * others.
181  */
182 static uint_t flow = 0;		/* IPv6 flow info */
183 static uint_t class = 0;	/* IPv6 class */
184 uchar_t tos = 0;		/* IPv4 type-of-service */
185 ushort_t off = 0;		/* set DF bit */
186 
187 static jmp_buf env;		/* stack environment for longjmp() */
188 boolean_t raw_req;		/* if sndsock for IPv4 must be raw */
189 
190 /*
191  * Name service lookup related data.
192  */
193 static mutex_t tr_nslock = ERRORCHECKMUTEX;
194 static boolean_t tr_nsactive = _B_FALSE;	/* Lookup ongoing */
195 static hrtime_t tr_nsstarttime;			/* Start time */
196 static int tr_nssleeptime = 2;			/* Interval between checks */
197 static int tr_nswarntime = 2;			/* Interval to warn after */
198 
199 /* Forwards */
200 static uint_t calc_packetlen(int, struct pr_set *);
201 extern int check_reply(struct msghdr *, int, int, uchar_t *, uchar_t *);
202 extern int check_reply6(struct msghdr *, int, int, uchar_t *, uchar_t *);
203 static double deltaT(struct timeval *, struct timeval *);
204 static char *device_name(struct ifaddrlist *, int, union any_in_addr *,
205     struct pr_set *);
206 extern void *find_ancillary_data(struct msghdr *, int, int);
207 static boolean_t has_addr(struct addrinfo *, union any_in_addr *);
208 static struct ifaddrlist *find_device(struct ifaddrlist *, int, char *);
209 static struct ifaddrlist *find_ifaddr(struct ifaddrlist *, int,
210     union any_in_addr *, int);
211 static void get_gwaddrs(char **, int, union any_in_addr *,
212     union any_in_addr *, int *, int *);
213 static void get_hostinfo(char *, int, struct addrinfo **);
214 char *inet_name(union any_in_addr *, int);
215 ushort_t in_cksum(ushort_t *, int);
216 extern int ip_hdr_length_v6(ip6_t *, int, uint8_t *);
217 extern char *pr_type(uchar_t);
218 extern char *pr_type6(uchar_t);
219 extern void print_addr(uchar_t *, int, struct sockaddr *);
220 extern void print_addr6(uchar_t *, int, struct sockaddr *);
221 extern boolean_t print_icmp_other(uchar_t, uchar_t);
222 extern boolean_t print_icmp_other6(uchar_t, uchar_t);
223 static void print_stats(int, int, double, double, double, double);
224 static void print_unknown_host_msg(const char *, const char *);
225 static void record_stats(double, int *, double *, double *, double *, double *);
226 static void resolve_nodes(int *, struct addrinfo **);
227 static void select_src_addr(union any_in_addr *, union any_in_addr *, int);
228 extern void send_probe(int, struct sockaddr *, struct ip *, int, int,
229     struct timeval *, int);
230 extern void send_probe6(int, struct msghdr *, struct ip *, int, int,
231     struct timeval *, int);
232 extern void set_ancillary_data(struct msghdr *, int, union any_in_addr *, int,
233     uint_t);
234 extern struct ip *set_buffers(int);
235 extern struct ip *set_buffers6(int);
236 extern void set_IPv4opt_sourcerouting(int, union any_in_addr *,
237     union any_in_addr *);
238 static void set_sin(struct sockaddr *, union any_in_addr *, int);
239 static int set_src_addr(struct pr_set *, struct ifaddrlist **);
240 static void setup_protocol(struct pr_set *, int);
241 static void setup_socket(struct pr_set *, int);
242 static void sig_handler(int);
243 static int str2int(const char *, const char *, int, int);
244 static double str2dbl(const char *, const char *, double, double);
245 static void trace_it(struct addrinfo *);
246 static void traceroute(union any_in_addr *, struct msghdr *, struct pr_set *,
247     int, struct ifaddrlist *);
248 static void tv_sub(struct timeval *, struct timeval *);
249 static void usage(void);
250 static int wait_for_reply(int, struct msghdr *, struct timeval *);
251 static double xsqrt(double);
252 static void *ns_warning_thr(void *);
253 
254 /*
255  * main
256  */
257 int
main(int argc,char ** argv)258 main(int argc, char **argv)
259 {
260 	struct addrinfo *ai_dst = NULL;		/* destination host */
261 	/*
262 	 * "probing_successful" indicates if we could successfully send probes,
263 	 * not necessarily received reply from the target (this behavior is from
264 	 * the original traceroute). It's _B_FALSE if packlen is invalid, or no
265 	 * interfaces found.
266 	 */
267 	boolean_t probing_successful = _B_FALSE;
268 	int longjmp_return;			/* return value from longjump */
269 	int i = 0;
270 	char *cp;
271 	int op;
272 	char *ep;
273 	char temp_buf[INET6_ADDRSTRLEN];	/* use for inet_ntop() */
274 	double pause;
275 
276 	/*
277 	 * A raw socket will be used for IPv4 if there is sufficient
278 	 * privilege.
279 	 */
280 	raw_req = priv_ineffect(PRIV_NET_RAWACCESS);
281 
282 	/*
283 	 * We'll need the privilege only when we open the sockets; that's
284 	 * when we'll fail if the program has insufficient privileges.
285 	 */
286 	(void) __init_suid_priv(PU_CLEARLIMITSET, PRIV_NET_ICMPACCESS,
287 	    raw_req ? PRIV_NET_RAWACCESS : NULL, NULL);
288 
289 	(void) setlinebuf(stdout);
290 
291 	if ((cp = strrchr(argv[0], '/')) != NULL)
292 		prog = cp + 1;
293 	else
294 		prog = argv[0];
295 
296 	opterr = 0;
297 	while ((op = getopt(argc, argv, "adFIlnrSvxA:c:f:g:i:L:m:P:p:Q:q:s:"
298 	    "t:w:")) != EOF) {
299 		switch (op) {
300 		case 'A':
301 			if (strcmp(optarg, "inet") == 0) {
302 				family_input = AF_INET;
303 			} else if (strcmp(optarg, "inet6") == 0) {
304 				family_input = AF_INET6;
305 			} else {
306 				Fprintf(stderr,
307 				    "%s: unknown address family %s\n",
308 				    prog, optarg);
309 				exit(EXIT_FAILURE);
310 			}
311 			break;
312 
313 		case 'a':
314 			probe_all = _B_TRUE;
315 			break;
316 
317 		case 'c':
318 			class = str2int(optarg, "traffic class", 0,
319 			    MAX_TRAFFIC_CLASS);
320 			break;
321 
322 		case 'd':
323 			options |= SO_DEBUG;
324 			break;
325 
326 		case 'f':
327 			first_ttl = str2int(optarg, "first ttl", 1, MAXTTL);
328 			break;
329 
330 		case 'F':
331 			off = IP_DF;
332 			dontfrag = 1;
333 			break;
334 
335 		case 'g':
336 			if (!raw_req) {
337 				Fprintf(stderr,
338 				    "%s: privilege to specify a loose source "
339 				    "route gateway is unavailable\n",
340 				    prog);
341 				exit(EXIT_FAILURE);
342 			}
343 			if (gw_count >= MAXMAX_GWS) {
344 				Fprintf(stderr,
345 				    "%s: Too many gateways\n", prog);
346 				exit(EXIT_FAILURE);
347 			}
348 			gwlist[gw_count] = strdup(optarg);
349 			if (gwlist[gw_count] == NULL) {
350 				Fprintf(stderr, "%s: strdup %s\n", prog,
351 				    strerror(errno));
352 				exit(EXIT_FAILURE);
353 			}
354 
355 			++gw_count;
356 			break;
357 
358 		case 'l':
359 			showttl = _B_TRUE;
360 			break;
361 
362 		case 'i':
363 			/* this can be IF name or IF index */
364 			if_index = (uint_t)strtol(optarg, &ep, 10);
365 
366 			/* convert IF index <-->  IF name */
367 			if (errno != 0 || *ep != '\0') {
368 				device = optarg;
369 				if_index = if_nametoindex((const char *)device);
370 
371 				/*
372 				 * In case it fails, check to see if the problem
373 				 * is other than "IF not found".
374 				 */
375 				if (if_index == 0 && errno != ENXIO) {
376 					Fprintf(stderr, "%s: if_nametoindex:"
377 					    "%s\n", prog, strerror(errno));
378 					exit(EXIT_FAILURE);
379 				}
380 			} else {
381 				device = (char *)malloc(LIFNAMSIZ + 1);
382 				if (device == NULL) {
383 					Fprintf(stderr, "%s: malloc: %s\n",
384 					    prog, strerror(errno));
385 					exit(EXIT_FAILURE);
386 				}
387 
388 				device = if_indextoname(if_index, device);
389 				if (device != NULL) {
390 					device[LIFNAMSIZ] = '\0';
391 				} else if (errno != ENXIO) {
392 					/*
393 					 * The problem was other than "index
394 					 * not found".
395 					 */
396 					Fprintf(stderr, "%s: if_indextoname:"
397 					    "%s\n", prog, strerror(errno));
398 					exit(EXIT_FAILURE);
399 				}
400 			}
401 
402 			if (device == NULL || if_index == 0) {
403 				Fprintf(stderr, "%s: interface %s "
404 				    "doesn't match any actual interfaces\n",
405 				    prog, optarg);
406 				exit(EXIT_FAILURE);
407 			}
408 			break;
409 
410 		case 'I':
411 			useicmp = _B_TRUE;
412 			break;
413 
414 		case 'L':
415 			flow = str2int(optarg, "flow label", 0, MAX_FLOW_LABEL);
416 			break;
417 
418 		case 'm':
419 			max_ttl = str2int(optarg, "max ttl(hop limit)", 1,
420 			    MAXTTL);
421 			break;
422 
423 		case 'n':
424 			nflag = _B_TRUE;
425 			break;
426 
427 		case 'P':
428 			pause = str2dbl(optarg, "pause", 0, INT_MAX);
429 			delay.tv_sec = (time_t)pause;
430 			delay.tv_usec = (suseconds_t)((pause - delay.tv_sec) *
431 			    1000000);
432 			break;
433 
434 		case 'p':
435 			port = str2int(optarg, "port", 1, MAX_PORT);
436 			break;
437 
438 		case 'Q':
439 			max_timeout = str2int(optarg, "max timeout", 1, -1);
440 			break;
441 
442 		case 'q':
443 			nprobes = str2int(optarg, "nprobes", 1, -1);
444 			break;
445 
446 		case 'r':
447 			options |= SO_DONTROUTE;
448 			break;
449 
450 		case 'S':
451 			collect_stat = _B_TRUE;
452 			break;
453 
454 		case 's':
455 			/*
456 			 * set the ip source address of the outbound
457 			 * probe (e.g., on a multi-homed host).
458 			 */
459 			source_input = optarg;
460 			break;
461 
462 		case 't':
463 			tos = (uchar_t)str2int(optarg, "tos", 0, MAX_TOS);
464 			settos = _B_TRUE;
465 			break;
466 
467 		case 'v':
468 			verbose = _B_TRUE;
469 			break;
470 
471 		case 'x':
472 			docksum = _B_FALSE;
473 			break;
474 
475 		case 'w':
476 			waittime = str2int(optarg, "wait time", 2, -1);
477 			break;
478 
479 		default:
480 			usage();
481 			break;
482 		}
483 	}
484 
485 	/*
486 	 * If it's probe_all, SIGQUIT makes traceroute exit(). But we set the
487 	 * address to jump back to in traceroute(). Until then, we'll need to
488 	 * temporarily specify one.
489 	 */
490 	if (probe_all) {
491 		if ((longjmp_return = setjmp(env)) != 0) {
492 			if (longjmp_return == SIGQUIT) {
493 				Printf("(exiting)\n");
494 				exit(EXIT_SUCCESS);
495 			} else {		/* should never happen */
496 				exit(EXIT_FAILURE);
497 			}
498 		}
499 		(void) signal(SIGQUIT, sig_handler);
500 	}
501 
502 	if ((gw_count > 0) && (options & SO_DONTROUTE)) {
503 		Fprintf(stderr, "%s: loose source route gateways (-g)"
504 		    " cannot be specified when probe packets are sent"
505 		    " directly to a host on an attached network (-r)\n",
506 		    prog);
507 		exit(EXIT_FAILURE);
508 	}
509 
510 	i = argc - optind;
511 	if (i == 1 || i == 2) {
512 		hostname = argv[optind];
513 
514 		if (i == 2) {
515 			/* accept any length now, we'll check it later */
516 			packlen_input = str2int(argv[optind + 1],
517 			    "packet length", 0, -1);
518 		}
519 	} else {
520 		usage();
521 	}
522 
523 	if (first_ttl > max_ttl) {
524 		Fprintf(stderr,
525 		    "%s: first ttl(hop limit) (%d) may not be greater"
526 		    " than max ttl(hop limit) (%d)\n",
527 		    prog, first_ttl, max_ttl);
528 		exit(EXIT_FAILURE);
529 	}
530 
531 	/*
532 	 * Start up the name services warning thread.
533 	 */
534 	if (thr_create(NULL, 0, ns_warning_thr, NULL,
535 	    THR_DETACHED | THR_DAEMON, NULL) != 0) {
536 		Fprintf(stderr, "%s: failed to create name services "
537 		    "thread: %s\n", prog, strerror(errno));
538 		exit(EXIT_FAILURE);
539 	}
540 
541 
542 	/* resolve hostnames */
543 	resolve_nodes(&family_input, &ai_dst);
544 	if (ai_dst == NULL) {
545 		exit(EXIT_FAILURE);
546 	}
547 
548 	/*
549 	 * If it's probe_all, SIGINT makes traceroute skip to probing next IP
550 	 * address of the target. The new interrupt handler is assigned in
551 	 * traceroute() function. Until then let's ignore the signal.
552 	 */
553 	if (probe_all)
554 		(void) signal(SIGINT, SIG_IGN);
555 
556 	ident = (getpid() & 0xffff) | 0x8000;
557 
558 	/*
559 	 * We KNOW that probe_all == TRUE if family is AF_UNSPEC,
560 	 * since family is set to the specific AF found unless it's
561 	 * probe_all. So if family == AF_UNSPEC, we need to init pr4 and pr6.
562 	 */
563 	switch (family_input) {
564 	case AF_UNSPEC:
565 		pr4 = (struct pr_set *)malloc(sizeof (struct pr_set));
566 		if (pr4 == NULL) {
567 			Fprintf(stderr,
568 			    "%s: malloc %s\n", prog, strerror(errno));
569 			exit(EXIT_FAILURE);
570 		}
571 		pr6 = (struct pr_set *)malloc(sizeof (struct pr_set));
572 		if (pr6 == NULL) {
573 			Fprintf(stderr,
574 			    "%s: malloc %s\n", prog, strerror(errno));
575 			exit(EXIT_FAILURE);
576 		}
577 		setup_protocol(pr6, AF_INET6);
578 		setup_protocol(pr4, AF_INET);
579 		outip6 = (*pr6->set_buffers_fn)(pr6->packlen);
580 		setup_socket(pr6, pr6->packlen);
581 
582 		outip4 = (*pr4->set_buffers_fn)(pr4->packlen);
583 		setup_socket(pr4, pr4->packlen);
584 		num_ifs6 = set_src_addr(pr6, &al6);
585 		num_ifs4 = set_src_addr(pr4, &al4);
586 		break;
587 	case AF_INET6:
588 		pr6 = (struct pr_set *)malloc(sizeof (struct pr_set));
589 		if (pr6 == NULL) {
590 			Fprintf(stderr,
591 			    "%s: malloc %s\n", prog, strerror(errno));
592 			exit(EXIT_FAILURE);
593 		}
594 		setup_protocol(pr6, AF_INET6);
595 		outip6 = (*pr6->set_buffers_fn)(pr6->packlen);
596 		setup_socket(pr6, pr6->packlen);
597 		num_ifs6 = set_src_addr(pr6, &al6);
598 		break;
599 	case AF_INET:
600 		pr4 = (struct pr_set *)malloc(sizeof (struct pr_set));
601 		if (pr4 == NULL) {
602 			Fprintf(stderr,
603 			    "%s: malloc %s\n", prog, strerror(errno));
604 			exit(EXIT_FAILURE);
605 		}
606 		setup_protocol(pr4, AF_INET);
607 		outip4 = (*pr4->set_buffers_fn)(pr4->packlen);
608 		setup_socket(pr4, pr4->packlen);
609 		num_ifs4 = set_src_addr(pr4, &al4);
610 		break;
611 	default:
612 		Fprintf(stderr, "%s: unknow address family.\n", prog);
613 		exit(EXIT_FAILURE);
614 	}
615 
616 	if (num_v4 + num_v6 > 1 && !probe_all) {
617 		if (ai_dst->ai_family == AF_INET) {
618 			Fprintf(stderr,
619 			    "%s: Warning: %s has multiple addresses;"
620 			    " using %s\n", prog, hostname,
621 			    inet_ntop(AF_INET,
622 			    /* LINTED E_BAD_PTR_CAST_ALIGN */
623 			    (void *)&((struct sockaddr_in *)
624 			    ai_dst->ai_addr)->sin_addr,
625 			    temp_buf, sizeof (temp_buf)));
626 		} else {
627 			Fprintf(stderr,
628 			    "%s: Warning: %s has multiple addresses;"
629 			    " using %s\n", prog, hostname,
630 			    inet_ntop(AF_INET6,
631 			    /* LINTED E_BAD_PTR_CAST_ALIGN */
632 			    (void *)&((struct sockaddr_in6 *)
633 			    ai_dst->ai_addr)->sin6_addr,
634 			    temp_buf, sizeof (temp_buf)));
635 		}
636 	}
637 
638 	if (num_ifs4 + num_ifs6 > 0) {
639 		trace_it(ai_dst);
640 		probing_successful = _B_TRUE;
641 	}
642 
643 	(void) close(rcvsock4);
644 	(void) close(sndsock4);
645 	(void) close(rcvsock6);
646 	(void) close(sndsock6);
647 
648 	/*
649 	 * if we could probe any of the IP addresses of the target, that means
650 	 * this was a successful operation
651 	 */
652 	if (probing_successful)
653 		return (EXIT_SUCCESS);
654 	else
655 		return (EXIT_FAILURE);
656 }
657 
658 /*
659  * print "unknown host" message
660  */
661 static void
print_unknown_host_msg(const char * protocol,const char * host)662 print_unknown_host_msg(const char *protocol, const char *host)
663 {
664 	Fprintf(stderr, "%s: unknown%s host %s\n", prog, protocol, host);
665 }
666 
667 /*
668  * resolve destination host and gateways
669  */
670 static void
resolve_nodes(int * family,struct addrinfo ** ai_dstp)671 resolve_nodes(int *family, struct addrinfo **ai_dstp)
672 {
673 	struct addrinfo *ai_dst = NULL;
674 	struct addrinfo *aip = NULL;
675 	int num_resolved_gw = 0;
676 	int num_resolved_gw6 = 0;
677 
678 	get_hostinfo(hostname, *family, &ai_dst);
679 	if (ai_dst == NULL) {
680 		print_unknown_host_msg("", hostname);
681 		exit(EXIT_FAILURE);
682 	}
683 	/* Get a count of the v4 & v6 addresses */
684 	for (aip = ai_dst; aip != NULL; aip = aip->ai_next) {
685 		switch (aip->ai_family) {
686 		case AF_INET:
687 			num_v4++;
688 			break;
689 		case AF_INET6:
690 			num_v6++;
691 			break;
692 		}
693 	}
694 
695 	if (*family == AF_UNSPEC && !probe_all) {
696 		*family = ai_dst->ai_family;
697 	}
698 
699 	/* resolve gateways */
700 	if (gw_count > 0) {
701 		get_gwaddrs(gwlist, *family, gwIPlist, gwIP6list,
702 		    &num_resolved_gw, &num_resolved_gw6);
703 
704 		/* we couldn't resolve a gateway as an IPv6 host */
705 		if (num_resolved_gw6 != gw_count && num_v6 != 0) {
706 			if (*family == AF_INET6 || *family == AF_UNSPEC)
707 				print_unknown_host_msg(" IPv6",
708 				    gwlist[num_resolved_gw6]);
709 			num_v6 = 0;
710 		}
711 
712 		/* we couldn't resolve a gateway as an IPv4 host */
713 		if (num_resolved_gw != gw_count && num_v4 != 0) {
714 			if (*family == AF_INET || *family == AF_UNSPEC)
715 				print_unknown_host_msg(" IPv4",
716 				    gwlist[num_resolved_gw]);
717 			num_v4 = 0;
718 		}
719 	}
720 
721 	*ai_dstp = (num_v4 + num_v6 > 0) ? ai_dst : NULL;
722 }
723 
724 /*
725  * Given IP address or hostname, return v4 and v6 hostinfo lists.
726  * Assumes that hostinfo ** ptrs are non-null.
727  */
728 static void
get_hostinfo(char * host,int family,struct addrinfo ** aipp)729 get_hostinfo(char *host, int family, struct addrinfo **aipp)
730 {
731 	struct addrinfo hints, *ai;
732 	struct in6_addr addr6;
733 	struct in_addr addr;
734 	char abuf[INET6_ADDRSTRLEN];	/* use for inet_ntop() */
735 	int rc;
736 
737 	/*
738 	 * Take care of v4-mapped addresses. It should run same as v4, after
739 	 * chopping off the prefix, leaving the IPv4 address
740 	 */
741 	if ((inet_pton(AF_INET6, host, &addr6) > 0) &&
742 	    IN6_IS_ADDR_V4MAPPED(&addr6)) {
743 		/* peel off the "mapping" stuff, leaving 32 bit IPv4 address */
744 		IN6_V4MAPPED_TO_INADDR(&addr6, &addr);
745 
746 		/* convert it back to a string */
747 		(void) inet_ntop(AF_INET, &addr, abuf, sizeof (abuf));
748 
749 		/* now the host is an IPv4 address */
750 		(void) strcpy(host, abuf);
751 
752 		/*
753 		 * If it's a mapped address, we convert it into IPv4
754 		 * address because traceroute will send and receive IPv4
755 		 * packets for that address. Therefore, it's a failure case to
756 		 * ask get_hostinfo() to treat a mapped address as an IPv6
757 		 * address.
758 		 */
759 		if (family == AF_INET6) {
760 			return;
761 		}
762 	}
763 
764 	(void) memset(&hints, 0, sizeof (hints));
765 	hints.ai_family = family;
766 	hints.ai_flags = AI_ADDRCONFIG | AI_CANONNAME;
767 	rc = getaddrinfo(host, NULL, &hints, &ai);
768 	if (rc != 0) {
769 		if (rc != EAI_NONAME)
770 			Fprintf(stderr, "%s: getaddrinfo: %s\n", prog,
771 			    gai_strerror(rc));
772 		*aipp = NULL;
773 		return;
774 	}
775 	*aipp = ai;
776 }
777 
778 /*
779  * Calculate the packet length to be used, and check against the valid range.
780  * Returns -1 if range check fails.
781  */
782 static uint_t
calc_packetlen(int plen_input,struct pr_set * pr)783 calc_packetlen(int plen_input, struct pr_set *pr)
784 {
785 	int minpacket;			/* min ip packet size */
786 	int optlen;			/* length of ip options */
787 	int plen;
788 
789 	/*
790 	 * LBNL bug fixed: miscalculation of optlen
791 	 */
792 	if (gw_count > 0) {
793 		/*
794 		 * IPv4:
795 		 * ----
796 		 * 5 (NO OPs) + 3 (code, len, ptr) + gateways
797 		 * IP options field can hold up to 9 gateways. But the API
798 		 * allows you to specify only 8, because the last one is the
799 		 * destination host. When this packet is sent, on the wire
800 		 * you see one gateway replaced by 4 NO OPs. The other 1 NO
801 		 * OP is for alignment
802 		 *
803 		 * IPv6:
804 		 * ----
805 		 * Well, formula is different, but the result is same.
806 		 * 8 byte fixed part for Type 0 Routing header, followed by
807 		 * gateway addresses
808 		 */
809 		optlen = 8 + gw_count * pr->addr_len;
810 	} else {
811 		optlen = 0;
812 	}
813 
814 	/* take care of the packet length calculations and checks */
815 	minpacket = pr->ip_hdr_len + sizeof (struct outdata) + optlen;
816 	if (useicmp)
817 		minpacket += pr->icmp_minlen;	/* minimum ICMP header size */
818 	else
819 		minpacket += sizeof (struct udphdr);
820 	plen = plen_input;
821 	if (plen == 0) {
822 		plen = minpacket;		/* minimum sized packet */
823 	} else if (minpacket > plen || plen > IP_MAXPACKET) {
824 		Fprintf(stderr, "%s: %s packet size must be >= %d and <= %d\n",
825 		    prog, pr->name, minpacket, IP_MAXPACKET);
826 		return (0);
827 	}
828 
829 	return (plen);
830 }
831 
832 /*
833  * Sets the source address by resolving -i and -s arguments, or if -i and -s
834  * don't dictate any, it sets the pick_src to make sure traceroute uses the
835  * kernel's pick of the source address.
836  * Returns number of interfaces configured on the source host, 0 on error or
837  * there's no interface which is up amd not a loopback.
838  */
839 static int
set_src_addr(struct pr_set * pr,struct ifaddrlist ** alp)840 set_src_addr(struct pr_set *pr, struct ifaddrlist **alp)
841 {
842 	union any_in_addr *ap;
843 	struct ifaddrlist *al = NULL;
844 	struct ifaddrlist *tmp1_al = NULL;
845 	struct ifaddrlist *tmp2_al = NULL;
846 	/* LINTED E_BAD_PTR_CAST_ALIGN */
847 	struct sockaddr_in *sin_from = (struct sockaddr_in *)pr->from;
848 	/* LINTED E_BAD_PTR_CAST_ALIGN */
849 	struct sockaddr_in6 *sin6_from = (struct sockaddr_in6 *)pr->from;
850 	struct addrinfo *aip;
851 	char errbuf[ERRBUFSIZE];
852 	char abuf[INET6_ADDRSTRLEN];		/* use for inet_ntop() */
853 	int num_ifs;				/* all the interfaces  */
854 	int num_src_ifs;			/* exclude loopback and down */
855 	int i;
856 	uint_t ifaddrflags = 0;
857 
858 	source = source_input;
859 
860 	if (device != NULL)
861 		ifaddrflags |= LIFC_UNDER_IPMP;
862 
863 	/* get the interface address list */
864 	num_ifs = ifaddrlist(&al, pr->family, ifaddrflags, errbuf);
865 	if (num_ifs < 0) {
866 		Fprintf(stderr, "%s: ifaddrlist: %s\n", prog, errbuf);
867 		exit(EXIT_FAILURE);
868 	}
869 
870 	num_src_ifs = 0;
871 	for (i = 0; i < num_ifs; i++) {
872 		if (!(al[i].flags & IFF_LOOPBACK) && (al[i].flags & IFF_UP))
873 			num_src_ifs++;
874 	}
875 
876 	if (num_src_ifs == 0) {
877 		Fprintf(stderr, "%s: can't find any %s network interfaces\n",
878 		    prog, pr->name);
879 		return (0);
880 	}
881 
882 	/* verify the device */
883 	if (device != NULL) {
884 		tmp1_al = find_device(al, num_ifs, device);
885 
886 		if (tmp1_al == NULL) {
887 			Fprintf(stderr, "%s: %s (index %d) is an invalid %s"
888 			    " interface\n", prog, device, if_index, pr->name);
889 			free(al);
890 			return (0);
891 		}
892 	}
893 
894 	/* verify the source address */
895 	if (source != NULL) {
896 		get_hostinfo(source, pr->family, &aip);
897 		if (aip == NULL) {
898 			Fprintf(stderr,
899 			    "%s: %s is an invalid %s source address\n",
900 			    prog, source, pr->name);
901 
902 			free(al);
903 			return (0);
904 		}
905 
906 		source = aip->ai_canonname;
907 
908 		if (pr->family == AF_INET)
909 			ap = (union any_in_addr *)
910 			    /* LINTED E_BAD_PTR_CAST_ALIGN */
911 			    &((struct sockaddr_in *)aip->ai_addr)->sin_addr;
912 		else
913 			ap = (union any_in_addr *)
914 			    /* LINTED E_BAD_PTR_CAST_ALIGN */
915 			    &((struct sockaddr_in6 *)aip->ai_addr)->sin6_addr;
916 
917 		/*
918 		 * LBNL bug fixed: used to accept any src address
919 		 */
920 		tmp2_al = find_ifaddr(al, num_ifs, ap, pr->family);
921 		if (tmp2_al == NULL) {
922 			(void) inet_ntop(pr->family, ap, abuf, sizeof (abuf));
923 			Fprintf(stderr, "%s: %s is not a local %s address\n",
924 			    prog, abuf, pr->name);
925 			free(al);
926 			freeaddrinfo(aip);
927 			return (0);
928 		}
929 	}
930 
931 	pick_src = _B_FALSE;
932 
933 	if (source == NULL) {			/* no -s used */
934 		if (device == NULL) {		/* no -i used, no -s used */
935 			pick_src = _B_TRUE;
936 		} else {			/* -i used, no -s used */
937 			/*
938 			 * -i used, but not -s, and it's IPv4: set the source
939 			 * address to whatever the interface has configured on
940 			 * it.
941 			 */
942 			if (pr->family == AF_INET)
943 				set_sin(pr->from, &(tmp1_al->addr), pr->family);
944 			else
945 				pick_src = _B_TRUE;
946 		}
947 	} else {				/* -s used */
948 		if (device == NULL) {		/* no -i used, -s used */
949 			set_sin(pr->from, ap, pr->family);
950 
951 			if (aip->ai_next != NULL) {
952 				(void) inet_ntop(pr->family, pr->from_sin_addr,
953 				    abuf, sizeof (abuf));
954 				Fprintf(stderr, "%s: Warning: %s has multiple "
955 				    "addresses; using %s\n", prog, source,
956 				    abuf);
957 			}
958 		} else {			/* -i and -s used */
959 			/*
960 			 * Make sure the source specified matches the
961 			 * interface address. You only care about this for IPv4
962 			 * IPv6 can handle IF not matching src address
963 			 */
964 			if (pr->family == AF_INET) {
965 				if (!has_addr(aip, &tmp1_al->addr)) {
966 					Fprintf(stderr,
967 					    "%s: %s is not on interface %s\n",
968 					    prog, source, device);
969 					exit(EXIT_FAILURE);
970 				}
971 				/*
972 				 * make sure we use the one matching the
973 				 * interface's address
974 				 */
975 				*ap = tmp1_al->addr;
976 			}
977 
978 			set_sin(pr->from, ap, pr->family);
979 		}
980 	}
981 
982 	/*
983 	 * Binding at this point will set the source address to be used
984 	 * for both IPv4 (when raw IP datagrams are not required) and
985 	 * IPv6.  If the address being bound to is zero, then the kernel
986 	 * will end up choosing the source address when the datagram is
987 	 * sent.
988 	 *
989 	 * For raw IPv4 datagrams, the source address is initialized
990 	 * within traceroute() along with the outbound destination
991 	 * address.
992 	 */
993 	if (pr->family == AF_INET && !raw_req) {
994 		sin_from->sin_family = AF_INET;
995 		sin_from->sin_port = htons(ident);
996 		if (bind(sndsock4, (struct sockaddr *)pr->from,
997 			sizeof (struct sockaddr_in)) < 0) {
998 			Fprintf(stderr, "%s: bind: %s\n", prog,
999 			    strerror(errno));
1000 			exit(EXIT_FAILURE);
1001 		}
1002 	} else if (pr->family == AF_INET6) {
1003 		sin6_from->sin6_family = AF_INET6;
1004 		sin6_from->sin6_port = htons(ident);
1005 		if (bind(sndsock6, (struct sockaddr *)pr->from,
1006 			sizeof (struct sockaddr_in6)) < 0) {
1007 			Fprintf(stderr, "%s: bind: %s\n", prog,
1008 			    strerror(errno));
1009 			exit(EXIT_FAILURE);
1010 		}
1011 
1012 		whereto6.sin6_flowinfo = htonl((class << 20) | flow);
1013 	}
1014 	*alp = al;
1015 	return (num_ifs);
1016 }
1017 
1018 /*
1019  * Returns the complete ifaddrlist structure matching the desired interface
1020  * address. Ignores interfaces which are either down or loopback.
1021  */
1022 static struct ifaddrlist *
find_ifaddr(struct ifaddrlist * al,int len,union any_in_addr * addr,int family)1023 find_ifaddr(struct ifaddrlist *al, int len, union any_in_addr *addr,
1024     int family)
1025 {
1026 	struct ifaddrlist *tmp_al = al;
1027 	int i;
1028 	size_t addr_len = (family == AF_INET) ? sizeof (struct in_addr) :
1029 	    sizeof (struct in6_addr);
1030 
1031 	for (i = 0; i < len; i++, tmp_al++) {
1032 		if ((!(tmp_al->flags & IFF_LOOPBACK) &&
1033 		    (tmp_al->flags & IFF_UP)) &&
1034 		    (memcmp(&tmp_al->addr, addr, addr_len) == 0))
1035 			break;
1036 	}
1037 
1038 	if (i < len) {
1039 		return (tmp_al);
1040 	} else {
1041 		return (NULL);
1042 	}
1043 }
1044 
1045 /*
1046  * Returns the complete ifaddrlist structure matching the desired interface name
1047  * Ignores interfaces which are either down or loopback.
1048  */
1049 static struct ifaddrlist *
find_device(struct ifaddrlist * al,int len,char * device)1050 find_device(struct ifaddrlist *al, int len, char *device)
1051 {
1052 	struct ifaddrlist *tmp_al = al;
1053 	int i;
1054 
1055 	for (i = 0; i < len; i++, tmp_al++) {
1056 		if ((!(tmp_al->flags & IFF_LOOPBACK) &&
1057 		    (tmp_al->flags & IFF_UP)) &&
1058 		    (strcmp(tmp_al->device, device) == 0))
1059 			break;
1060 	}
1061 
1062 	if (i < len) {
1063 		return (tmp_al);
1064 	} else {
1065 		return (NULL);
1066 	}
1067 }
1068 
1069 /*
1070  * returns _B_TRUE if given hostinfo contains the given address
1071  */
1072 static boolean_t
has_addr(struct addrinfo * ai,union any_in_addr * addr)1073 has_addr(struct addrinfo *ai, union any_in_addr *addr)
1074 {
1075 	struct addrinfo *ai_tmp = NULL;
1076 	union any_in_addr *ap;
1077 
1078 	for (ai_tmp = ai; ai_tmp != NULL; ai_tmp = ai_tmp->ai_next) {
1079 		if (ai_tmp->ai_family == AF_INET6)
1080 			continue;
1081 		ap = (union any_in_addr *)
1082 		    /* LINTED E_BAD_PTR_CAST_ALIGN */
1083 		    &((struct sockaddr_in *)ai_tmp->ai_addr)->sin_addr;
1084 		if (memcmp(ap, addr, sizeof (struct in_addr)) == 0)
1085 			break;
1086 	}
1087 
1088 	if (ai_tmp != NULL) {
1089 		return (_B_TRUE);
1090 	} else {
1091 		return (_B_FALSE);
1092 	}
1093 }
1094 
1095 /*
1096  * Resolve the gateway names, splitting results into v4 and v6 lists.
1097  * Gateway addresses are added to the appropriate passed-in array; the
1098  * number of resolved gateways for each af is returned in resolved[6].
1099  * Assumes that passed-in arrays are large enough for MAX_GWS[6] addrs
1100  * and resolved[6] ptrs are non-null; ignores array and counter if the
1101  * address family param makes them irrelevant.
1102  */
1103 static void
get_gwaddrs(char ** gwlist,int family,union any_in_addr * gwIPlist,union any_in_addr * gwIPlist6,int * resolved,int * resolved6)1104 get_gwaddrs(char **gwlist, int family, union any_in_addr *gwIPlist,
1105     union any_in_addr *gwIPlist6, int *resolved, int *resolved6)
1106 {
1107 	int i;
1108 	boolean_t check_v4 = _B_TRUE, check_v6 = _B_TRUE;
1109 	struct addrinfo *ai = NULL;
1110 	struct addrinfo *aip = NULL;
1111 
1112 	*resolved = *resolved6 = 0;
1113 	switch (family) {
1114 	case AF_UNSPEC:
1115 		break;
1116 	case AF_INET:
1117 		check_v6 = _B_FALSE;
1118 		break;
1119 	case AF_INET6:
1120 		check_v4 = _B_FALSE;
1121 		break;
1122 	default:
1123 		return;
1124 	}
1125 
1126 	if (check_v4 && gw_count >= MAX_GWS) {
1127 		check_v4 = _B_FALSE;
1128 		Fprintf(stderr, "%s: too many IPv4 gateways\n", prog);
1129 		num_v4 = 0;
1130 	}
1131 	if (check_v6 && gw_count >= MAX_GWS6) {
1132 		check_v6 = _B_FALSE;
1133 		Fprintf(stderr, "%s: too many IPv6 gateways\n", prog);
1134 		num_v6 = 0;
1135 	}
1136 
1137 	for (i = 0; i < gw_count; i++) {
1138 		if (!check_v4 && !check_v6)
1139 			return;
1140 		get_hostinfo(gwlist[i], family, &ai);
1141 		if (ai == NULL)
1142 			return;
1143 		if (check_v4 && num_v4 != 0) {
1144 			check_v4 = _B_FALSE;
1145 			for (aip = ai; aip != NULL; aip = aip->ai_next) {
1146 				if (aip->ai_family == AF_INET) {
1147 					/* LINTED E_BAD_PTR_CAST_ALIGN */
1148 					bcopy(&((struct sockaddr_in *)
1149 					    aip->ai_addr)->sin_addr,
1150 					    &gwIPlist[i].addr,
1151 					    aip->ai_addrlen);
1152 					(*resolved)++;
1153 					check_v4 = _B_TRUE;
1154 					break;
1155 				}
1156 			}
1157 		} else if (check_v4) {
1158 			check_v4 = _B_FALSE;
1159 		}
1160 		if (check_v6 && num_v6 != 0) {
1161 			check_v6 = _B_FALSE;
1162 			for (aip = ai; aip != NULL; aip = aip->ai_next) {
1163 				if (aip->ai_family == AF_INET6) {
1164 					/* LINTED E_BAD_PTR_CAST_ALIGN */
1165 					bcopy(&((struct sockaddr_in6 *)
1166 					    aip->ai_addr)->sin6_addr,
1167 					    &gwIPlist6[i].addr6,
1168 					    aip->ai_addrlen);
1169 					(*resolved6)++;
1170 					check_v6 = _B_TRUE;
1171 					break;
1172 				}
1173 			}
1174 		} else if (check_v6) {
1175 			check_v6 = _B_FALSE;
1176 		}
1177 	}
1178 	freeaddrinfo(ai);
1179 }
1180 
1181 /*
1182  * set protocol specific values here
1183  */
1184 static void
setup_protocol(struct pr_set * pr,int family)1185 setup_protocol(struct pr_set *pr, int family)
1186 {
1187 	/*
1188 	 * Set the global variables for each AF. This is going to save us lots
1189 	 * of "if (family == AF_INET)... else .."
1190 	 */
1191 	pr->family = family;
1192 
1193 	if (family == AF_INET) {
1194 		if (!docksum) {
1195 			Fprintf(stderr,
1196 			    "%s: Warning: checksums disabled\n", prog);
1197 		}
1198 		(void) strcpy(pr->name, "IPv4");
1199 		(void) strcpy(pr->icmp, "icmp");
1200 		pr->icmp_minlen = ICMP_MINLEN;
1201 		pr->addr_len = sizeof (struct in_addr);
1202 		pr->ip_hdr_len = sizeof (struct ip);
1203 		pr->sock_size = sizeof (struct sockaddr_in);
1204 		pr->to = (struct sockaddr *)&whereto;
1205 		pr->from = (struct sockaddr *)&wherefrom;
1206 		pr->from_sin_addr = (void *)&wherefrom.sin_addr;
1207 		pr->gwIPlist = gwIPlist;
1208 		pr->set_buffers_fn = set_buffers;
1209 		pr->check_reply_fn = check_reply;
1210 		pr->print_icmp_other_fn = print_icmp_other;
1211 		pr->print_addr_fn = print_addr;
1212 		pr->packlen = calc_packetlen(packlen_input, pr);
1213 	} else {
1214 		(void) strcpy(pr->name, "IPv6");
1215 		(void) strcpy(pr->icmp, "ipv6-icmp");
1216 		pr->icmp_minlen = ICMP6_MINLEN;
1217 		pr->addr_len = sizeof (struct in6_addr);
1218 		pr->ip_hdr_len = sizeof (struct ip6_hdr);
1219 		pr->sock_size = sizeof (struct sockaddr_in6);
1220 		pr->to = (struct sockaddr *)&whereto6;
1221 		pr->from = (struct sockaddr *)&wherefrom6;
1222 		pr->from_sin_addr = (void *)&wherefrom6.sin6_addr;
1223 		pr->gwIPlist = gwIP6list;
1224 		pr->set_buffers_fn = set_buffers6;
1225 		pr->check_reply_fn = check_reply6;
1226 		pr->print_icmp_other_fn = print_icmp_other6;
1227 		pr->print_addr_fn = print_addr6;
1228 		pr->packlen = calc_packetlen(packlen_input, pr);
1229 	}
1230 	if (pr->packlen == 0)
1231 		exit(EXIT_FAILURE);
1232 }
1233 
1234 /*
1235  * setup the sockets for the given protocol's address family
1236  */
1237 static void
setup_socket(struct pr_set * pr,int packet_len)1238 setup_socket(struct pr_set *pr, int packet_len)
1239 {
1240 	int on = 1;
1241 	struct protoent *pe;
1242 	int type;
1243 	int proto;
1244 	int int_op;
1245 	int rsock;
1246 	int ssock;
1247 
1248 	if ((pe = getprotobyname(pr->icmp)) == NULL) {
1249 		Fprintf(stderr, "%s: unknown protocol %s\n", prog, pr->icmp);
1250 		exit(EXIT_FAILURE);
1251 	}
1252 
1253 	/* privilege bracketing */
1254 	(void) __priv_bracket(PRIV_ON);
1255 
1256 	if ((rsock = socket(pr->family, SOCK_RAW, pe->p_proto)) < 0) {
1257 		Fprintf(stderr, "%s: icmp socket: %s\n", prog, strerror(errno));
1258 		exit(EXIT_FAILURE);
1259 	}
1260 
1261 	if (options & SO_DEBUG) {
1262 		if (setsockopt(rsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
1263 		    sizeof (on)) < 0) {
1264 			Fprintf(stderr, "%s: SO_DEBUG: %s\n", prog,
1265 			    strerror(errno));
1266 			exit(EXIT_FAILURE);
1267 		}
1268 	}
1269 	if (options & SO_DONTROUTE) {
1270 		if (setsockopt(rsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
1271 		    sizeof (on)) < 0) {
1272 			Fprintf(stderr, "%s: SO_DONTROUTE: %s\n", prog,
1273 			    strerror(errno));
1274 			exit(EXIT_FAILURE);
1275 		}
1276 	}
1277 
1278 	if (pr->family == AF_INET6) {
1279 		/* Enable receipt of destination address info */
1280 		if (setsockopt(rsock, IPPROTO_IPV6, IPV6_RECVPKTINFO,
1281 		    (char *)&on, sizeof (on)) < 0) {
1282 			Fprintf(stderr, "%s: IPV6_RECVPKTINFO: %s\n", prog,
1283 			    strerror(errno));
1284 			exit(EXIT_FAILURE);
1285 		}
1286 		/* Enable receipt of hoplimit info */
1287 		if (setsockopt(rsock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
1288 		    (char *)&on, sizeof (on)) < 0) {
1289 			Fprintf(stderr, "%s: IPV6_RECVHOPLIMIT: %s\n", prog,
1290 			    strerror(errno));
1291 			exit(EXIT_FAILURE);
1292 		}
1293 
1294 	}
1295 
1296 	/*
1297 	 * Initialize the socket type and protocol based on the address
1298 	 * family, whether or not a raw IP socket is required (for IPv4)
1299 	 * or whether ICMP will be used instead of UDP.
1300 	 *
1301 	 * For historical reasons, the datagrams sent out by
1302 	 * traceroute(8) do not have the "don't fragment" flag set.  For
1303 	 * this reason as well as the ability to set the Loose Source and
1304 	 * Record Route (LSRR) option, a raw IP socket will be used for
1305 	 * IPv4 when run in the global zone.  Otherwise, the actual
1306 	 * datagram that will be sent will be a regular UDP or ICMP echo
1307 	 * request packet.  However for convenience and for future options
1308 	 * when other IP header information may be specified using
1309 	 * traceroute, the buffer including the raw IP and UDP or ICMP
1310 	 * header is always filled in.  When the probe is actually sent,
1311 	 * the size of the request and the start of the packet is set
1312 	 * according to the type of datagram to send.
1313 	 */
1314 	if (pr->family == AF_INET && raw_req) {
1315 		type = SOCK_RAW;
1316 		proto = IPPROTO_RAW;
1317 	} else if (useicmp) {
1318 		type = SOCK_RAW;
1319 		if (pr->family == AF_INET)
1320 			proto = IPPROTO_ICMP;
1321 		else
1322 			proto = IPPROTO_ICMPV6;
1323 	} else {
1324 		type = SOCK_DGRAM;
1325 		proto = IPPROTO_UDP;
1326 	}
1327 	ssock = socket(pr->family, type, proto);
1328 
1329 	if (ssock < 0) {
1330 		if (proto == IPPROTO_RAW) {
1331 			Fprintf(stderr, "%s: raw socket: %s\n", prog,
1332 			    strerror(errno));
1333 		} else if (proto == IPPROTO_UDP) {
1334 			Fprintf(stderr, "%s: udp socket: %s\n", prog,
1335 			    strerror(errno));
1336 		} else {
1337 			Fprintf(stderr, "%s: icmp socket: %s\n", prog,
1338 			    strerror(errno));
1339 		}
1340 		exit(EXIT_FAILURE);
1341 	}
1342 
1343 	if (setsockopt(ssock, SOL_SOCKET, SO_SNDBUF, (char *)&packet_len,
1344 	    sizeof (packet_len)) < 0) {
1345 		Fprintf(stderr, "%s: SO_SNDBUF: %s\n", prog, strerror(errno));
1346 		exit(EXIT_FAILURE);
1347 	}
1348 
1349 	if (pr->family == AF_INET && raw_req) {
1350 		if (setsockopt(ssock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
1351 		    sizeof (on)) < 0) {
1352 			Fprintf(stderr, "%s: IP_HDRINCL: %s\n", prog,
1353 			    strerror(errno));
1354 			exit(EXIT_FAILURE);
1355 		}
1356 	}
1357 
1358 	if (options & SO_DEBUG) {
1359 		if (setsockopt(ssock, SOL_SOCKET, SO_DEBUG, (char *)&on,
1360 		    sizeof (on)) < 0) {
1361 			Fprintf(stderr, "%s: SO_DEBUG: %s\n", prog,
1362 			    strerror(errno));
1363 			exit(EXIT_FAILURE);
1364 		}
1365 	}
1366 	if (options & SO_DONTROUTE) {
1367 		if (setsockopt(ssock, SOL_SOCKET, SO_DONTROUTE,
1368 		    (char *)&on, sizeof (on)) < 0) {
1369 			Fprintf(stderr, "%s: SO_DONTROUTE: %s\n", prog,
1370 			    strerror(errno));
1371 			exit(EXIT_FAILURE);
1372 		}
1373 	}
1374 
1375 	/*
1376 	 * If a raw IPv4 packet is going to be sent, the Type of Service
1377 	 * field in the packet will be initialized in set_buffers().
1378 	 * Otherwise, it is initialized here using the IPPROTO_IP level
1379 	 * socket option.
1380 	 */
1381 	if (settos && !raw_req) {
1382 		int_op = tos;
1383 		if (setsockopt(ssock, IPPROTO_IP, IP_TOS, (char *)&int_op,
1384 		    sizeof (int_op)) < 0) {
1385 			Fprintf(stderr, "%s: IP_TOS: %s\n", prog,
1386 			    strerror(errno));
1387 			exit(EXIT_FAILURE);
1388 		}
1389 	}
1390 
1391 	/* We enable or disable to not depend on the kernel default */
1392 	if (pr->family == AF_INET) {
1393 		if (setsockopt(ssock, IPPROTO_IP, IP_DONTFRAG,
1394 		    (char *)&dontfrag, sizeof (dontfrag)) == -1) {
1395 			Fprintf(stderr, "%s: IP_DONTFRAG %s\n", prog,
1396 			    strerror(errno));
1397 			exit(EXIT_FAILURE);
1398 		}
1399 	} else {
1400 		if (setsockopt(ssock, IPPROTO_IPV6, IPV6_DONTFRAG,
1401 		    (char *)&dontfrag, sizeof (dontfrag)) == -1) {
1402 			Fprintf(stderr, "%s: IPV6_DONTFRAG %s\n", prog,
1403 			    strerror(errno));
1404 			exit(EXIT_FAILURE);
1405 		}
1406 	}
1407 
1408 	if (pr->family == AF_INET) {
1409 		rcvsock4 = rsock;
1410 		sndsock4 = ssock;
1411 	} else {
1412 		rcvsock6 = rsock;
1413 		sndsock6 = ssock;
1414 	}
1415 	/* Revert to non-privileged user after configuring sockets */
1416 	(void) __priv_bracket(PRIV_OFF);
1417 }
1418 
1419 /*
1420  * If we are "probing all", this function calls traceroute() for each IP address
1421  * of the target, otherwise calls only once. Returns _B_FALSE if traceroute()
1422  * fails.
1423  */
1424 static void
trace_it(struct addrinfo * ai_dst)1425 trace_it(struct addrinfo *ai_dst)
1426 {
1427 	struct msghdr msg6;
1428 	int num_dst_IPaddrs;
1429 	struct addrinfo *aip;
1430 	int i;
1431 
1432 	if (!probe_all)
1433 		num_dst_IPaddrs = 1;
1434 	else
1435 		num_dst_IPaddrs = num_v4 + num_v6;
1436 
1437 	/*
1438 	 * Initialize the msg6 structure using the hoplimit for the first
1439 	 * probe packet, gateway addresses and the outgoing interface index.
1440 	 */
1441 	if (ai_dst->ai_family == AF_INET6 || (probe_all && num_v6)) {
1442 		msg6.msg_control = NULL;
1443 		msg6.msg_controllen = 0;
1444 		set_ancillary_data(&msg6, first_ttl, pr6->gwIPlist, gw_count,
1445 		    if_index);
1446 	}
1447 
1448 	/* run traceroute for all the IP addresses of the multihomed dest */
1449 	for (aip = ai_dst, i = 0; i < num_dst_IPaddrs && aip != NULL; i++) {
1450 		union any_in_addr *addrp;
1451 		if (aip->ai_family == AF_INET) {
1452 			addrp = (union any_in_addr *)
1453 			    /* LINTED E_BAD_PTR_CAST_ALIGN */
1454 			    &((struct sockaddr_in *)
1455 			    aip->ai_addr)->sin_addr;
1456 			set_sin((struct sockaddr *)pr4->to, addrp,
1457 			    aip->ai_family);
1458 			traceroute(addrp, &msg6, pr4, num_ifs4, al4);
1459 		} else {
1460 			addrp = (union any_in_addr *)
1461 			    /* LINTED E_BAD_PTR_CAST_ALIGN */
1462 			    &((struct sockaddr_in6 *)
1463 			    aip->ai_addr)->sin6_addr;
1464 			set_sin((struct sockaddr *)pr6->to, addrp,
1465 			    aip->ai_family);
1466 			traceroute(addrp, &msg6, pr6, num_ifs6, al6);
1467 		}
1468 		aip = aip->ai_next;
1469 		if (i < (num_dst_IPaddrs - 1))
1470 			(void) putchar('\n');
1471 	}
1472 }
1473 
1474 /*
1475  * set the IP address in a sockaddr struct
1476  */
1477 static void
set_sin(struct sockaddr * sock,union any_in_addr * addr,int family)1478 set_sin(struct sockaddr *sock, union any_in_addr *addr, int family)
1479 {
1480 	sock->sa_family = family;
1481 
1482 	if (family == AF_INET)
1483 		/* LINTED E_BAD_PTR_CAST_ALIGN */
1484 		((struct sockaddr_in *)sock)->sin_addr = addr->addr;
1485 	else
1486 		/* LINTED E_BAD_PTR_CAST_ALIGN */
1487 		((struct sockaddr_in6 *)sock)->sin6_addr = addr->addr6;
1488 }
1489 
1490 /*
1491  * returns the IF name on which the given IP address is configured
1492  */
1493 static char *
device_name(struct ifaddrlist * al,int len,union any_in_addr * ip_addr,struct pr_set * pr)1494 device_name(struct ifaddrlist *al, int len, union any_in_addr *ip_addr,
1495     struct pr_set *pr)
1496 {
1497 	int i;
1498 	struct ifaddrlist *tmp_al;
1499 
1500 	tmp_al = al;
1501 
1502 	for (i = 0; i < len; i++, tmp_al++) {
1503 		if (memcmp(&tmp_al->addr, ip_addr, pr->addr_len) == 0) {
1504 			return (tmp_al->device);
1505 		}
1506 	}
1507 
1508 	return (NULL);
1509 }
1510 
1511 /*
1512  * Trace the route to the host with given IP address.
1513  */
1514 static void
traceroute(union any_in_addr * ip_addr,struct msghdr * msg6,struct pr_set * pr,int num_ifs,struct ifaddrlist * al)1515 traceroute(union any_in_addr *ip_addr, struct msghdr *msg6, struct pr_set *pr,
1516     int num_ifs, struct ifaddrlist *al)
1517 {
1518 	int ttl;
1519 	int probe;
1520 	uchar_t type;				/* icmp type */
1521 	uchar_t code;				/* icmp code */
1522 	int reply;
1523 	int seq = 0;
1524 	char abuf[INET6_ADDRSTRLEN];		/* use for inet_ntop() */
1525 	int longjmp_return;			/* return value from longjump */
1526 	struct ip *ip = (struct ip *)packet;
1527 	boolean_t got_there = _B_FALSE;		/* we hit the destination */
1528 	static boolean_t first_pkt = _B_TRUE;
1529 	int hoplimit;				/* hoplimit for IPv6 packets */
1530 	struct in6_addr addr6;
1531 	int num_src_ifs;			/* excludes down and loopback */
1532 	struct msghdr in_msg;
1533 	struct iovec iov;
1534 	int *intp;
1535 	int sndsock;
1536 	int rcvsock;
1537 
1538 	msg6->msg_name = pr->to;
1539 	msg6->msg_namelen = sizeof (struct sockaddr_in6);
1540 	sndsock =  (pr->family == AF_INET) ? sndsock4 : sndsock6;
1541 	rcvsock =  (pr->family == AF_INET) ? rcvsock4 : rcvsock6;
1542 
1543 	/* carry out the source address selection */
1544 	if (pick_src) {
1545 		union any_in_addr src_addr;
1546 		char *dev_name;
1547 		int i;
1548 
1549 		/*
1550 		 * If there's a gateway, a routing header as a consequence, our
1551 		 * kernel picks the source address based on the first hop
1552 		 * address, rather than final destination address.
1553 		 */
1554 		if (gw_count > 0) {
1555 			(void) select_src_addr(pr->gwIPlist, &src_addr,
1556 			    pr->family);
1557 		} else {
1558 			(void) select_src_addr(ip_addr, &src_addr, pr->family);
1559 		}
1560 		set_sin(pr->from, &src_addr, pr->family);
1561 
1562 		/* filter out down and loopback interfaces */
1563 		num_src_ifs = 0;
1564 		for (i = 0; i < num_ifs; i++) {
1565 			if (!(al[i].flags & IFF_LOOPBACK) &&
1566 			    (al[i].flags & IFF_UP))
1567 				num_src_ifs++;
1568 		}
1569 
1570 		if (num_src_ifs > 1) {
1571 			dev_name = device_name(al, num_ifs, &src_addr, pr);
1572 			if (dev_name == NULL)
1573 				dev_name = "?";
1574 
1575 			(void) inet_ntop(pr->family, pr->from_sin_addr, abuf,
1576 			    sizeof (abuf));
1577 			Fprintf(stderr,
1578 			    "%s: Warning: Multiple interfaces found;"
1579 			    " using %s @ %s\n", prog, abuf, dev_name);
1580 		}
1581 	}
1582 
1583 	if (pr->family == AF_INET) {
1584 		outip4->ip_src = *(struct in_addr *)pr->from_sin_addr;
1585 		outip4->ip_dst = ip_addr->addr;
1586 	}
1587 
1588 	/*
1589 	 * If the hostname is an IPv6 literal address, let's not print it twice.
1590 	 */
1591 	if (pr->family == AF_INET6 &&
1592 	    inet_pton(AF_INET6, hostname, &addr6) > 0) {
1593 		Fprintf(stderr, "%s to %s", prog, hostname);
1594 	} else {
1595 		Fprintf(stderr, "%s to %s (%s)", prog, hostname,
1596 		    inet_ntop(pr->family, ip_addr, abuf, sizeof (abuf)));
1597 	}
1598 
1599 	if (source)
1600 		Fprintf(stderr, " from %s", source);
1601 	Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl,
1602 	    pr->packlen);
1603 	(void) fflush(stderr);
1604 
1605 	/*
1606 	 * Setup the source routing for IPv4. For IPv6, we did the required
1607 	 * setup in the caller function, trace_it(), because it's independent
1608 	 * from the IP address of target.
1609 	 */
1610 	if (pr->family == AF_INET && gw_count > 0)
1611 		set_IPv4opt_sourcerouting(sndsock, ip_addr, pr->gwIPlist);
1612 
1613 	if (probe_all) {
1614 		/* interrupt handler sig_handler() jumps back to here */
1615 		if ((longjmp_return = setjmp(env)) != 0) {
1616 			switch (longjmp_return) {
1617 			case SIGINT:
1618 				Printf("(skipping)\n");
1619 				return;
1620 			case SIGQUIT:
1621 				Printf("(exiting)\n");
1622 				exit(EXIT_SUCCESS);
1623 			default:	/* should never happen */
1624 				exit(EXIT_FAILURE);
1625 			}
1626 		}
1627 		(void) signal(SIGINT, sig_handler);
1628 	}
1629 
1630 	for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1631 		union any_in_addr lastaddr;
1632 		int timeouts = 0;
1633 		double rtt;		/* for statistics */
1634 		int nreceived = 0;
1635 		double rttmin, rttmax;
1636 		double rttsum, rttssq;
1637 		int unreachable;
1638 
1639 		got_there = _B_FALSE;
1640 		unreachable = 0;
1641 
1642 		/*
1643 		 * The following line clears both IPv4 and IPv6 address stored
1644 		 * in the union.
1645 		 */
1646 		lastaddr.addr6 = in6addr_any;
1647 
1648 		if ((ttl == (first_ttl + 1)) && (options & SO_DONTROUTE)) {
1649 			Fprintf(stderr,
1650 			    "%s: host %s is not on a directly-attached"
1651 			    " network\n", prog, hostname);
1652 			break;
1653 		}
1654 
1655 		Printf("%2d ", ttl);
1656 		(void) fflush(stdout);
1657 
1658 		for (probe = 0; (probe < nprobes) && (timeouts < max_timeout);
1659 		    ++probe) {
1660 			int cc;
1661 			struct timeval t1, t2;
1662 
1663 			/*
1664 			 * Put a delay before sending this probe packet. Don't
1665 			 * delay it if it's the very first packet.
1666 			 */
1667 			if (!first_pkt) {
1668 				if (delay.tv_sec > 0)
1669 					(void) sleep((uint_t)delay.tv_sec);
1670 				if (delay.tv_usec > 0)
1671 					(void) usleep(delay.tv_usec);
1672 			} else {
1673 				first_pkt = _B_FALSE;
1674 			}
1675 
1676 			(void) gettimeofday(&t1, NULL);
1677 
1678 			if (pr->family == AF_INET) {
1679 				send_probe(sndsock, pr->to, outip4, seq, ttl,
1680 				    &t1, pr->packlen);
1681 			} else {
1682 				send_probe6(sndsock, msg6, outip6, seq, ttl,
1683 				    &t1, pr->packlen);
1684 			}
1685 
1686 			/* prepare msghdr for recvmsg() */
1687 			in_msg.msg_name = pr->from;
1688 			in_msg.msg_namelen = pr->sock_size;
1689 
1690 			iov.iov_base = (char *)packet;
1691 			iov.iov_len = sizeof (packet);
1692 
1693 			in_msg.msg_iov = &iov;
1694 			in_msg.msg_iovlen = 1;
1695 
1696 			in_msg.msg_control = ancillary_data;
1697 			in_msg.msg_controllen = sizeof (ancillary_data);
1698 
1699 			while ((cc = wait_for_reply(rcvsock, &in_msg,
1700 			    &t1)) != 0) {
1701 				(void) gettimeofday(&t2, NULL);
1702 
1703 				reply = (*pr->check_reply_fn) (&in_msg, cc, seq,
1704 				    &type, &code);
1705 
1706 				in_msg.msg_controllen =
1707 				    sizeof (ancillary_data);
1708 				/* Skip short packet */
1709 				if (reply == REPLY_SHORT_PKT) {
1710 					continue;
1711 				}
1712 
1713 				timeouts = 0;
1714 
1715 				/*
1716 				 * if reply comes from a different host, print
1717 				 * the hostname
1718 				 */
1719 				if (memcmp(pr->from_sin_addr, &lastaddr,
1720 				    pr->addr_len) != 0) {
1721 					(*pr->print_addr_fn) ((uchar_t *)packet,
1722 					    cc, pr->from);
1723 					/* store the address response */
1724 					(void) memcpy(&lastaddr,
1725 					    pr->from_sin_addr, pr->addr_len);
1726 				}
1727 
1728 				rtt = deltaT(&t1, &t2);
1729 				if (collect_stat) {
1730 					record_stats(rtt, &nreceived, &rttmin,
1731 					    &rttmax, &rttsum, &rttssq);
1732 				} else {
1733 					Printf("  %.3f ms", rtt);
1734 				}
1735 
1736 				if (pr->family == AF_INET6) {
1737 					intp = find_ancillary_data(&in_msg,
1738 					    IPPROTO_IPV6, IPV6_HOPLIMIT);
1739 					if (intp == NULL) {
1740 						Fprintf(stderr,
1741 						    "%s: can't find "
1742 						    "IPV6_HOPLIMIT ancillary "
1743 						    "data\n", prog);
1744 						exit(EXIT_FAILURE);
1745 					}
1746 					hoplimit = *intp;
1747 				}
1748 
1749 				if (reply == REPLY_GOT_TARGET) {
1750 					got_there = _B_TRUE;
1751 
1752 					if (((pr->family == AF_INET) &&
1753 					    (ip->ip_ttl <= 1)) ||
1754 					    ((pr->family == AF_INET6) &&
1755 					    (hoplimit <= 1)))
1756 						Printf(" !");
1757 				}
1758 
1759 				if (!collect_stat && showttl) {
1760 					if (pr->family == AF_INET) {
1761 						Printf(" (ttl=%d)",
1762 						    (int)ip->ip_ttl);
1763 					} else if (hoplimit != -1) {
1764 						Printf(" (hop limit=%d)",
1765 						    hoplimit);
1766 					}
1767 				}
1768 
1769 				if (reply == REPLY_GOT_OTHER) {
1770 					if ((*pr->print_icmp_other_fn)
1771 					    (type, code)) {
1772 						unreachable++;
1773 					}
1774 				}
1775 
1776 				/* special case */
1777 				if (pr->family == AF_INET &&
1778 				    type == ICMP_UNREACH &&
1779 				    code == ICMP_UNREACH_PROTOCOL)
1780 					got_there = _B_TRUE;
1781 
1782 				break;
1783 			}
1784 
1785 			seq = (seq + 1) % (MAX_SEQ + 1);
1786 
1787 			if (cc == 0) {
1788 				Printf(" *");
1789 				timeouts++;
1790 			}
1791 
1792 			(void) fflush(stdout);
1793 		}
1794 
1795 		if (collect_stat) {
1796 			print_stats(probe, nreceived, rttmin, rttmax, rttsum,
1797 			    rttssq);
1798 		}
1799 
1800 		(void) putchar('\n');
1801 
1802 		/* either we hit the target or received too many unreachables */
1803 		if (got_there ||
1804 		    (unreachable > 0 && unreachable >= nprobes - 1))
1805 			break;
1806 	}
1807 
1808 	/* Ignore the SIGINT between traceroute() runs */
1809 	if (probe_all)
1810 		(void) signal(SIGINT, SIG_IGN);
1811 }
1812 
1813 /*
1814  * for a given destination address and address family, it finds out what
1815  * source address kernel is going to pick
1816  */
1817 static void
select_src_addr(union any_in_addr * dst_addr,union any_in_addr * src_addr,int family)1818 select_src_addr(union any_in_addr *dst_addr, union any_in_addr *src_addr,
1819     int family)
1820 {
1821 	int tmp_fd;
1822 	struct sockaddr *sock;
1823 	struct sockaddr_in *sin;
1824 	struct sockaddr_in6 *sin6;
1825 	size_t sock_len;
1826 
1827 	sock = (struct sockaddr *)malloc(sizeof (struct sockaddr_in6));
1828 	if (sock == NULL) {
1829 		Fprintf(stderr, "%s: malloc %s\n", prog, strerror(errno));
1830 		exit(EXIT_FAILURE);
1831 	}
1832 	(void) bzero(sock, sizeof (struct sockaddr_in6));
1833 
1834 	if (family == AF_INET) {
1835 		/* LINTED E_BAD_PTR_CAST_ALIGN */
1836 		sin = (struct sockaddr_in *)sock;
1837 		sin->sin_family = AF_INET;
1838 		sin->sin_addr = dst_addr->addr;
1839 		sin->sin_port = IPPORT_ECHO;	/* port shouldn't be 0 */
1840 		sock_len = sizeof (struct sockaddr_in);
1841 	} else {
1842 		/* LINTED E_BAD_PTR_CAST_ALIGN */
1843 		sin6 = (struct sockaddr_in6 *)sock;
1844 		sin6->sin6_family = AF_INET6;
1845 		sin6->sin6_addr = dst_addr->addr6;
1846 		sin6->sin6_port = IPPORT_ECHO;	/* port shouldn't be 0 */
1847 		sock_len = sizeof (struct sockaddr_in6);
1848 	}
1849 
1850 	/* open a UDP socket */
1851 	if ((tmp_fd = socket(family, SOCK_DGRAM, 0)) < 0) {
1852 		Fprintf(stderr, "%s: udp socket: %s\n", prog,
1853 		    strerror(errno));
1854 		exit(EXIT_FAILURE);
1855 	}
1856 
1857 	/* connect it */
1858 	if (connect(tmp_fd, sock, sock_len) < 0) {
1859 		/*
1860 		 * If there's no route to the destination, this connect() call
1861 		 * fails. We just return all-zero (wildcard) as the source
1862 		 * address, so that user can get to see "no route to dest"
1863 		 * message, as it'll try to send the probe packet out and will
1864 		 * receive ICMP unreachable.
1865 		 */
1866 		if (family == AF_INET)
1867 			src_addr->addr.s_addr = INADDR_ANY;
1868 		else
1869 			src_addr->addr6 = in6addr_any;
1870 		free(sock);
1871 		return;
1872 	}
1873 
1874 	/* get the local sock info */
1875 	if (getsockname(tmp_fd, sock, &sock_len) < 0) {
1876 		Fprintf(stderr, "%s: getsockname: %s\n", prog,
1877 		    strerror(errno));
1878 		exit(EXIT_FAILURE);
1879 	}
1880 
1881 	if (family == AF_INET) {
1882 		/* LINTED E_BAD_PTR_CAST_ALIGN */
1883 		sin = (struct sockaddr_in *)sock;
1884 		src_addr->addr = sin->sin_addr;
1885 	} else {
1886 		/* LINTED E_BAD_PTR_CAST_ALIGN */
1887 		sin6 = (struct sockaddr_in6 *)sock;
1888 		src_addr->addr6 = sin6->sin6_addr;
1889 	}
1890 
1891 	free(sock);
1892 	(void) close(tmp_fd);
1893 }
1894 
1895 /*
1896  * Checksum routine for Internet Protocol family headers (C Version)
1897  */
1898 ushort_t
in_cksum(ushort_t * addr,int len)1899 in_cksum(ushort_t *addr, int len)
1900 {
1901 	int nleft = len;
1902 	ushort_t *w = addr;
1903 	ushort_t answer;
1904 	int sum = 0;
1905 
1906 	/*
1907 	 *  Our algorithm is simple, using a 32 bit accumulator (sum),
1908 	 *  we add sequential 16 bit words to it, and at the end, fold
1909 	 *  back all the carry bits from the top 16 bits into the lower
1910 	 *  16 bits.
1911 	 */
1912 	while (nleft > 1)  {
1913 		sum += *w++;
1914 		nleft -= 2;
1915 	}
1916 
1917 	/* mop up an odd byte, if necessary */
1918 	if (nleft == 1)
1919 		sum += *(uchar_t *)w;
1920 
1921 	/* add back carry outs from top 16 bits to low 16 bits */
1922 	sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
1923 	sum += (sum >> 16);			/* add carry */
1924 	answer = ~sum;				/* truncate to 16 bits */
1925 	return (answer);
1926 }
1927 
1928 /*
1929  * Wait until a reply arrives or timeout occurs. If packet arrived, read it
1930  * return the size of the packet read.
1931  */
1932 static int
wait_for_reply(int sock,struct msghdr * msg,struct timeval * tp)1933 wait_for_reply(int sock, struct msghdr *msg, struct timeval *tp)
1934 {
1935 	fd_set fds;
1936 	struct timeval now, wait;
1937 	int cc = 0;
1938 	int result;
1939 
1940 	(void) FD_ZERO(&fds);
1941 	FD_SET(sock, &fds);
1942 
1943 	wait.tv_sec = tp->tv_sec + waittime;
1944 	wait.tv_usec = tp->tv_usec;
1945 	(void) gettimeofday(&now, NULL);
1946 	tv_sub(&wait, &now);
1947 
1948 	if (wait.tv_sec < 0 || wait.tv_usec < 0)
1949 		return (0);
1950 
1951 	result = select(sock + 1, &fds, (fd_set *)NULL, (fd_set *)NULL, &wait);
1952 
1953 	if (result == -1) {
1954 		if (errno != EINTR) {
1955 			Fprintf(stderr, "%s: select: %s\n", prog,
1956 			    strerror(errno));
1957 		}
1958 	} else if (result > 0)
1959 		cc = recvmsg(sock, msg, 0);
1960 
1961 	return (cc);
1962 }
1963 
1964 /*
1965  * Construct an Internet address representation. If the nflag has been supplied,
1966  * give numeric value, otherwise try for symbolic name.
1967  */
1968 char *
inet_name(union any_in_addr * in,int family)1969 inet_name(union any_in_addr *in, int family)
1970 {
1971 	char *cp;
1972 	static boolean_t first = _B_TRUE;
1973 	static char domain[NI_MAXHOST + 1];
1974 	static char line[NI_MAXHOST + 1];	/* assuming		*/
1975 				/* (NI_MAXHOST + 1) >= INET6_ADDRSTRLEN */
1976 	char hbuf[NI_MAXHOST];
1977 	socklen_t slen;
1978 	struct sockaddr_in sin;
1979 	struct sockaddr_in6 sin6;
1980 	struct sockaddr *sa;
1981 	int flags;
1982 
1983 	switch (family) {
1984 	case AF_INET:
1985 		slen = sizeof (struct sockaddr_in);
1986 		sin.sin_addr = in->addr;
1987 		sin.sin_port = 0;
1988 		sa = (struct sockaddr *)&sin;
1989 		break;
1990 	case AF_INET6:
1991 		slen = sizeof (struct sockaddr_in6);
1992 		sin6.sin6_addr = in->addr6;
1993 		sin6.sin6_port = 0;
1994 		sin6.sin6_scope_id = 0;
1995 		sa = (struct sockaddr *)&sin6;
1996 		break;
1997 	default:
1998 		(void) snprintf(line, sizeof (line),
1999 		    "<invalid address family>");
2000 		return (line);
2001 	}
2002 	sa->sa_family = family;
2003 
2004 	if (first && !nflag) {
2005 		/* find out the domain name */
2006 		first = _B_FALSE;
2007 		mutex_enter(&tr_nslock);
2008 		tr_nsactive = _B_TRUE;
2009 		tr_nsstarttime = gethrtime();
2010 		mutex_exit(&tr_nslock);
2011 		if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
2012 		    (cp = strchr(domain, '.')) != NULL) {
2013 			(void) strncpy(domain, cp + 1, sizeof (domain) - 1);
2014 			domain[sizeof (domain) - 1] = '\0';
2015 		} else {
2016 			domain[0] = '\0';
2017 		}
2018 		mutex_enter(&tr_nslock);
2019 		tr_nsactive = _B_FALSE;
2020 		mutex_exit(&tr_nslock);
2021 	}
2022 
2023 	flags = (nflag) ? NI_NUMERICHOST : NI_NAMEREQD;
2024 	mutex_enter(&tr_nslock);
2025 	tr_nsactive = _B_TRUE;
2026 	tr_nsstarttime = gethrtime();
2027 	mutex_exit(&tr_nslock);
2028 	if (getnameinfo(sa, slen, hbuf, sizeof (hbuf), NULL, 0, flags) != 0) {
2029 		if (inet_ntop(family, (const void *)&in->addr6,
2030 		    hbuf, sizeof (hbuf)) == NULL)
2031 			hbuf[0] = 0;
2032 	} else if (!nflag && (cp = strchr(hbuf, '.')) != NULL &&
2033 	    strcmp(cp + 1, domain) == 0) {
2034 		*cp = '\0';
2035 	}
2036 	mutex_enter(&tr_nslock);
2037 	tr_nsactive = _B_FALSE;
2038 	mutex_exit(&tr_nslock);
2039 	(void) strlcpy(line, hbuf, sizeof (line));
2040 
2041 	return (line);
2042 }
2043 
2044 /*
2045  * return the difference (in msec) between two time values
2046  */
2047 static double
deltaT(struct timeval * t1p,struct timeval * t2p)2048 deltaT(struct timeval *t1p, struct timeval *t2p)
2049 {
2050 	double dt;
2051 
2052 	dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
2053 	    (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
2054 	return (dt);
2055 }
2056 
2057 /*
2058  * Subtract 2 timeval structs:  out = out - in.
2059  * Out is assumed to be >= in.
2060  */
2061 static void
tv_sub(struct timeval * out,struct timeval * in)2062 tv_sub(struct timeval *out, struct timeval *in)
2063 {
2064 	if ((out->tv_usec -= in->tv_usec) < 0)   {
2065 		--out->tv_sec;
2066 		out->tv_usec += 1000000;
2067 	}
2068 	out->tv_sec -= in->tv_sec;
2069 }
2070 
2071 /*
2072  * record statistics
2073  */
2074 static void
record_stats(double rtt,int * nreceived,double * rttmin,double * rttmax,double * rttsum,double * rttssq)2075 record_stats(double rtt, int *nreceived, double *rttmin, double *rttmax,
2076     double *rttsum, double *rttssq)
2077 {
2078 	if (*nreceived == 0) {
2079 		*rttmin = rtt;
2080 		*rttmax = rtt;
2081 		*rttsum = rtt;
2082 		*rttssq = rtt * rtt;
2083 	} else {
2084 		if (rtt < *rttmin)
2085 			*rttmin = rtt;
2086 
2087 		if (rtt > *rttmax)
2088 			*rttmax = rtt;
2089 
2090 		*rttsum += rtt;
2091 		*rttssq += rtt * rtt;
2092 	}
2093 
2094 	(*nreceived)++;
2095 }
2096 
2097 /*
2098  * display statistics
2099  */
2100 static void
print_stats(int ntransmitted,int nreceived,double rttmin,double rttmax,double rttsum,double rttssq)2101 print_stats(int ntransmitted, int nreceived, double rttmin, double rttmax,
2102     double rttsum, double rttssq)
2103 {
2104 	double rttavg;			/* average round-trip time */
2105 	double rttstd;			/* rtt standard deviation */
2106 
2107 	if (ntransmitted > 0 && ntransmitted >= nreceived) {
2108 		int missed = ntransmitted - nreceived;
2109 		double loss = 100 * (double)missed / (double)ntransmitted;
2110 
2111 		if (nreceived > 0) {
2112 			rttavg = rttsum / nreceived;
2113 			rttstd = rttssq - (rttavg * rttsum);
2114 			rttstd = xsqrt(rttstd / nreceived);
2115 
2116 			Printf("  %.3f", rttmin);
2117 			Printf("/%.3f", rttavg);
2118 			Printf("/%.3f", rttmax);
2119 
2120 			Printf(" (%.3f) ms ", rttstd);
2121 		}
2122 
2123 		Printf(" %d/%d pkts", nreceived, ntransmitted);
2124 
2125 		if (nreceived == 0)
2126 			Printf(" (100%% loss)");
2127 		else
2128 			Printf(" (%.2g%% loss)", loss);
2129 	}
2130 }
2131 
2132 /*
2133  * square root function
2134  */
2135 double
xsqrt(double y)2136 xsqrt(double y)
2137 {
2138 	double t, x;
2139 
2140 	if (y <= 0) {
2141 		return (0.0);
2142 	}
2143 
2144 	x = (y < 1.0) ? 1.0 : y;
2145 	do {
2146 		t = x;
2147 		x = (t + (y/t))/2.0;
2148 	} while (0 < x && x < t);
2149 
2150 	return (x);
2151 }
2152 
2153 /*
2154  * String to double with optional min and max.
2155  */
2156 static double
str2dbl(const char * str,const char * what,double mi,double ma)2157 str2dbl(const char *str, const char *what, double mi, double ma)
2158 {
2159 	double val;
2160 	char *ep;
2161 
2162 	errno = 0;
2163 
2164 	val = strtod(str, &ep);
2165 	if (errno != 0 || *ep != '\0') {
2166 		Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
2167 		    prog, str, what);
2168 		exit(EXIT_FAILURE);
2169 	}
2170 	if (val < mi && mi >= 0) {
2171 		Fprintf(stderr, "%s: %s must be >= %f\n", prog, what, mi);
2172 		exit(EXIT_FAILURE);
2173 	}
2174 	if (val > ma && ma >= 0) {
2175 		Fprintf(stderr, "%s: %s must be <= %f\n", prog, what, ma);
2176 		exit(EXIT_FAILURE);
2177 	}
2178 	return (val);
2179 }
2180 
2181 /*
2182  * String to int with optional min and max. Handles decimal and hex.
2183  */
2184 static int
str2int(const char * str,const char * what,int mi,int ma)2185 str2int(const char *str, const char *what, int mi, int ma)
2186 {
2187 	const char *cp;
2188 	int val;
2189 	char *ep;
2190 
2191 	errno = 0;
2192 
2193 	if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
2194 		cp = str + 2;
2195 		val = (int)strtol(cp, &ep, 16);
2196 	} else {
2197 		val = (int)strtol(str, &ep, 10);
2198 	}
2199 	if (errno != 0 || *ep != '\0') {
2200 		Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
2201 		    prog, str, what);
2202 		exit(EXIT_FAILURE);
2203 	}
2204 	if (val < mi && mi >= 0) {
2205 		if (mi == 0) {
2206 			Fprintf(stderr, "%s: %s must be >= %d\n",
2207 			    prog, what, mi);
2208 		} else {
2209 			Fprintf(stderr, "%s: %s must be > %d\n",
2210 			    prog, what, mi - 1);
2211 		}
2212 		exit(EXIT_FAILURE);
2213 	}
2214 	if (val > ma && ma >= 0) {
2215 		Fprintf(stderr, "%s: %s must be <= %d\n", prog, what, ma);
2216 		exit(EXIT_FAILURE);
2217 	}
2218 	return (val);
2219 }
2220 
2221 /*
2222  * This is the interrupt handler for SIGINT and SIGQUIT. It's completely handled
2223  * where it jumps to.
2224  */
2225 static void
sig_handler(int sig)2226 sig_handler(int sig)
2227 {
2228 	longjmp(env, sig);
2229 }
2230 
2231 /*
2232  * display the usage of traceroute
2233  */
2234 static void
usage(void)2235 usage(void)
2236 {
2237 	Fprintf(stderr, "Usage: %s [-adFIlnSvx] [-A address_family] "
2238 	    "[-c traffic_class]\n"
2239 	    "\t[-f first_hop] [-g gateway [-g gateway ...]| -r] [-i iface]\n"
2240 	    "\t[-L flow_label] [-m max_hop] [-P pause_sec] [-p port] "
2241 	    "[-Q max_timeout]\n"
2242 	    "\t[-q nqueries] [-s src_addr] [-t tos] [-w wait_time] host "
2243 	    "[packetlen]\n", prog);
2244 	exit(EXIT_FAILURE);
2245 }
2246 
2247 /* ARGSUSED */
2248 static void *
ns_warning_thr(void * unused)2249 ns_warning_thr(void *unused)
2250 {
2251 	for (;;) {
2252 		hrtime_t now;
2253 
2254 		(void) sleep(tr_nssleeptime);
2255 
2256 		now = gethrtime();
2257 		mutex_enter(&tr_nslock);
2258 		if (tr_nsactive && now - tr_nsstarttime >=
2259 		    tr_nswarntime * NANOSEC) {
2260 			Fprintf(stderr, "%s: warning: responses "
2261 			    "received, but name service lookups are "
2262 			    "taking a while. Use %s -n to disable "
2263 			    "name service lookups.\n",
2264 			    prog, prog);
2265 			mutex_exit(&tr_nslock);
2266 			return (NULL);
2267 		}
2268 		mutex_exit(&tr_nslock);
2269 	}
2270 
2271 	/* LINTED: E_STMT_NOT_REACHED */
2272 	return (NULL);
2273 }
2274