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/socket.h> 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <ctype.h> 37 #include <strings.h> 38 #include <libintl.h> 39 #include <errno.h> 40 41 #include <netinet/in_systm.h> 42 #include <netinet/in.h> 43 #include <netinet/ip.h> 44 #include <netinet/ip_var.h> 45 #include <netinet/ip_icmp.h> 46 #include <netinet/udp.h> 47 #include <netinet/udp_var.h> 48 49 #include <arpa/inet.h> 50 #include <netdb.h> 51 52 #include <ifaddrlist.h> 53 #include "traceroute.h" 54 55 /* 56 * IPv4 source routing option. 57 * In order to avoid padding for the alignment of IPv4 addresses, ipsr_addrs 58 * is defined as a 2-D array of uint8_t, instead of 1-D array of struct in_addr. 59 */ 60 struct ip_sourceroute { 61 uint8_t ipsr_code; 62 uint8_t ipsr_len; 63 uint8_t ipsr_ptr; 64 /* up to 9 IPv4 addresses */ 65 uint8_t ipsr_addrs[1][sizeof (struct in_addr)]; 66 }; 67 68 int check_reply(struct msghdr *, int, int, uchar_t *, uchar_t *); 69 extern ushort_t in_cksum(ushort_t *, int); 70 extern char *inet_name(union any_in_addr *, int); 71 static char *pr_type(uchar_t); 72 void print_addr(uchar_t *, int, struct sockaddr *); 73 boolean_t print_icmp_other(uchar_t, uchar_t); 74 void send_probe(int, struct sockaddr *, struct ip *, int, int, 75 struct timeval *, int); 76 struct ip *set_buffers(int); 77 void set_IPv4opt_sourcerouting(int, union any_in_addr *, union any_in_addr *); 78 79 /* 80 * prepares the buffer to be sent as an IP datagram 81 */ 82 struct ip * 83 set_buffers(int plen) 84 { 85 struct ip *outip; 86 uchar_t *outp; /* packet following the IP header (UDP/ICMP) */ 87 struct udphdr *outudp; 88 struct icmp *outicmp; 89 int optlen = 0; 90 91 outip = (struct ip *)malloc((size_t)plen); 92 if (outip == NULL) { 93 Fprintf(stderr, "%s: malloc: %s\n", prog, strerror(errno)); 94 exit(EXIT_FAILURE); 95 } 96 97 if (gw_count > 0) { 98 /* 8 = 5 (NO OPs) + 3 (code, len, ptr) */ 99 optlen = 8 + gw_count * sizeof (struct in_addr); 100 } 101 102 (void) memset((char *)outip, 0, (size_t)plen); 103 outp = (uchar_t *)(outip + 1); 104 105 outip->ip_v = IPVERSION; 106 if (settos) 107 outip->ip_tos = tos; 108 109 /* 110 * LBNL bug fixed: missing '- optlen' before, causing optlen 111 * added twice 112 * 113 * BSD bug: BSD touches the header fields 'len' and 'ip_off' 114 * even when HDRINCL is set. It applies htons() on these 115 * fields. It should send the header untouched when HDRINCL 116 * is set. 117 */ 118 outip->ip_len = htons(plen - optlen); 119 outip->ip_off = htons(off); 120 outip->ip_hl = (outp - (uchar_t *)outip) >> 2; 121 122 /* setup ICMP or UDP */ 123 if (useicmp) { 124 outip->ip_p = IPPROTO_ICMP; 125 126 /* LINTED E_BAD_PTR_CAST_ALIGN */ 127 outicmp = (struct icmp *)outp; 128 outicmp->icmp_type = ICMP_ECHO; 129 outicmp->icmp_id = htons(ident); 130 } else { 131 outip->ip_p = IPPROTO_UDP; 132 133 /* LINTED E_BAD_PTR_CAST_ALIGN */ 134 outudp = (struct udphdr *)outp; 135 outudp->uh_sport = htons(ident); 136 outudp->uh_ulen = 137 htons((ushort_t)(plen - (sizeof (struct ip) + optlen))); 138 } 139 140 return (outip); 141 } 142 143 /* 144 * Setup the source routing for IPv4. 145 */ 146 void 147 set_IPv4opt_sourcerouting(int sndsock, union any_in_addr *ip_addr, 148 union any_in_addr *gwIPlist) 149 { 150 struct protoent *pe; 151 struct ip_sourceroute *srp; 152 uchar_t optlist[MAX_IPOPTLEN]; 153 int i; 154 int gwV4_count; 155 156 if ((pe = getprotobyname("ip")) == NULL) { 157 Fprintf(stderr, "%s: unknown protocol ip\n", prog); 158 exit(EXIT_FAILURE); 159 } 160 161 gwV4_count = (gw_count < MAX_GWS) ? gw_count : MAX_GWS - 1; 162 /* final hop */ 163 gwIPlist[gwV4_count].addr = ip_addr->addr; 164 165 /* 166 * the option length passed to setsockopt() needs to be a multiple of 167 * 32 bits. Therefore we need to use a 1-byte padding (source routing 168 * information takes 4x+3 bytes). 169 */ 170 optlist[0] = IPOPT_NOP; 171 172 srp = (struct ip_sourceroute *)&optlist[1]; 173 srp->ipsr_code = IPOPT_LSRR; 174 /* 3 = 1 (code) + 1 (len) + 1 (ptr) */ 175 srp->ipsr_len = 3 + (gwV4_count + 1) * sizeof (gwIPlist[0].addr); 176 srp->ipsr_ptr = IPOPT_MINOFF; 177 178 for (i = 0; i <= gwV4_count; i++) { 179 (void) bcopy((char *)&gwIPlist[i].addr, &srp->ipsr_addrs[i], 180 sizeof (struct in_addr)); 181 } 182 183 if (setsockopt(sndsock, pe->p_proto, IP_OPTIONS, (const char *)optlist, 184 srp->ipsr_len + 1) < 0) { 185 Fprintf(stderr, "%s: IP_OPTIONS: %s\n", prog, strerror(errno)); 186 exit(EXIT_FAILURE); 187 } 188 } 189 190 /* 191 * send a probe packet to the destination 192 */ 193 void 194 send_probe(int sndsock, struct sockaddr *to, struct ip *outip, 195 int seq, int ttl, struct timeval *tp, int packlen) 196 { 197 int cc; 198 struct udpiphdr *ui; 199 uchar_t *outp; /* packet following the IP header (UDP/ICMP) */ 200 struct udphdr *outudp; 201 struct icmp *outicmp; 202 struct outdata *outdata; 203 struct ip tip; 204 int optlen = 0; 205 int send_size; 206 207 /* initialize buffer pointers */ 208 outp = (uchar_t *)(outip + 1); 209 /* LINTED E_BAD_PTR_CAST_ALIGN */ 210 outudp = (struct udphdr *)outp; 211 /* LINTED E_BAD_PTR_CAST_ALIGN */ 212 outicmp = (struct icmp *)outp; 213 /* LINTED E_BAD_PTR_CAST_ALIGN */ 214 outdata = (struct outdata *)(outp + ICMP_MINLEN); 215 216 if (gw_count > 0) { 217 /* 8 = 5 (NO OPs) + 3 (code, len, ptr) */ 218 optlen = 8 + gw_count * sizeof (struct in_addr); 219 } 220 221 if (raw_req) { 222 send_size = packlen - optlen; 223 } else if (useicmp) { 224 send_size = packlen - optlen - sizeof (struct ip); 225 } else { 226 send_size = packlen - optlen - sizeof (struct ip) - 227 sizeof (struct udphdr); 228 } 229 230 outip->ip_ttl = ttl; 231 outip->ip_id = htons(ident + seq); 232 233 /* 234 * If a raw IPv4 packet is going to be sent, the Time to Live 235 * field in the packet was initialized above. Otherwise, it is 236 * initialized here using the IPPROTO_IP level socket option. 237 */ 238 if (!raw_req) { 239 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL, (char *)&ttl, 240 sizeof (ttl)) < 0) { 241 Fprintf(stderr, "%s: IP_TTL: %s\n", prog, 242 strerror(errno)); 243 exit(EXIT_FAILURE); 244 } 245 } 246 247 /* 248 * In most cases, the kernel will recalculate the ip checksum. 249 * But we must do it anyway so that the udp checksum comes out 250 * right. 251 */ 252 if (docksum) { 253 outip->ip_sum = 254 in_cksum((ushort_t *)outip, sizeof (*outip) + optlen); 255 if (outip->ip_sum == 0) 256 outip->ip_sum = 0xffff; 257 } 258 259 /* Payload */ 260 outdata->seq = seq; 261 outdata->ttl = ttl; 262 outdata->tv = *tp; 263 264 if (useicmp) { 265 outicmp->icmp_seq = htons(seq); 266 } else { 267 outudp->uh_dport = htons((port + seq) % (MAX_PORT + 1)); 268 } 269 270 if (!raw_req) 271 /* LINTED E_BAD_PTR_CAST_ALIGN */ 272 ((struct sockaddr_in *)to)->sin_port = outudp->uh_dport; 273 274 /* (We can only do the checksum if we know our ip address) */ 275 if (docksum) { 276 if (useicmp) { 277 outicmp->icmp_cksum = 0; 278 outicmp->icmp_cksum = in_cksum((ushort_t *)outicmp, 279 packlen - (sizeof (struct ip) + optlen)); 280 if (outicmp->icmp_cksum == 0) 281 outicmp->icmp_cksum = 0xffff; 282 } else { 283 /* Checksum (must save and restore ip header) */ 284 tip = *outip; 285 ui = (struct udpiphdr *)outip; 286 ui->ui_next = 0; 287 ui->ui_prev = 0; 288 ui->ui_x1 = 0; 289 ui->ui_len = outudp->uh_ulen; 290 outudp->uh_sum = 0; 291 outudp->uh_sum = in_cksum((ushort_t *)ui, packlen); 292 if (outudp->uh_sum == 0) 293 outudp->uh_sum = 0xffff; 294 *outip = tip; 295 } 296 } 297 298 if (raw_req) { 299 cc = sendto(sndsock, (char *)outip, send_size, 0, to, 300 sizeof (struct sockaddr_in)); 301 } else if (useicmp) { 302 cc = sendto(sndsock, (char *)outicmp, send_size, 0, to, 303 sizeof (struct sockaddr_in)); 304 } else { 305 cc = sendto(sndsock, (char *)outp, send_size, 0, to, 306 sizeof (struct sockaddr_in)); 307 } 308 309 if (cc < 0 || cc != send_size) { 310 if (cc < 0) { 311 Fprintf(stderr, "%s: sendto: %s\n", prog, 312 strerror(errno)); 313 } 314 Printf("%s: wrote %s %d chars, ret=%d\n", 315 prog, hostname, send_size, cc); 316 (void) fflush(stdout); 317 } 318 } 319 320 /* 321 * Check out the reply packet to see if it's what we were expecting. 322 * Returns REPLY_GOT_TARGET if the reply comes from the target 323 * REPLY_GOT_GATEWAY if an intermediate gateway sends TIME_EXCEEDED 324 * REPLY_GOT_OTHER for other kinds of unreachables indicating none of 325 * the above two cases 326 * 327 * It also sets the icmp type and icmp code values 328 */ 329 int 330 check_reply(struct msghdr *msg, int cc, int seq, uchar_t *type, uchar_t *code) 331 { 332 uchar_t *buf = msg->msg_iov->iov_base; 333 struct sockaddr_in *from_in = (struct sockaddr_in *)msg->msg_name; 334 struct icmp *icp; 335 int hlen; 336 int save_cc = cc; 337 struct ip *ip; 338 339 /* LINTED E_BAD_PTR_CAST_ALIGN */ 340 ip = (struct ip *)buf; 341 hlen = ip->ip_hl << 2; 342 if (cc < hlen + ICMP_MINLEN) { 343 if (verbose) { 344 Printf("packet too short (%d bytes) from %s\n", 345 cc, inet_ntoa(from_in->sin_addr)); 346 } 347 return (REPLY_SHORT_PKT); 348 } 349 cc -= hlen; 350 /* LINTED E_BAD_PTR_CAST_ALIGN */ 351 icp = (struct icmp *)(buf + hlen); 352 353 *type = icp->icmp_type; 354 *code = icp->icmp_code; 355 356 /* 357 * traceroute interpretes only ICMP_TIMXCEED_INTRANS, ICMP_UNREACH and 358 * ICMP_ECHOREPLY, ignores others 359 */ 360 if ((*type == ICMP_TIMXCEED && *code == ICMP_TIMXCEED_INTRANS) || 361 *type == ICMP_UNREACH || *type == ICMP_ECHOREPLY) { 362 struct ip *hip; 363 struct udphdr *up; 364 struct icmp *hicmp; 365 366 cc -= ICMP_MINLEN; 367 hip = &icp->icmp_ip; 368 hlen = hip->ip_hl << 2; 369 cc -= hlen; 370 if (useicmp) { 371 if (*type == ICMP_ECHOREPLY && 372 icp->icmp_id == htons(ident) && 373 icp->icmp_seq == htons(seq)) 374 return (REPLY_GOT_TARGET); 375 376 /* LINTED E_BAD_PTR_CAST_ALIGN */ 377 hicmp = (struct icmp *)((uchar_t *)hip + hlen); 378 379 if (ICMP_MINLEN <= cc && 380 hip->ip_p == IPPROTO_ICMP && 381 hicmp->icmp_id == htons(ident) && 382 hicmp->icmp_seq == htons(seq)) { 383 return ((*type == ICMP_TIMXCEED) ? 384 REPLY_GOT_GATEWAY : REPLY_GOT_OTHER); 385 } 386 } else { 387 /* LINTED E_BAD_PTR_CAST_ALIGN */ 388 up = (struct udphdr *)((uchar_t *)hip + hlen); 389 /* 390 * at least 4 bytes of UDP header is required for this 391 * check 392 */ 393 if (4 <= cc && 394 hip->ip_p == IPPROTO_UDP && 395 up->uh_sport == htons(ident) && 396 up->uh_dport == htons((port + seq) % 397 (MAX_PORT + 1))) { 398 if (*type == ICMP_UNREACH && 399 *code == ICMP_UNREACH_PORT) { 400 return (REPLY_GOT_TARGET); 401 } else if (*type == ICMP_TIMXCEED) { 402 return (REPLY_GOT_GATEWAY); 403 } else { 404 return (REPLY_GOT_OTHER); 405 } 406 } 407 } 408 } 409 410 if (verbose) { 411 int i, j; 412 uchar_t *lp = (uchar_t *)ip; 413 414 cc = save_cc; 415 Printf("\n%d bytes from %s to ", cc, 416 inet_ntoa(from_in->sin_addr)); 417 Printf("%s: icmp type %d (%s) code %d\n", 418 inet_ntoa(ip->ip_dst), *type, pr_type(*type), *code); 419 for (i = 0; i < cc; i += 4) { 420 Printf("%2d: x", i); 421 for (j = 0; ((j < 4) && ((i + j) < cc)); j++) 422 Printf("%2.2x", *lp++); 423 (void) putchar('\n'); 424 } 425 } 426 427 return (REPLY_SHORT_PKT); 428 } 429 430 /* 431 * convert an ICMP "type" field to a printable string. 432 */ 433 static char * 434 pr_type(uchar_t type) 435 { 436 static struct icmptype_table ttab[] = { 437 {ICMP_ECHOREPLY, "Echo Reply"}, 438 {1, "ICMP 1"}, 439 {2, "ICMP 2"}, 440 {ICMP_UNREACH, "Dest Unreachable"}, 441 {ICMP_SOURCEQUENCH, "Source Quench"}, 442 {ICMP_REDIRECT, "Redirect"}, 443 {6, "ICMP 6"}, 444 {7, "ICMP 7"}, 445 {ICMP_ECHO, "Echo"}, 446 {ICMP_ROUTERADVERT, "Router Advertisement"}, 447 {ICMP_ROUTERSOLICIT, "Router Solicitation"}, 448 {ICMP_TIMXCEED, "Time Exceeded"}, 449 {ICMP_PARAMPROB, "Param Problem"}, 450 {ICMP_TSTAMP, "Timestamp"}, 451 {ICMP_TSTAMPREPLY, "Timestamp Reply"}, 452 {ICMP_IREQ, "Info Request"}, 453 {ICMP_IREQREPLY, "Info Reply"}, 454 {ICMP_MASKREQ, "Netmask Request"}, 455 {ICMP_MASKREPLY, "Netmask Reply"} 456 }; 457 int i = 0; 458 459 for (i = 0; i < A_CNT(ttab); i++) { 460 if (ttab[i].type == type) 461 return (ttab[i].message); 462 } 463 464 return ("OUT-OF-RANGE"); 465 } 466 467 /* 468 * print the IPv4 src address of the reply packet 469 */ 470 void 471 print_addr(uchar_t *buf, int cc, struct sockaddr *from) 472 { 473 /* LINTED E_BAD_PTR_CAST_ALIGN */ 474 struct sockaddr_in *from_in = (struct sockaddr_in *)from; 475 struct ip *ip; 476 union any_in_addr ip_addr; 477 478 ip_addr.addr = from_in->sin_addr; 479 480 /* LINTED E_BAD_PTR_CAST_ALIGN */ 481 ip = (struct ip *)buf; 482 483 if (nflag) { 484 Printf(" %s", inet_ntoa(from_in->sin_addr)); 485 } else { 486 Printf(" %s (%s)", inet_name(&ip_addr, AF_INET), 487 inet_ntoa(from_in->sin_addr)); 488 } 489 490 if (verbose) 491 Printf(" %d bytes to %s", cc, inet_ntoa(ip->ip_dst)); 492 } 493 494 /* 495 * ICMP messages which doesn't mean we got the target, or we got a gateway, are 496 * processed here. It returns _B_TRUE if it's some sort of 'unreachable'. 497 */ 498 boolean_t 499 print_icmp_other(uchar_t type, uchar_t code) 500 { 501 boolean_t unreach = _B_FALSE; 502 503 /* 504 * this function only prints '!*' for ICMP unreachable messages, 505 * ignores others. 506 */ 507 if (type != ICMP_UNREACH) { 508 return (_B_FALSE); 509 } 510 511 switch (code) { 512 case ICMP_UNREACH_PORT: 513 break; 514 515 case ICMP_UNREACH_NET_UNKNOWN: 516 case ICMP_UNREACH_NET: 517 unreach = _B_TRUE; 518 Printf(" !N"); 519 break; 520 521 case ICMP_UNREACH_HOST_UNKNOWN: 522 case ICMP_UNREACH_HOST: 523 unreach = _B_TRUE; 524 Printf(" !H"); 525 break; 526 527 case ICMP_UNREACH_PROTOCOL: 528 Printf(" !P"); 529 break; 530 531 case ICMP_UNREACH_NEEDFRAG: 532 unreach = _B_TRUE; 533 Printf(" !F"); 534 break; 535 536 case ICMP_UNREACH_SRCFAIL: 537 unreach = _B_TRUE; 538 Printf(" !S"); 539 break; 540 541 case ICMP_UNREACH_FILTER_PROHIB: 542 case ICMP_UNREACH_NET_PROHIB: 543 case ICMP_UNREACH_HOST_PROHIB: 544 unreach = _B_TRUE; 545 Printf(" !X"); 546 break; 547 548 case ICMP_UNREACH_TOSNET: 549 case ICMP_UNREACH_TOSHOST: 550 unreach = _B_TRUE; 551 Printf(" !T"); 552 break; 553 554 case ICMP_UNREACH_ISOLATED: 555 case ICMP_UNREACH_HOST_PRECEDENCE: 556 case ICMP_UNREACH_PRECEDENCE_CUTOFF: 557 unreach = _B_TRUE; 558 Printf(" !U"); 559 break; 560 561 default: 562 unreach = _B_TRUE; 563 Printf(" !<%d>", code); 564 break; 565 } 566 567 return (unreach); 568 } 569