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