traceroute.c revision 1.17
1 /* $NetBSD: traceroute.c,v 1.17 1997/09/02 21:48:50 is Exp $ */ 2 3 /*- 4 * Copyright (c) 1990, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Van Jacobson. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 */ 38 39 #ifndef lint 40 static char copyright[] = 41 "@(#) Copyright (c) 1990, 1993\n\ 42 The Regents of the University of California. All rights reserved.\n"; 43 #endif /* not lint */ 44 45 #ifndef lint 46 #if 0 47 static char sccsid[] = "@(#)traceroute.c 8.1 (Berkeley) 6/6/93";*/ 48 #else 49 static char rcsid[] = "$NetBSD: traceroute.c,v 1.17 1997/09/02 21:48:50 is Exp $"; 50 #endif 51 #endif /* not lint */ 52 53 /* 54 * traceroute host - trace the route ip packets follow going to "host". 55 * 56 * Attempt to trace the route an ip packet would follow to some 57 * internet host. We find out intermediate hops by launching probe 58 * packets with a small ttl (time to live) then listening for an 59 * icmp "time exceeded" reply from a gateway. We start our probes 60 * with a ttl of one and increase by one until we get an icmp "port 61 * unreachable" (which means we got to "host") or hit a max (which 62 * defaults to 30 hops & can be changed with the -m flag). Three 63 * probes (change with -q flag) are sent at each ttl setting and a 64 * line is printed showing the ttl, address of the gateway and 65 * round trip time of each probe. If the probe answers come from 66 * different gateways, the address of each responding system will 67 * be printed. If there is no response within a 5 sec. timeout 68 * interval (changed with the -w flag), a "*" is printed for that 69 * probe. 70 * 71 * Probe packets are UDP format. We don't want the destination 72 * host to process them so the destination port is set to an 73 * unlikely value (if some clod on the destination is using that 74 * value, it can be changed with the -p flag). 75 * 76 * A sample use might be: 77 * 78 * [yak 71]% traceroute nis.nsf.net. 79 * traceroute to nis.nsf.net (35.1.1.48), 30 hops max, 56 byte packet 80 * 1 helios.ee.lbl.gov (128.3.112.1) 19 ms 19 ms 0 ms 81 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms 82 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms 83 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 39 ms 84 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 39 ms 39 ms 39 ms 85 * 6 128.32.197.4 (128.32.197.4) 40 ms 59 ms 59 ms 86 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 59 ms 87 * 8 129.140.70.13 (129.140.70.13) 99 ms 99 ms 80 ms 88 * 9 129.140.71.6 (129.140.71.6) 139 ms 239 ms 319 ms 89 * 10 129.140.81.7 (129.140.81.7) 220 ms 199 ms 199 ms 90 * 11 nic.merit.edu (35.1.1.48) 239 ms 239 ms 239 ms 91 * 92 * Note that lines 2 & 3 are the same. This is due to a buggy 93 * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards 94 * packets with a zero ttl. 95 * 96 * A more interesting example is: 97 * 98 * [yak 72]% traceroute allspice.lcs.mit.edu. 99 * traceroute to allspice.lcs.mit.edu (18.26.0.115), 30 hops max 100 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms 101 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 19 ms 19 ms 102 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 19 ms 103 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 19 ms 39 ms 39 ms 104 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 20 ms 39 ms 39 ms 105 * 6 128.32.197.4 (128.32.197.4) 59 ms 119 ms 39 ms 106 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 39 ms 107 * 8 129.140.70.13 (129.140.70.13) 80 ms 79 ms 99 ms 108 * 9 129.140.71.6 (129.140.71.6) 139 ms 139 ms 159 ms 109 * 10 129.140.81.7 (129.140.81.7) 199 ms 180 ms 300 ms 110 * 11 129.140.72.17 (129.140.72.17) 300 ms 239 ms 239 ms 111 * 12 * * * 112 * 13 128.121.54.72 (128.121.54.72) 259 ms 499 ms 279 ms 113 * 14 * * * 114 * 15 * * * 115 * 16 * * * 116 * 17 * * * 117 * 18 ALLSPICE.LCS.MIT.EDU (18.26.0.115) 339 ms 279 ms 279 ms 118 * 119 * (I start to see why I'm having so much trouble with mail to 120 * MIT.) Note that the gateways 12, 14, 15, 16 & 17 hops away 121 * either don't send ICMP "time exceeded" messages or send them 122 * with a ttl too small to reach us. 14 - 17 are running the 123 * MIT C Gateway code that doesn't send "time exceeded"s. God 124 * only knows what's going on with 12. 125 * 126 * The silent gateway 12 in the above may be the result of a bug in 127 * the 4.[23]BSD network code (and its derivatives): 4.x (x <= 3) 128 * sends an unreachable message using whatever ttl remains in the 129 * original datagram. Since, for gateways, the remaining ttl is 130 * zero, the icmp "time exceeded" is guaranteed to not make it back 131 * to us. The behavior of this bug is slightly more interesting 132 * when it appears on the destination system: 133 * 134 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms 135 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 39 ms 136 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 39 ms 19 ms 137 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 19 ms 138 * 5 ccn-nerif35.Berkeley.EDU (128.32.168.35) 39 ms 39 ms 39 ms 139 * 6 csgw.Berkeley.EDU (128.32.133.254) 39 ms 59 ms 39 ms 140 * 7 * * * 141 * 8 * * * 142 * 9 * * * 143 * 10 * * * 144 * 11 * * * 145 * 12 * * * 146 * 13 rip.Berkeley.EDU (128.32.131.22) 59 ms ! 39 ms ! 39 ms ! 147 * 148 * Notice that there are 12 "gateways" (13 is the final 149 * destination) and exactly the last half of them are "missing". 150 * What's really happening is that rip (a Sun-3 running Sun OS3.5) 151 * is using the ttl from our arriving datagram as the ttl in its 152 * icmp reply. So, the reply will time out on the return path 153 * (with no notice sent to anyone since icmp's aren't sent for 154 * icmp's) until we probe with a ttl that's at least twice the path 155 * length. I.e., rip is really only 7 hops away. A reply that 156 * returns with a ttl of 1 is a clue this problem exists. 157 * Traceroute prints a "!" after the time if the ttl is <= 1. 158 * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or 159 * non-standard (HPUX) software, expect to see this problem 160 * frequently and/or take care picking the target host of your 161 * probes. 162 * 163 * Other possible annotations after the time are !H, !N, !P (got a host, 164 * network or protocol unreachable, respectively), !S or !F (source 165 * route failed or fragmentation needed -- neither of these should 166 * ever occur and the associated gateway is busted if you see one). If 167 * almost all the probes result in some kind of unreachable, traceroute 168 * will give up and exit. 169 * 170 * Notes 171 * ----- 172 * This program must be run by root or be setuid. (I suggest that 173 * you *don't* make it setuid -- casual use could result in a lot 174 * of unnecessary traffic on our poor, congested nets.) 175 * 176 * This program requires a kernel mod that does not appear in any 177 * system available from Berkeley: A raw ip socket using proto 178 * IPPROTO_RAW must interpret the data sent as an ip datagram (as 179 * opposed to data to be wrapped in a ip datagram). See the README 180 * file that came with the source to this program for a description 181 * of the mods I made to /sys/netinet/raw_ip.c. Your mileage may 182 * vary. But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE 183 * MODIFIED TO RUN THIS PROGRAM. 184 * 185 * The udp port usage may appear bizarre (well, ok, it is bizarre). 186 * The problem is that an icmp message only contains 8 bytes of 187 * data from the original datagram. 8 bytes is the size of a udp 188 * header so, if we want to associate replies with the original 189 * datagram, the necessary information must be encoded into the 190 * udp header (the ip id could be used but there's no way to 191 * interlock with the kernel's assignment of ip id's and, anyway, 192 * it would have taken a lot more kernel hacking to allow this 193 * code to set the ip id). So, to allow two or more users to 194 * use traceroute simultaneously, we use this task's pid as the 195 * source port (the high bit is set to move the port number out 196 * of the "likely" range). To keep track of which probe is being 197 * replied to (so times and/or hop counts don't get confused by a 198 * reply that was delayed in transit), we increment the destination 199 * port number before each probe. 200 * 201 * Don't use this as a coding example. I was trying to find a 202 * routing problem and this code sort-of popped out after 48 hours 203 * without sleep. I was amazed it ever compiled, much less ran. 204 * 205 * I stole the idea for this program from Steve Deering. Since 206 * the first release, I've learned that had I attended the right 207 * IETF working group meetings, I also could have stolen it from Guy 208 * Almes or Matt Mathis. I don't know (or care) who came up with 209 * the idea first. I envy the originators' perspicacity and I'm 210 * glad they didn't keep the idea a secret. 211 * 212 * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or 213 * enhancements to the original distribution. 214 * 215 * I've hacked up a round-trip-route version of this that works by 216 * sending a loose-source-routed udp datagram through the destination 217 * back to yourself. Unfortunately, SO many gateways botch source 218 * routing, the thing is almost worthless. Maybe one day... 219 * 220 * -- Van Jacobson (van (at) helios.ee.lbl.gov) 221 * Tue Dec 20 03:50:13 PST 1988 222 */ 223 224 #include <sys/param.h> 225 #include <sys/time.h> 226 #include <sys/socket.h> 227 #include <sys/file.h> 228 #include <sys/ioctl.h> 229 230 #include <netinet/in_systm.h> 231 #include <netinet/in.h> 232 #include <netinet/ip.h> 233 #include <netinet/ip_icmp.h> 234 #include <netinet/ip_var.h> 235 #include <netinet/udp.h> 236 237 #include <arpa/inet.h> 238 239 #include <ctype.h> 240 #include <err.h> 241 #include <errno.h> 242 #include <netdb.h> 243 #include <stdio.h> 244 #include <stdlib.h> 245 #include <string.h> 246 #include <unistd.h> 247 248 #define Fprintf (void)fprintf 249 #define Printf (void)printf 250 251 #define HEADERSIZE (sizeof(struct ip) + lsrrlen + sizeof(struct udphdr) + sizeof(struct packetdata)) 252 #define MAX_LSRR ((MAX_IPOPTLEN - 4) / 4) 253 254 /* 255 * Format of the data in a (udp) probe packet. 256 */ 257 struct packetdata { 258 u_char seq; /* sequence number of this packet */ 259 u_char ttl; /* ttl packet left with */ 260 struct timeval tv; /* time packet left */ 261 }; 262 263 struct in_addr gateway[MAX_LSRR + 1]; 264 int lsrrlen = 0; 265 266 u_char packet[512], *outpacket; /* last inbound (icmp) packet */ 267 268 int wait_for_reply __P((int, struct sockaddr_in *)); 269 void send_probe __P((int, int, struct sockaddr_in *)); 270 double deltaT __P((struct timeval *, struct timeval *)); 271 int packet_ok __P((u_char *, int, struct sockaddr_in *, int)); 272 void print __P((u_char *, int, struct sockaddr_in *)); 273 char *inetname __P((struct in_addr)); 274 void usage __P((void)); 275 276 int s; /* receive (icmp) socket file descriptor */ 277 int sndsock; /* send (udp) socket file descriptor */ 278 struct timezone tz; /* leftover */ 279 280 int datalen; /* How much data */ 281 282 char *source = 0; 283 char *hostname; 284 285 int nprobes = 3; 286 int max_ttl = 30; 287 u_short ident; 288 u_short port = 32768+666; /* start udp dest port # for probe packets */ 289 int options; /* socket options */ 290 int verbose; 291 int waittime = 5; /* time to wait for response (in seconds) */ 292 int nflag; /* print addresses numerically */ 293 int dump; 294 295 int 296 main(argc, argv) 297 int argc; 298 char *argv[]; 299 { 300 struct hostent *hp; 301 struct protoent *pe; 302 struct sockaddr_in from, to; 303 int ch, i, lsrr, on, probe, seq, tos, ttl, ttl_flag; 304 struct ip *ip; 305 306 lsrr = 0; 307 on = 1; 308 seq = tos = 0; 309 ttl_flag = 0; 310 while ((ch = getopt(argc, argv, "dDg:lm:np:q:rs:t:w:v")) != -1) 311 switch (ch) { 312 case 'd': 313 options |= SO_DEBUG; 314 break; 315 case 'D': 316 dump = 1; 317 break; 318 case 'g': 319 if (lsrr >= MAX_LSRR) 320 errx(1, "too many gateways; max %d", MAX_LSRR); 321 if (inet_aton(optarg, &gateway[lsrr]) == 0) { 322 hp = gethostbyname(optarg); 323 if (hp == 0) 324 errx(1, "unknown host %s", optarg); 325 memcpy(&gateway[lsrr], hp->h_addr, hp->h_length); 326 } 327 if (++lsrr == 1) 328 lsrrlen = 4; 329 lsrrlen += 4; 330 break; 331 case 'l': 332 ttl_flag = 1; 333 break; 334 case 'm': 335 max_ttl = atoi(optarg); 336 if (max_ttl < 1 || max_ttl > MAXTTL) 337 errx(1, "max ttl must be 1 to %d.", MAXTTL); 338 break; 339 case 'n': 340 nflag++; 341 break; 342 case 'p': 343 port = atoi(optarg); 344 if (port < 1) 345 errx(1, "port must be >0."); 346 break; 347 case 'q': 348 nprobes = atoi(optarg); 349 if (nprobes < 1) 350 errx(1, "nprobes must be >0."); 351 break; 352 case 'r': 353 options |= SO_DONTROUTE; 354 break; 355 case 's': 356 /* 357 * set the ip source address of the outbound 358 * probe (e.g., on a multi-homed host). 359 */ 360 source = optarg; 361 break; 362 case 't': 363 tos = atoi(optarg); 364 if (tos < 0 || tos > 255) 365 errx(1, "tos must be 0 to 255."); 366 break; 367 case 'v': 368 verbose++; 369 break; 370 case 'w': 371 waittime = atoi(optarg); 372 if (waittime <= 1) 373 errx(1, "wait must be >1 sec."); 374 break; 375 default: 376 usage(); 377 } 378 argc -= optind; 379 argv += optind; 380 381 if (argc < 1) 382 usage(); 383 384 setlinebuf (stdout); 385 386 (void) memset(&to, 0, sizeof(struct sockaddr)); 387 to.sin_family = AF_INET; 388 if (inet_aton(*argv, &to.sin_addr) != 0) 389 hostname = *argv; 390 else { 391 hp = gethostbyname(*argv); 392 if (hp == 0) 393 errx(1, "unknown host %s", *argv); 394 to.sin_family = hp->h_addrtype; 395 memcpy(&to.sin_addr, hp->h_addr, hp->h_length); 396 hostname = hp->h_name; 397 } 398 if (*++argv) 399 datalen = atoi(*argv); 400 if (datalen < 0 || datalen > IP_MAXPACKET - HEADERSIZE) 401 errx(1, "packet size must be 0 to %d.", 402 IP_MAXPACKET - HEADERSIZE); 403 datalen += HEADERSIZE; 404 405 outpacket = (u_char *)malloc(datalen); 406 if (outpacket == 0) 407 err(1, "malloc"); 408 (void) memset(outpacket, 0, datalen); 409 410 ip = (struct ip *)outpacket; 411 if (lsrr != 0) { 412 u_char *p; 413 p = (u_char *)(ip + 1); 414 *p++ = IPOPT_NOP; 415 *p++ = IPOPT_LSRR; 416 *p++ = lsrrlen - 1; 417 *p++ = IPOPT_MINOFF; 418 gateway[lsrr] = to.sin_addr; 419 for (i = 1; i <= lsrr; i++) 420 *((struct in_addr *)p)++ = gateway[i]; 421 ip->ip_dst = gateway[0]; 422 } else 423 ip->ip_dst = to.sin_addr; 424 ip->ip_off = 0; 425 ip->ip_hl = (sizeof(struct ip) + lsrrlen) >> 2; 426 ip->ip_p = IPPROTO_UDP; 427 ip->ip_v = IPVERSION; 428 ip->ip_tos = tos; 429 430 ident = (getpid() & 0xffff) | 0x8000; 431 432 if ((pe = getprotobyname("icmp")) == NULL) { 433 Fprintf(stderr, "icmp: unknown protocol\n"); 434 exit(10); 435 } 436 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0) 437 err(5, "icmp socket"); 438 if (options & SO_DEBUG) 439 (void) setsockopt(s, SOL_SOCKET, SO_DEBUG, 440 (char *)&on, sizeof(on)); 441 if (options & SO_DONTROUTE) 442 (void) setsockopt(s, SOL_SOCKET, SO_DONTROUTE, 443 (char *)&on, sizeof(on)); 444 445 if ((sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) 446 err(5, "raw socket"); 447 448 #ifdef SO_SNDBUF 449 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&datalen, 450 sizeof(datalen)) < 0) 451 err(6, "SO_SNDBUF"); 452 #endif SO_SNDBUF 453 #ifdef IP_HDRINCL 454 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on, 455 sizeof(on)) < 0) 456 err(6, "IP_HDRINCL"); 457 #endif IP_HDRINCL 458 if (options & SO_DEBUG) 459 (void) setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, 460 (char *)&on, sizeof(on)); 461 if (options & SO_DONTROUTE) 462 (void) setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, 463 (char *)&on, sizeof(on)); 464 465 if (source) { 466 (void) memset(&from, 0, sizeof(struct sockaddr)); 467 from.sin_family = AF_INET; 468 if (inet_aton(source, &from.sin_addr) == 0) 469 errx(1, "unknown host %s", source); 470 ip->ip_src = from.sin_addr; 471 #ifndef IP_HDRINCL 472 if (bind(sndsock, (struct sockaddr *)&from, sizeof(from)) < 0) 473 err(1, "bind"); 474 #endif IP_HDRINCL 475 } 476 477 setuid(getuid()); 478 Fprintf(stderr, "traceroute to %s (%s)", hostname, 479 inet_ntoa(to.sin_addr)); 480 if (source) 481 Fprintf(stderr, " from %s", source); 482 Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, datalen); 483 (void) fflush(stderr); 484 485 for (ttl = 1; ttl <= max_ttl; ++ttl) { 486 u_long lastaddr = 0; 487 int got_there = 0; 488 int unreachable = 0; 489 490 Printf("%2d ", ttl); 491 for (probe = 0; probe < nprobes; ++probe) { 492 int cc; 493 struct timeval t1, t2; 494 struct timezone tz; 495 496 (void) gettimeofday(&t1, &tz); 497 send_probe(++seq, ttl, &to); 498 while (cc = wait_for_reply(s, &from)) { 499 (void) gettimeofday(&t2, &tz); 500 /* 501 * Since we'll be receiving all ICMP 502 * messages to this host above, we may 503 * never end up with cc=0, so we need 504 * an additional termination check. 505 */ 506 if (t2.tv_sec - t1.tv_sec > waittime) { 507 cc = 0; 508 break; 509 } 510 if ((i = packet_ok(packet, cc, &from, seq))) { 511 if (from.sin_addr.s_addr != lastaddr) { 512 print(packet, cc, &from); 513 lastaddr = from.sin_addr.s_addr; 514 } 515 ip = (struct ip *)packet; 516 Printf(" %g ms", deltaT(&t1, &t2)); 517 if (ttl_flag) 518 Printf(" (ttl = %d)", 519 ip->ip_ttl); 520 if (i == -1) 521 break; 522 switch(i - 1) { 523 case ICMP_UNREACH_PORT: 524 #ifndef ARCHAIC 525 ip = (struct ip *)packet; 526 if (ip->ip_ttl <= 1) 527 Printf(" !"); 528 #endif ARCHAIC 529 ++got_there; 530 break; 531 case ICMP_UNREACH_NET: 532 ++unreachable; 533 Printf(" !N"); 534 break; 535 case ICMP_UNREACH_HOST: 536 ++unreachable; 537 Printf(" !H"); 538 break; 539 case ICMP_UNREACH_PROTOCOL: 540 ++got_there; 541 Printf(" !P"); 542 break; 543 case ICMP_UNREACH_NEEDFRAG: 544 ++unreachable; 545 Printf(" !F"); 546 break; 547 case ICMP_UNREACH_SRCFAIL: 548 ++unreachable; 549 Printf(" !S"); 550 break; 551 case ICMP_UNREACH_ADMIN_PROHIBIT: 552 ++unreachable; 553 Printf(" !A"); 554 break; 555 default: 556 ++unreachable; 557 printf(" !<%d>", i-1); 558 break; 559 } 560 break; 561 } 562 } 563 if (cc == 0) 564 Printf(" *"); 565 (void) fflush(stdout); 566 } 567 putchar('\n'); 568 if (got_there || unreachable >= nprobes) 569 exit(0); 570 } 571 } 572 573 int 574 wait_for_reply(sock, from) 575 int sock; 576 struct sockaddr_in *from; 577 { 578 fd_set fds; 579 struct timeval wait; 580 int cc = 0; 581 int fromlen = sizeof (*from); 582 583 FD_ZERO(&fds); 584 FD_SET(sock, &fds); 585 wait.tv_sec = waittime; wait.tv_usec = 0; 586 587 if (select(sock+1, &fds, (fd_set *)0, (fd_set *)0, &wait) > 0) 588 cc=recvfrom(s, (char *)packet, sizeof(packet), 0, 589 (struct sockaddr *)from, &fromlen); 590 591 return(cc); 592 } 593 594 void 595 dump_packet() 596 { 597 u_char *p; 598 int i; 599 600 Fprintf(stderr, "packet data:"); 601 for (p = outpacket, i = 0; i < datalen; i++) { 602 if ((i % 24) == 0) 603 Fprintf(stderr, "\n "); 604 Fprintf(stderr, " %02x", *p++); 605 } 606 Fprintf(stderr, "\n"); 607 } 608 609 void 610 send_probe(seq, ttl, to) 611 int seq, ttl; 612 struct sockaddr_in *to; 613 { 614 struct ip *ip = (struct ip *)outpacket; 615 u_char *p = (u_char *)(ip + 1); 616 struct udphdr *up = (struct udphdr *)(p + lsrrlen); 617 struct packetdata *op = (struct packetdata *)(up + 1); 618 int i; 619 620 ip->ip_len = datalen; 621 ip->ip_ttl = ttl; 622 ip->ip_id = htons(ident+seq); 623 624 up->uh_sport = htons(ident); 625 up->uh_dport = htons(port+seq); 626 up->uh_ulen = htons((u_short)(datalen - sizeof(struct ip) - lsrrlen)); 627 up->uh_sum = 0; 628 629 op->seq = seq; 630 op->ttl = ttl; 631 (void) gettimeofday(&op->tv, &tz); 632 633 if (dump) 634 dump_packet(); 635 636 i = sendto(sndsock, outpacket, datalen, 0, (struct sockaddr *)to, 637 sizeof(struct sockaddr_in)); 638 if (i < 0 || i != datalen) { 639 if (i<0) 640 perror("sendto"); 641 Printf("traceroute: wrote %s %d chars, ret=%d\n", hostname, 642 datalen, i); 643 (void) fflush(stdout); 644 } 645 } 646 647 648 double 649 deltaT(t1p, t2p) 650 struct timeval *t1p, *t2p; 651 { 652 register double dt; 653 654 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 + 655 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0; 656 return (dt); 657 } 658 659 660 /* 661 * Convert an ICMP "type" field to a printable string. 662 */ 663 char * 664 pr_type(t) 665 u_char t; 666 { 667 static char *ttab[] = { 668 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable", 669 "Source Quench", "Redirect", "ICMP 6", "ICMP 7", 670 "Echo", "ICMP 9", "ICMP 10", "Time Exceeded", 671 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request", 672 "Info Reply" 673 }; 674 675 if(t > 16) 676 return("OUT-OF-RANGE"); 677 678 return(ttab[t]); 679 } 680 681 682 int 683 packet_ok(buf, cc, from, seq) 684 u_char *buf; 685 int cc; 686 struct sockaddr_in *from; 687 int seq; 688 { 689 register struct icmp *icp; 690 u_char type, code; 691 int hlen; 692 #ifndef ARCHAIC 693 struct ip *ip; 694 695 ip = (struct ip *) buf; 696 hlen = ip->ip_hl << 2; 697 if (cc < hlen + ICMP_MINLEN) { 698 if (verbose) 699 Printf("packet too short (%d bytes) from %s\n", cc, 700 inet_ntoa(from->sin_addr)); 701 return (0); 702 } 703 cc -= hlen; 704 icp = (struct icmp *)(buf + hlen); 705 #else 706 icp = (struct icmp *)buf; 707 #endif ARCHAIC 708 type = icp->icmp_type; code = icp->icmp_code; 709 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) || 710 type == ICMP_UNREACH) { 711 struct ip *hip; 712 struct udphdr *up; 713 714 hip = &icp->icmp_ip; 715 hlen = hip->ip_hl << 2; 716 up = (struct udphdr *)((u_char *)hip + hlen); 717 if (hlen + 12 <= cc && hip->ip_p == IPPROTO_UDP && 718 up->uh_sport == htons(ident) && 719 up->uh_dport == htons(port+seq)) 720 return (type == ICMP_TIMXCEED? -1 : code+1); 721 } 722 #ifndef ARCHAIC 723 if (verbose) { 724 int i; 725 u_long *lp = (u_long *)&icp->icmp_ip; 726 727 Printf("\n%d bytes from %s", cc, inet_ntoa(from->sin_addr)); 728 Printf(" to %s", inet_ntoa(ip->ip_dst)); 729 Printf(": icmp type %d (%s) code %d\n", type, pr_type(type), 730 icp->icmp_code); 731 for (i = 4; i < cc ; i += sizeof(long)) 732 Printf("%2d: x%8.8lx\n", i, *lp++); 733 } 734 #endif ARCHAIC 735 return(0); 736 } 737 738 739 void 740 print(buf, cc, from) 741 u_char *buf; 742 int cc; 743 struct sockaddr_in *from; 744 { 745 struct ip *ip; 746 int hlen; 747 748 ip = (struct ip *) buf; 749 hlen = ip->ip_hl << 2; 750 cc -= hlen; 751 752 if (nflag) 753 Printf(" %s", inet_ntoa(from->sin_addr)); 754 else 755 Printf(" %s (%s)", inetname(from->sin_addr), 756 inet_ntoa(from->sin_addr)); 757 758 if (verbose) 759 Printf (" %d bytes to %s", cc, inet_ntoa (ip->ip_dst)); 760 } 761 762 763 #ifdef notyet 764 /* 765 * Checksum routine for Internet Protocol family headers (C Version) 766 */ 767 u_short 768 in_cksum(addr, len) 769 u_short *addr; 770 int len; 771 { 772 register int nleft = len; 773 register u_short *w = addr; 774 register u_short answer; 775 register int sum = 0; 776 777 /* 778 * Our algorithm is simple, using a 32 bit accumulator (sum), 779 * we add sequential 16 bit words to it, and at the end, fold 780 * back all the carry bits from the top 16 bits into the lower 781 * 16 bits. 782 */ 783 while (nleft > 1) { 784 sum += *w++; 785 nleft -= 2; 786 } 787 788 /* mop up an odd byte, if necessary */ 789 if (nleft == 1) 790 sum += *(u_char *)w; 791 792 /* 793 * add back carry outs from top 16 bits to low 16 bits 794 */ 795 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */ 796 sum += (sum >> 16); /* add carry */ 797 answer = ~sum; /* truncate to 16 bits */ 798 return (answer); 799 } 800 #endif notyet 801 802 /* 803 * Construct an Internet address representation. 804 * If the nflag has been supplied, give 805 * numeric value, otherwise try for symbolic name. 806 */ 807 char * 808 inetname(in) 809 struct in_addr in; 810 { 811 register char *cp; 812 static char line[50]; 813 struct hostent *hp; 814 static char domain[MAXHOSTNAMELEN + 1]; 815 static int first = 1; 816 817 if (first && !nflag) { 818 first = 0; 819 if (gethostname(domain, MAXHOSTNAMELEN) == 0 && 820 (cp = index(domain, '.'))) { 821 (void) strncpy(domain, cp + 1, sizeof(domain)); 822 domain[sizeof(domain) - 1] = '\0'; 823 } else 824 domain[0] = 0; 825 } 826 cp = 0; 827 if (!nflag && in.s_addr != INADDR_ANY) { 828 hp = gethostbyaddr((char *)&in, sizeof (in), AF_INET); 829 if (hp) { 830 if ((cp = index(hp->h_name, '.')) && 831 !strcmp(cp + 1, domain)) 832 *cp = 0; 833 cp = hp->h_name; 834 } 835 } 836 if (cp) { 837 (void) strncpy(line, cp, sizeof(line)); 838 line[sizeof(line) - 1] = '\0'; 839 } else { 840 in.s_addr = ntohl(in.s_addr); 841 #define C(x) ((x) & 0xff) 842 (void)snprintf(line, sizeof line, "%lu.%lu.%lu.%lu", 843 C(in.s_addr >> 24), C(in.s_addr >> 16), C(in.s_addr >> 8), 844 C(in.s_addr)); 845 } 846 return (line); 847 } 848 849 void 850 usage() 851 { 852 (void)fprintf(stderr, 853 "usage: traceroute [-dDnrv] [-g gateway_addr] ... [-m max_ttl] [-p port#]\n\t\ 854 [-q nqueries] [-s src_addr] [-t tos] [-w wait] host [data size]\n"); 855 exit(1); 856 } 857
Indexes created Wed Oct 15 16:09:53 GMT 2025