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