traceroute.c revision 1.9
1 /* $NetBSD: traceroute.c,v 1.9 1995/03/27 02:24:17 glass 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.9 1995/03/27 02:24:17 glass 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 Sprintf (void)sprintf 250 #define Printf (void)printf 251 252 #define HEADERSIZE (sizeof(struct ip) + lsrrlen + sizeof(struct udphdr) + sizeof(struct packetdata)) 253 #define MAX_LSRR ((MAX_IPOPTLEN - 4) / 4) 254 255 /* 256 * Format of the data in a (udp) probe packet. 257 */ 258 struct packetdata { 259 u_char seq; /* sequence number of this packet */ 260 u_char ttl; /* ttl packet left with */ 261 struct timeval tv; /* time packet left */ 262 }; 263 264 struct in_addr gateway[MAX_LSRR + 1]; 265 int lsrrlen = 0; 266 267 u_char packet[512], *outpacket; /* last inbound (icmp) packet */ 268 269 int wait_for_reply __P((int, struct sockaddr_in *)); 270 void send_probe __P((int, int, struct sockaddr_in *)); 271 double deltaT __P((struct timeval *, struct timeval *)); 272 int packet_ok __P((u_char *, int, struct sockaddr_in *, int)); 273 void print __P((u_char *, int, struct sockaddr_in *)); 274 char *inetname __P((struct in_addr)); 275 void usage __P((void)); 276 277 int s; /* receive (icmp) socket file descriptor */ 278 int sndsock; /* send (udp) socket file descriptor */ 279 struct timezone tz; /* leftover */ 280 281 int datalen; /* How much data */ 282 283 char *source = 0; 284 char *hostname; 285 286 int nprobes = 3; 287 int max_ttl = 30; 288 u_short ident; 289 u_short port = 32768+666; /* start udp dest port # for probe packets */ 290 int options; /* socket options */ 291 int verbose; 292 int waittime = 5; /* time to wait for response (in seconds) */ 293 int nflag; /* print addresses numerically */ 294 int dump; 295 296 int 297 main(argc, argv) 298 int argc; 299 char *argv[]; 300 { 301 struct hostent *hp; 302 struct protoent *pe; 303 struct sockaddr_in from, to; 304 int ch, i, lsrr, on, probe, seq, tos, ttl; 305 u_long gw; 306 struct ip *ip; 307 308 lsrr = 0; 309 on = 1; 310 seq = tos = 0; 311 while ((ch = getopt(argc, argv, "dDg:m:np:q:rs:t:w:v")) != -1) 312 switch (ch) { 313 case 'd': 314 options |= SO_DEBUG; 315 break; 316 case 'D': 317 dump = 1; 318 break; 319 case 'g': 320 if (lsrr >= MAX_LSRR) 321 errx(1, "too many gateways; max %d", MAX_LSRR); 322 gw = inet_addr(optarg); 323 if (gw == -1) { 324 hp = gethostbyname(optarg); 325 if (hp == 0) 326 errx(1, "unknown host %s", optarg); 327 memcpy(&gw, hp->h_addr, 4); 328 } 329 gateway[lsrr++].s_addr = gw; 330 if (lsrr == 1) 331 lsrrlen = 4; 332 lsrrlen += 4; 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 to.sin_addr.s_addr = inet_addr(*argv); 389 if (to.sin_addr.s_addr != -1) 390 hostname = *argv; 391 else { 392 hp = gethostbyname(*argv); 393 if (hp == 0) 394 errx(1, "unknown host %s", *argv); 395 to.sin_family = hp->h_addrtype; 396 memcpy(&to.sin_addr, hp->h_addr, hp->h_length); 397 hostname = hp->h_name; 398 } 399 if (*++argv) 400 datalen = atoi(*argv); 401 if (datalen < 0 || datalen > IP_MAXPACKET - HEADERSIZE) 402 errx(1, "packet size must be 0 to %d.", 403 IP_MAXPACKET - HEADERSIZE); 404 datalen += HEADERSIZE; 405 406 outpacket = (u_char *)malloc(datalen); 407 if (outpacket == 0) 408 err(1, "malloc"); 409 (void) memset(outpacket, 0, datalen); 410 411 ip = (struct ip *)outpacket; 412 if (lsrr != 0) { 413 u_char *p; 414 p = (u_char *)(ip + 1); 415 *p++ = IPOPT_NOP; 416 *p++ = IPOPT_LSRR; 417 *p++ = lsrrlen - 1; 418 *p++ = IPOPT_MINOFF; 419 gateway[lsrr] = to.sin_addr; 420 for (i = 1; i <= lsrr; i++) 421 *((struct in_addr *)p)++ = gateway[i]; 422 ip->ip_dst = gateway[0]; 423 } else 424 ip->ip_dst = to.sin_addr; 425 ip->ip_off = 0; 426 ip->ip_hl = (sizeof(struct ip) + lsrrlen) >> 2; 427 ip->ip_p = IPPROTO_UDP; 428 ip->ip_v = IPVERSION; 429 ip->ip_tos = tos; 430 431 ident = (getpid() & 0xffff) | 0x8000; 432 433 if ((pe = getprotobyname("icmp")) == NULL) { 434 Fprintf(stderr, "icmp: unknown protocol\n"); 435 exit(10); 436 } 437 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0) 438 err(5, "icmp socket"); 439 if (options & SO_DEBUG) 440 (void) setsockopt(s, SOL_SOCKET, SO_DEBUG, 441 (char *)&on, sizeof(on)); 442 if (options & SO_DONTROUTE) 443 (void) setsockopt(s, SOL_SOCKET, SO_DONTROUTE, 444 (char *)&on, sizeof(on)); 445 446 if ((sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) 447 err(5, "raw socket"); 448 449 #ifdef SO_SNDBUF 450 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&datalen, 451 sizeof(datalen)) < 0) 452 err(6, "SO_SNDBUF"); 453 #endif SO_SNDBUF 454 #ifdef IP_HDRINCL 455 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on, 456 sizeof(on)) < 0) 457 err(6, "IP_HDRINCL"); 458 #endif IP_HDRINCL 459 if (options & SO_DEBUG) 460 (void) setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, 461 (char *)&on, sizeof(on)); 462 if (options & SO_DONTROUTE) 463 (void) setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, 464 (char *)&on, sizeof(on)); 465 466 if (source) { 467 (void) memset(&from, 0, sizeof(struct sockaddr)); 468 from.sin_family = AF_INET; 469 from.sin_addr.s_addr = inet_addr(source); 470 if (from.sin_addr.s_addr == -1) 471 errx(1, "unknown host %s", source); 472 ip->ip_src = from.sin_addr; 473 #ifndef IP_HDRINCL 474 if (bind(sndsock, (struct sockaddr *)&from, sizeof(from)) < 0) 475 err(1, "bind"); 476 #endif IP_HDRINCL 477 } 478 479 Fprintf(stderr, "traceroute to %s (%s)", hostname, 480 inet_ntoa(to.sin_addr)); 481 if (source) 482 Fprintf(stderr, " from %s", source); 483 Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, datalen); 484 (void) fflush(stderr); 485 486 for (ttl = 1; ttl <= max_ttl; ++ttl) { 487 u_long lastaddr = 0; 488 int got_there = 0; 489 int unreachable = 0; 490 491 Printf("%2d ", ttl); 492 for (probe = 0; probe < nprobes; ++probe) { 493 int cc; 494 struct timeval t1, t2; 495 struct timezone tz; 496 497 (void) gettimeofday(&t1, &tz); 498 send_probe(++seq, ttl, &to); 499 while (cc = wait_for_reply(s, &from)) { 500 (void) gettimeofday(&t2, &tz); 501 if ((i = packet_ok(packet, cc, &from, seq))) { 502 if (from.sin_addr.s_addr != lastaddr) { 503 print(packet, cc, &from); 504 lastaddr = from.sin_addr.s_addr; 505 } 506 Printf(" %g ms", deltaT(&t1, &t2)); 507 switch(i - 1) { 508 case ICMP_UNREACH_PORT: 509 #ifndef ARCHAIC 510 ip = (struct ip *)packet; 511 if (ip->ip_ttl <= 1) 512 Printf(" !"); 513 #endif ARCHAIC 514 ++got_there; 515 break; 516 case ICMP_UNREACH_NET: 517 ++unreachable; 518 Printf(" !N"); 519 break; 520 case ICMP_UNREACH_HOST: 521 ++unreachable; 522 Printf(" !H"); 523 break; 524 case ICMP_UNREACH_PROTOCOL: 525 ++got_there; 526 Printf(" !P"); 527 break; 528 case ICMP_UNREACH_NEEDFRAG: 529 ++unreachable; 530 Printf(" !F"); 531 break; 532 case ICMP_UNREACH_SRCFAIL: 533 ++unreachable; 534 Printf(" !S"); 535 break; 536 } 537 break; 538 } 539 } 540 if (cc == 0) 541 Printf(" *"); 542 (void) fflush(stdout); 543 } 544 putchar('\n'); 545 if (got_there || unreachable >= nprobes) 546 exit(0); 547 } 548 } 549 550 int 551 wait_for_reply(sock, from) 552 int sock; 553 struct sockaddr_in *from; 554 { 555 fd_set fds; 556 struct timeval wait; 557 int cc = 0; 558 int fromlen = sizeof (*from); 559 560 FD_ZERO(&fds); 561 FD_SET(sock, &fds); 562 wait.tv_sec = waittime; wait.tv_usec = 0; 563 564 if (select(sock+1, &fds, (fd_set *)0, (fd_set *)0, &wait) > 0) 565 cc=recvfrom(s, (char *)packet, sizeof(packet), 0, 566 (struct sockaddr *)from, &fromlen); 567 568 return(cc); 569 } 570 571 void 572 dump_packet() 573 { 574 u_char *p; 575 int i; 576 577 Fprintf(stderr, "packet data:"); 578 for (p = outpacket, i = 0; i < datalen; i++) { 579 if ((i % 24) == 0) 580 Fprintf(stderr, "\n "); 581 Fprintf(stderr, " %02x", *p++); 582 } 583 Fprintf(stderr, "\n"); 584 } 585 586 void 587 send_probe(seq, ttl, to) 588 int seq, ttl; 589 struct sockaddr_in *to; 590 { 591 struct ip *ip = (struct ip *)outpacket; 592 u_char *p = (u_char *)(ip + 1); 593 struct udphdr *up = (struct udphdr *)(p + lsrrlen); 594 struct packetdata *op = (struct packetdata *)(up + 1); 595 int i; 596 597 ip->ip_len = datalen; 598 ip->ip_ttl = ttl; 599 ip->ip_id = htons(ident+seq); 600 601 up->uh_sport = htons(ident); 602 up->uh_dport = htons(port+seq); 603 up->uh_ulen = htons((u_short)(datalen - sizeof(struct ip) - lsrrlen)); 604 up->uh_sum = 0; 605 606 op->seq = seq; 607 op->ttl = ttl; 608 (void) gettimeofday(&op->tv, &tz); 609 610 if (dump) 611 dump_packet(); 612 613 i = sendto(sndsock, outpacket, datalen, 0, (struct sockaddr *)to, 614 sizeof(struct sockaddr_in)); 615 if (i < 0 || i != datalen) { 616 if (i<0) 617 perror("sendto"); 618 Printf("traceroute: wrote %s %d chars, ret=%d\n", hostname, 619 datalen, i); 620 (void) fflush(stdout); 621 } 622 } 623 624 625 double 626 deltaT(t1p, t2p) 627 struct timeval *t1p, *t2p; 628 { 629 register double dt; 630 631 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 + 632 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0; 633 return (dt); 634 } 635 636 637 /* 638 * Convert an ICMP "type" field to a printable string. 639 */ 640 char * 641 pr_type(t) 642 u_char t; 643 { 644 static char *ttab[] = { 645 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable", 646 "Source Quench", "Redirect", "ICMP 6", "ICMP 7", 647 "Echo", "ICMP 9", "ICMP 10", "Time Exceeded", 648 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request", 649 "Info Reply" 650 }; 651 652 if(t > 16) 653 return("OUT-OF-RANGE"); 654 655 return(ttab[t]); 656 } 657 658 659 int 660 packet_ok(buf, cc, from, seq) 661 u_char *buf; 662 int cc; 663 struct sockaddr_in *from; 664 int seq; 665 { 666 register struct icmp *icp; 667 u_char type, code; 668 int hlen; 669 #ifndef ARCHAIC 670 struct ip *ip; 671 672 ip = (struct ip *) buf; 673 hlen = ip->ip_hl << 2; 674 if (cc < hlen + ICMP_MINLEN) { 675 if (verbose) 676 Printf("packet too short (%d bytes) from %s\n", cc, 677 inet_ntoa(from->sin_addr)); 678 return (0); 679 } 680 cc -= hlen; 681 icp = (struct icmp *)(buf + hlen); 682 #else 683 icp = (struct icmp *)buf; 684 #endif ARCHAIC 685 type = icp->icmp_type; code = icp->icmp_code; 686 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) || 687 type == ICMP_UNREACH) { 688 struct ip *hip; 689 struct udphdr *up; 690 691 hip = &icp->icmp_ip; 692 hlen = hip->ip_hl << 2; 693 up = (struct udphdr *)((u_char *)hip + hlen); 694 if (hlen + 12 <= cc && hip->ip_p == IPPROTO_UDP && 695 up->uh_sport == htons(ident) && 696 up->uh_dport == htons(port+seq)) 697 return (type == ICMP_TIMXCEED? -1 : code+1); 698 } 699 #ifndef ARCHAIC 700 if (verbose) { 701 int i; 702 u_long *lp = (u_long *)&icp->icmp_ip; 703 704 Printf("\n%d bytes from %s to %s", cc, 705 inet_ntoa(from->sin_addr), inet_ntoa(ip->ip_dst)); 706 Printf(": icmp type %d (%s) code %d\n", type, pr_type(type), 707 icp->icmp_code); 708 for (i = 4; i < cc ; i += sizeof(long)) 709 Printf("%2d: x%8.8lx\n", i, *lp++); 710 } 711 #endif ARCHAIC 712 return(0); 713 } 714 715 716 void 717 print(buf, cc, from) 718 u_char *buf; 719 int cc; 720 struct sockaddr_in *from; 721 { 722 struct ip *ip; 723 int hlen; 724 725 ip = (struct ip *) buf; 726 hlen = ip->ip_hl << 2; 727 cc -= hlen; 728 729 if (nflag) 730 Printf(" %s", inet_ntoa(from->sin_addr)); 731 else 732 Printf(" %s (%s)", inetname(from->sin_addr), 733 inet_ntoa(from->sin_addr)); 734 735 if (verbose) 736 Printf (" %d bytes to %s", cc, inet_ntoa (ip->ip_dst)); 737 } 738 739 740 #ifdef notyet 741 /* 742 * Checksum routine for Internet Protocol family headers (C Version) 743 */ 744 u_short 745 in_cksum(addr, len) 746 u_short *addr; 747 int len; 748 { 749 register int nleft = len; 750 register u_short *w = addr; 751 register u_short answer; 752 register int sum = 0; 753 754 /* 755 * Our algorithm is simple, using a 32 bit accumulator (sum), 756 * we add sequential 16 bit words to it, and at the end, fold 757 * back all the carry bits from the top 16 bits into the lower 758 * 16 bits. 759 */ 760 while (nleft > 1) { 761 sum += *w++; 762 nleft -= 2; 763 } 764 765 /* mop up an odd byte, if necessary */ 766 if (nleft == 1) 767 sum += *(u_char *)w; 768 769 /* 770 * add back carry outs from top 16 bits to low 16 bits 771 */ 772 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */ 773 sum += (sum >> 16); /* add carry */ 774 answer = ~sum; /* truncate to 16 bits */ 775 return (answer); 776 } 777 #endif notyet 778 779 /* 780 * Construct an Internet address representation. 781 * If the nflag has been supplied, give 782 * numeric value, otherwise try for symbolic name. 783 */ 784 char * 785 inetname(in) 786 struct in_addr in; 787 { 788 register char *cp; 789 static char line[50]; 790 struct hostent *hp; 791 static char domain[MAXHOSTNAMELEN + 1]; 792 static int first = 1; 793 794 if (first && !nflag) { 795 first = 0; 796 if (gethostname(domain, MAXHOSTNAMELEN) == 0 && 797 (cp = index(domain, '.'))) 798 (void) strcpy(domain, cp + 1); 799 else 800 domain[0] = 0; 801 } 802 cp = 0; 803 if (!nflag && in.s_addr != INADDR_ANY) { 804 hp = gethostbyaddr((char *)&in, sizeof (in), AF_INET); 805 if (hp) { 806 if ((cp = index(hp->h_name, '.')) && 807 !strcmp(cp + 1, domain)) 808 *cp = 0; 809 cp = hp->h_name; 810 } 811 } 812 if (cp) 813 (void) strcpy(line, cp); 814 else { 815 in.s_addr = ntohl(in.s_addr); 816 #define C(x) ((x) & 0xff) 817 Sprintf(line, "%lu.%lu.%lu.%lu", C(in.s_addr >> 24), 818 C(in.s_addr >> 16), C(in.s_addr >> 8), C(in.s_addr)); 819 } 820 return (line); 821 } 822 823 void 824 usage() 825 { 826 (void)fprintf(stderr, 827 "usage: traceroute [-dDnrv] [-g gateway_addr] ... [-m max_ttl] [-p port#]\n\t\ 828 [-q nqueries] [-s src_addr] [-t tos] [-w wait] host [data size]\n"); 829 exit(1); 830 } 831
Indexes created Tue Sep 23 07:09:52 GMT 2025