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