1/* 2 * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that: (1) source code distributions 7 * retain the above copyright notice and this paragraph in its entirety, (2) 8 * distributions including binary code include the above copyright notice and 9 * this paragraph in its entirety in the documentation or other materials 10 * provided with the distribution, and (3) all advertising materials mentioning 11 * features or use of this software display the following acknowledgement: 12 * ``This product includes software developed by the University of California, 13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of 14 * the University nor the names of its contributors may be used to endorse 15 * or promote products derived from this software without specific prior 16 * written permission. 17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 20 */ 21 22/* 23 * traceroute host - trace the route ip packets follow going to "host". 24 * 25 * Attempt to trace the route an ip packet would follow to some 26 * internet host. We find out intermediate hops by launching probe 27 * packets with a small ttl (time to live) then listening for an 28 * icmp "time exceeded" reply from a gateway. We start our probes 29 * with a ttl of one and increase by one until we get an icmp "port 30 * unreachable" (which means we got to "host") or hit a max (which 31 * defaults to net.inet.ip.ttl hops & can be changed with the -m flag). 32 * Three probes (change with -q flag) are sent at each ttl setting and 33 * a line is printed showing the ttl, address of the gateway and 34 * round trip time of each probe. If the probe answers come from 35 * different gateways, the address of each responding system will 36 * be printed. If there is no response within a 5 sec. timeout 37 * interval (changed with the -w flag), a "*" is printed for that 38 * probe. 39 * 40 * Probe packets are UDP format. We don't want the destination 41 * host to process them so the destination port is set to an 42 * unlikely value (if some clod on the destination is using that 43 * value, it can be changed with the -p flag). 44 * 45 * A sample use might be: 46 * 47 * [yak 71]% traceroute nis.nsf.net. 48 * traceroute to nis.nsf.net (35.1.1.48), 64 hops max, 40 byte packets 49 * 1 helios.ee.lbl.gov (128.3.112.1) 19 ms 19 ms 0 ms 50 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms 51 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms 52 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 39 ms 53 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 39 ms 39 ms 39 ms 54 * 6 128.32.197.4 (128.32.197.4) 40 ms 59 ms 59 ms 55 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 59 ms 56 * 8 129.140.70.13 (129.140.70.13) 99 ms 99 ms 80 ms 57 * 9 129.140.71.6 (129.140.71.6) 139 ms 239 ms 319 ms 58 * 10 129.140.81.7 (129.140.81.7) 220 ms 199 ms 199 ms 59 * 11 nic.merit.edu (35.1.1.48) 239 ms 239 ms 239 ms 60 * 61 * Note that lines 2 & 3 are the same. This is due to a buggy 62 * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards 63 * packets with a zero ttl. 64 * 65 * A more interesting example is: 66 * 67 * [yak 72]% traceroute allspice.lcs.mit.edu. 68 * traceroute to allspice.lcs.mit.edu (18.26.0.115), 64 hops max, 40 byte packets 69 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms 70 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 19 ms 19 ms 71 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 19 ms 72 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 19 ms 39 ms 39 ms 73 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 20 ms 39 ms 39 ms 74 * 6 128.32.197.4 (128.32.197.4) 59 ms 119 ms 39 ms 75 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 39 ms 76 * 8 129.140.70.13 (129.140.70.13) 80 ms 79 ms 99 ms 77 * 9 129.140.71.6 (129.140.71.6) 139 ms 139 ms 159 ms 78 * 10 129.140.81.7 (129.140.81.7) 199 ms 180 ms 300 ms 79 * 11 129.140.72.17 (129.140.72.17) 300 ms 239 ms 239 ms 80 * 12 * * * 81 * 13 128.121.54.72 (128.121.54.72) 259 ms 499 ms 279 ms 82 * 14 * * * 83 * 15 * * * 84 * 16 * * * 85 * 17 * * * 86 * 18 ALLSPICE.LCS.MIT.EDU (18.26.0.115) 339 ms 279 ms 279 ms 87 * 88 * (I start to see why I'm having so much trouble with mail to 89 * MIT.) Note that the gateways 12, 14, 15, 16 & 17 hops away 90 * either don't send ICMP "time exceeded" messages or send them 91 * with a ttl too small to reach us. 14 - 17 are running the 92 * MIT C Gateway code that doesn't send "time exceeded"s. God 93 * only knows what's going on with 12. 94 * 95 * The silent gateway 12 in the above may be the result of a bug in 96 * the 4.[23]BSD network code (and its derivatives): 4.x (x <= 3) 97 * sends an unreachable message using whatever ttl remains in the 98 * original datagram. Since, for gateways, the remaining ttl is 99 * zero, the icmp "time exceeded" is guaranteed to not make it back 100 * to us. The behavior of this bug is slightly more interesting 101 * when it appears on the destination system: 102 * 103 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms 104 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 39 ms 105 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 39 ms 19 ms 106 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 19 ms 107 * 5 ccn-nerif35.Berkeley.EDU (128.32.168.35) 39 ms 39 ms 39 ms 108 * 6 csgw.Berkeley.EDU (128.32.133.254) 39 ms 59 ms 39 ms 109 * 7 * * * 110 * 8 * * * 111 * 9 * * * 112 * 10 * * * 113 * 11 * * * 114 * 12 * * * 115 * 13 rip.Berkeley.EDU (128.32.131.22) 59 ms ! 39 ms ! 39 ms ! 116 * 117 * Notice that there are 12 "gateways" (13 is the final 118 * destination) and exactly the last half of them are "missing". 119 * What's really happening is that rip (a Sun-3 running Sun OS3.5) 120 * is using the ttl from our arriving datagram as the ttl in its 121 * icmp reply. So, the reply will time out on the return path 122 * (with no notice sent to anyone since icmp's aren't sent for 123 * icmp's) until we probe with a ttl that's at least twice the path 124 * length. I.e., rip is really only 7 hops away. A reply that 125 * returns with a ttl of 1 is a clue this problem exists. 126 * Traceroute prints a "!" after the time if the ttl is <= 1. 127 * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or 128 * non-standard (HPUX) software, expect to see this problem 129 * frequently and/or take care picking the target host of your 130 * probes. 131 * 132 * Other possible annotations after the time are !H, !N, !P (got a host, 133 * network or protocol unreachable, respectively), !S or !F (source 134 * route failed or fragmentation needed -- neither of these should 135 * ever occur and the associated gateway is busted if you see one). If 136 * almost all the probes result in some kind of unreachable, traceroute 137 * will give up and exit. 138 * 139 * Notes 140 * ----- 141 * This program must be run by root or be setuid. (I suggest that 142 * you *don't* make it setuid -- casual use could result in a lot 143 * of unnecessary traffic on our poor, congested nets.) 144 * 145 * This program requires a kernel mod that does not appear in any 146 * system available from Berkeley: A raw ip socket using proto 147 * IPPROTO_RAW must interpret the data sent as an ip datagram (as 148 * opposed to data to be wrapped in an ip datagram). See the README 149 * file that came with the source to this program for a description 150 * of the mods I made to /sys/netinet/raw_ip.c. Your mileage may 151 * vary. But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE 152 * MODIFIED TO RUN THIS PROGRAM. 153 * 154 * The udp port usage may appear bizarre (well, ok, it is bizarre). 155 * The problem is that an icmp message only contains 8 bytes of 156 * data from the original datagram. 8 bytes is the size of a udp 157 * header so, if we want to associate replies with the original 158 * datagram, the necessary information must be encoded into the 159 * udp header (the ip id could be used but there's no way to 160 * interlock with the kernel's assignment of ip id's and, anyway, 161 * it would have taken a lot more kernel hacking to allow this 162 * code to set the ip id). So, to allow two or more users to 163 * use traceroute simultaneously, we use this task's pid as the 164 * source port (the high bit is set to move the port number out 165 * of the "likely" range). To keep track of which probe is being 166 * replied to (so times and/or hop counts don't get confused by a 167 * reply that was delayed in transit), we increment the destination 168 * port number before each probe. 169 * 170 * Don't use this as a coding example. I was trying to find a 171 * routing problem and this code sort-of popped out after 48 hours 172 * without sleep. I was amazed it ever compiled, much less ran. 173 * 174 * I stole the idea for this program from Steve Deering. Since 175 * the first release, I've learned that had I attended the right 176 * IETF working group meetings, I also could have stolen it from Guy 177 * Almes or Matt Mathis. I don't know (or care) who came up with 178 * the idea first. I envy the originators' perspicacity and I'm 179 * glad they didn't keep the idea a secret. 180 * 181 * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or 182 * enhancements to the original distribution. 183 * 184 * I've hacked up a round-trip-route version of this that works by 185 * sending a loose-source-routed udp datagram through the destination 186 * back to yourself. Unfortunately, SO many gateways botch source 187 * routing, the thing is almost worthless. Maybe one day... 188 * 189 * -- Van Jacobson (van@ee.lbl.gov) 190 * Tue Dec 20 03:50:13 PST 1988 191 */ 192 193#include <sys/param.h> 194#include <sys/capsicum.h> 195#include <sys/file.h> 196#include <sys/ioctl.h> 197#include <sys/select.h> 198#include <sys/socket.h> 199#include <sys/sysctl.h> 200#include <sys/time.h> 201 202#include <netinet/in_systm.h> 203#include <netinet/in.h> 204#include <netinet/ip.h> 205#include <netinet/ip_var.h> 206#include <netinet/ip_icmp.h> 207#include <netinet/sctp.h> 208#include <netinet/sctp_header.h> 209#include <netinet/udp.h> 210#include <netinet/tcp.h> 211#include <netinet/tcpip.h> 212 213#include <arpa/inet.h> 214 215#ifdef WITH_CASPER 216#include <libcasper.h> 217#include <casper/cap_dns.h> 218#endif 219 220#ifdef IPSEC 221#include <net/route.h> 222#include <netipsec/ipsec.h> /* XXX */ 223#endif /* IPSEC */ 224 225#include <ctype.h> 226#include <capsicum_helpers.h> 227#include <err.h> 228#include <errno.h> 229#include <fcntl.h> 230#include <malloc.h> 231#include <memory.h> 232#include <netdb.h> 233#include <stdio.h> 234#include <stdlib.h> 235#include <string.h> 236#include <unistd.h> 237 238/* rfc1716 */ 239#ifndef ICMP_UNREACH_FILTER_PROHIB 240#define ICMP_UNREACH_FILTER_PROHIB 13 /* admin prohibited filter */ 241#endif 242#ifndef ICMP_UNREACH_HOST_PRECEDENCE 243#define ICMP_UNREACH_HOST_PRECEDENCE 14 /* host precedence violation */ 244#endif 245#ifndef ICMP_UNREACH_PRECEDENCE_CUTOFF 246#define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 /* precedence cutoff */ 247#endif 248 249#include "findsaddr.h" 250#include "ifaddrlist.h" 251#include "as.h" 252#include "traceroute.h" 253 254/* Maximum number of gateways (include room for one noop) */ 255#define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t))) 256 257#ifndef MAXHOSTNAMELEN 258#define MAXHOSTNAMELEN 64 259#endif 260 261#define Fprintf (void)fprintf 262#define Printf (void)printf 263 264/* What a GRE packet header looks like */ 265struct grehdr { 266 u_int16_t flags; 267 u_int16_t proto; 268 u_int16_t length; /* PPTP version of these fields */ 269 u_int16_t callId; 270}; 271#ifndef IPPROTO_GRE 272#define IPPROTO_GRE 47 273#endif 274 275/* For GRE, we prepare what looks like a PPTP packet */ 276#define GRE_PPTP_PROTO 0x880b 277 278/* Host name and address list */ 279struct hostinfo { 280 char *name; 281 int n; 282 u_int32_t *addrs; 283}; 284 285/* Data section of the probe packet */ 286struct outdata { 287 u_char seq; /* sequence number of this packet */ 288 u_char ttl; /* ttl packet left with */ 289 struct timeval tv; /* time packet left */ 290}; 291 292u_char packet[512]; /* last inbound (icmp) packet */ 293 294struct ip *outip; /* last output ip packet */ 295u_char *outp; /* last output inner protocol packet */ 296 297struct ip *hip = NULL; /* Quoted IP header */ 298int hiplen = 0; 299 300/* loose source route gateway list (including room for final destination) */ 301u_int32_t gwlist[NGATEWAYS + 1]; 302 303int s; /* receive (icmp) socket file descriptor */ 304int sndsock; /* send (udp) socket file descriptor */ 305 306struct sockaddr whereto; /* Who to try to reach */ 307struct sockaddr wherefrom; /* Who we are */ 308int packlen; /* total length of packet */ 309int protlen; /* length of protocol part of packet */ 310int minpacket; /* min ip packet size */ 311int maxpacket = 32 * 1024; /* max ip packet size */ 312int pmtu; /* Path MTU Discovery (RFC1191) */ 313u_int pausemsecs; 314 315char *prog; 316char *source; 317char *hostname; 318char *device; 319static const char devnull[] = "/dev/null"; 320 321int nprobes = -1; 322int max_ttl; 323int first_ttl = 1; 324u_short ident; 325u_short port; /* protocol specific base "port" */ 326 327int options; /* socket options */ 328int verbose; 329int waittime = 5; /* time to wait for response (in seconds) */ 330int nflag; /* print addresses numerically */ 331int as_path; /* print as numbers for each hop */ 332char *as_server = NULL; 333void *asn; 334#ifdef CANT_HACK_IPCKSUM 335int doipcksum = 0; /* don't calculate ip checksums by default */ 336#else 337int doipcksum = 1; /* calculate ip checksums by default */ 338#endif 339int optlen; /* length of ip options */ 340int fixedPort = 0; /* Use fixed destination port for TCP and UDP */ 341int printdiff = 0; /* Print the difference between sent and quoted */ 342int ecnflag = 0; /* ECN bleaching detection flag */ 343 344extern int optind; 345extern int opterr; 346extern char *optarg; 347 348#ifdef WITH_CASPER 349static cap_channel_t *capdns; 350#endif 351 352/* Forwards */ 353double deltaT(struct timeval *, struct timeval *); 354void freehostinfo(struct hostinfo *); 355void getaddr(u_int32_t *, char *); 356struct hostinfo *gethostinfo(char *); 357u_short in_cksum(u_short *, int); 358u_int32_t sctp_crc32c(const void *, u_int32_t); 359char *inetname(struct in_addr); 360int main(int, char **); 361u_short p_cksum(struct ip *, u_short *, int, int); 362int packet_ok(u_char *, int, struct sockaddr_in *, int); 363char *pr_type(u_char); 364void print(u_char *, int, struct sockaddr_in *); 365#ifdef IPSEC 366int setpolicy(int so, char *policy); 367#endif 368void send_probe(int, int); 369struct outproto *setproto(char *); 370int str2val(const char *, const char *, int, int); 371void tvsub(struct timeval *, struct timeval *); 372void usage(void); 373int wait_for_reply(int, struct sockaddr_in *, const struct timeval *); 374void pkt_compare(const u_char *, int, const u_char *, int); 375 376void udp_prep(struct outdata *); 377int udp_check(const u_char *, int); 378void udplite_prep(struct outdata *); 379int udplite_check(const u_char *, int); 380void tcp_prep(struct outdata *); 381int tcp_check(const u_char *, int); 382void sctp_prep(struct outdata *); 383int sctp_check(const u_char *, int); 384void gre_prep(struct outdata *); 385int gre_check(const u_char *, int); 386void gen_prep(struct outdata *); 387int gen_check(const u_char *, int); 388void icmp_prep(struct outdata *); 389int icmp_check(const u_char *, int); 390 391/* Descriptor structure for each outgoing protocol we support */ 392struct outproto { 393 char *name; /* name of protocol */ 394 const char *key; /* An ascii key for the bytes of the header */ 395 u_char num; /* IP protocol number */ 396 u_short hdrlen; /* max size of protocol header */ 397 u_short port; /* default base protocol-specific "port" */ 398 void (*prepare)(struct outdata *); 399 /* finish preparing an outgoing packet */ 400 int (*check)(const u_char *, int); 401 /* check an incoming packet */ 402}; 403 404/* List of supported protocols. The first one is the default. The last 405 one is the handler for generic protocols not explicitly listed. */ 406struct outproto protos[] = { 407 { 408 "udp", 409 "spt dpt len sum", 410 IPPROTO_UDP, 411 sizeof(struct udphdr), 412 32768 + 666, 413 udp_prep, 414 udp_check 415 }, 416 { 417 "udplite", 418 "spt dpt cov sum", 419 IPPROTO_UDPLITE, 420 sizeof(struct udphdr), 421 32768 + 666, 422 udplite_prep, 423 udplite_check 424 }, 425 { 426 "tcp", 427 "spt dpt seq ack xxflwin sum urp", 428 IPPROTO_TCP, 429 sizeof(struct tcphdr), 430 32768 + 666, 431 tcp_prep, 432 tcp_check 433 }, 434 { 435 "sctp", 436 "spt dpt vtag crc tyfllen tyfllen ", 437 IPPROTO_SCTP, 438 sizeof(struct sctphdr), 439 32768 + 666, 440 sctp_prep, 441 sctp_check 442 }, 443 { 444 "gre", 445 "flg pro len clid", 446 IPPROTO_GRE, 447 sizeof(struct grehdr), 448 GRE_PPTP_PROTO, 449 gre_prep, 450 gre_check 451 }, 452 { 453 "icmp", 454 "typ cod sum ", 455 IPPROTO_ICMP, 456 sizeof(struct icmp), 457 0, 458 icmp_prep, 459 icmp_check 460 }, 461 { 462 NULL, 463 "", 464 0, 465 2 * sizeof(u_short), 466 0, 467 gen_prep, 468 gen_check 469 }, 470}; 471struct outproto *proto = &protos[0]; 472 473const char *ip_hdr_key = "vhtslen id off tlprsum srcip dstip opts"; 474 475int 476main(int argc, char **argv) 477{ 478 register int op, code, n; 479 register char *cp; 480 register const char *err; 481 register u_int32_t *ap; 482 register struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom; 483 register struct sockaddr_in *to = (struct sockaddr_in *)&whereto; 484 register struct hostinfo *hi; 485 int on = 1; 486 register struct protoent *pe; 487 register int ttl, probe, i; 488 register int seq = 0; 489 int tos = 0, settos = 0; 490 register int lsrr = 0; 491 register u_short off = 0; 492 struct ifaddrlist *al; 493 char errbuf[132]; 494 int requestPort = -1; 495 int sump = 0; 496 int sockerrno; 497#ifdef WITH_CASPER 498 const char *types[] = { "NAME2ADDR", "ADDR2NAME" }; 499 int families[1]; 500 cap_channel_t *casper; 501#endif 502 cap_rights_t rights; 503 bool cansandbox; 504 505 /* Insure the socket fds won't be 0, 1 or 2 */ 506 if (open(devnull, O_RDONLY) < 0 || 507 open(devnull, O_RDONLY) < 0 || 508 open(devnull, O_RDONLY) < 0) { 509 Fprintf(stderr, "%s: open \"%s\": %s\n", 510 prog, devnull, strerror(errno)); 511 exit(1); 512 } 513 /* 514 * Do the setuid-required stuff first, then lose privileges ASAP. 515 * Do error checking for these two calls where they appeared in 516 * the original code. 517 */ 518 cp = "icmp"; 519 pe = getprotobyname(cp); 520 if (pe) { 521 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0) 522 sockerrno = errno; 523 else if ((sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) 524 sockerrno = errno; 525 } 526 527 if (setuid(getuid()) != 0) { 528 perror("setuid()"); 529 exit(1); 530 } 531 532#ifdef WITH_CASPER 533 casper = cap_init(); 534 if (casper == NULL) 535 errx(1, "unable to create casper process"); 536 capdns = cap_service_open(casper, "system.dns"); 537 if (capdns == NULL) 538 errx(1, "unable to open system.dns service"); 539 if (cap_dns_type_limit(capdns, types, 2) < 0) 540 errx(1, "unable to limit access to system.dns service"); 541 families[0] = AF_INET; 542 if (cap_dns_family_limit(capdns, families, 1) < 0) 543 errx(1, "unable to limit access to system.dns service"); 544#endif /* WITH_CASPER */ 545 546#ifdef IPCTL_DEFTTL 547 { 548 int mib[4] = { CTL_NET, PF_INET, IPPROTO_IP, IPCTL_DEFTTL }; 549 size_t sz = sizeof(max_ttl); 550 551 if (sysctl(mib, 4, &max_ttl, &sz, NULL, 0) == -1) { 552 perror("sysctl(net.inet.ip.ttl)"); 553 exit(1); 554 } 555 } 556#else /* !IPCTL_DEFTTL */ 557 max_ttl = 30; 558#endif 559 560#ifdef WITH_CASPER 561 cap_close(casper); 562#endif 563 564 if (argv[0] == NULL) 565 prog = "traceroute"; 566 else if ((cp = strrchr(argv[0], '/')) != NULL) 567 prog = cp + 1; 568 else 569 prog = argv[0]; 570 571 opterr = 0; 572 while ((op = getopt(argc, argv, "aA:eEdDFInrSvxf:g:i:M:m:P:p:q:s:t:w:z:")) != EOF) 573 switch (op) { 574 case 'a': 575 as_path = 1; 576 break; 577 578 case 'A': 579 as_path = 1; 580 as_server = optarg; 581 break; 582 583 case 'd': 584 options |= SO_DEBUG; 585 break; 586 587 case 'D': 588 printdiff = 1; 589 break; 590 591 case 'e': 592 fixedPort = 1; 593 break; 594 595 case 'E': 596 ecnflag = 1; 597 break; 598 599 case 'f': 600 case 'M': /* FreeBSD compat. */ 601 first_ttl = str2val(optarg, "first ttl", 1, 255); 602 break; 603 604 case 'F': 605 off = IP_DF; 606 break; 607 608 case 'g': 609 if (lsrr >= NGATEWAYS) { 610 Fprintf(stderr, 611 "%s: No more than %d gateways\n", 612 prog, NGATEWAYS); 613 exit(1); 614 } 615 getaddr(gwlist + lsrr, optarg); 616 ++lsrr; 617 break; 618 619 case 'i': 620 device = optarg; 621 break; 622 623 case 'I': 624 proto = setproto("icmp"); 625 break; 626 627 case 'm': 628 max_ttl = str2val(optarg, "max ttl", 1, 255); 629 break; 630 631 case 'n': 632 ++nflag; 633 break; 634 635 case 'P': 636 proto = setproto(optarg); 637 break; 638 639 case 'p': 640 requestPort = (u_short)str2val(optarg, "port", 641 1, (1 << 16) - 1); 642 break; 643 644 case 'q': 645 nprobes = str2val(optarg, "nprobes", 1, -1); 646 break; 647 648 case 'r': 649 options |= SO_DONTROUTE; 650 break; 651 652 case 's': 653 /* 654 * set the ip source address of the outbound 655 * probe (e.g., on a multi-homed host). 656 */ 657 source = optarg; 658 break; 659 660 case 'S': 661 sump = 1; 662 break; 663 664 case 't': 665 tos = str2val(optarg, "tos", 0, 255); 666 ++settos; 667 break; 668 669 case 'v': 670 ++verbose; 671 break; 672 673 case 'x': 674 doipcksum = (doipcksum == 0); 675 break; 676 677 case 'w': 678 waittime = str2val(optarg, "wait time", 679 1, 24 * 60 * 60); 680 break; 681 682 case 'z': 683 pausemsecs = str2val(optarg, "pause msecs", 684 0, 60 * 60 * 1000); 685 break; 686 687 default: 688 usage(); 689 } 690 691 /* Set requested port, if any, else default for this protocol */ 692 port = (requestPort != -1) ? requestPort : proto->port; 693 694 if (nprobes == -1) 695 nprobes = printdiff ? 1 : 3; 696 697 if (first_ttl > max_ttl) { 698 Fprintf(stderr, 699 "%s: first ttl (%d) may not be greater than max ttl (%d)\n", 700 prog, first_ttl, max_ttl); 701 exit(1); 702 } 703 704 if (!doipcksum) 705 Fprintf(stderr, "%s: Warning: ip checksums disabled\n", prog); 706 707 if (lsrr > 0) 708 optlen = (lsrr + 1) * sizeof(gwlist[0]); 709 minpacket = sizeof(*outip) + proto->hdrlen + optlen; 710 if (minpacket > 40) 711 packlen = minpacket; 712 else 713 packlen = 40; 714 715 /* Process destination and optional packet size */ 716 switch (argc - optind) { 717 718 case 2: 719 packlen = str2val(argv[optind + 1], 720 "packet length", minpacket, maxpacket); 721 /* Fall through */ 722 723 case 1: 724 hostname = argv[optind]; 725 hi = gethostinfo(hostname); 726 setsin(to, hi->addrs[0]); 727 if (hi->n > 1) 728 Fprintf(stderr, 729 "%s: Warning: %s has multiple addresses; using %s\n", 730 prog, hostname, inet_ntoa(to->sin_addr)); 731 hostname = hi->name; 732 hi->name = NULL; 733 freehostinfo(hi); 734 break; 735 736 default: 737 usage(); 738 } 739 740 setlinebuf(stdout); 741 742 protlen = packlen - sizeof(*outip) - optlen; 743 if ((proto->num == IPPROTO_SCTP) && (packlen & 3)) { 744 Fprintf(stderr, "%s: packet length must be a multiple of 4\n", 745 prog); 746 exit(1); 747 } 748 749 outip = (struct ip *)malloc((unsigned)packlen); 750 if (outip == NULL) { 751 Fprintf(stderr, "%s: malloc: %s\n", prog, strerror(errno)); 752 exit(1); 753 } 754 memset((char *)outip, 0, packlen); 755 756 outip->ip_v = IPVERSION; 757 if (settos) 758 outip->ip_tos = tos; 759 if (ecnflag) { 760 outip->ip_tos &= ~IPTOS_ECN_MASK; 761 outip->ip_tos |= IPTOS_ECN_ECT1; 762 } 763 outip->ip_len = htons(packlen); 764 outip->ip_off = htons(off); 765 outip->ip_p = proto->num; 766 outp = (u_char *)(outip + 1); 767 if (lsrr > 0) { 768 register u_char *optlist; 769 770 optlist = outp; 771 outp += optlen; 772 773 /* final hop */ 774 gwlist[lsrr] = to->sin_addr.s_addr; 775 776 outip->ip_dst.s_addr = gwlist[0]; 777 778 /* force 4 byte alignment */ 779 optlist[0] = IPOPT_NOP; 780 /* loose source route option */ 781 optlist[1] = IPOPT_LSRR; 782 i = lsrr * sizeof(gwlist[0]); 783 optlist[2] = i + 3; 784 /* Pointer to LSRR addresses */ 785 optlist[3] = IPOPT_MINOFF; 786 memcpy(optlist + 4, gwlist + 1, i); 787 } else 788 outip->ip_dst = to->sin_addr; 789 790 outip->ip_hl = (outp - (u_char *)outip) >> 2; 791 ident = (getpid() & 0xffff) | 0x8000; 792 793 if (pe == NULL) { 794 Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp); 795 exit(1); 796 } 797 if (s < 0) { 798 errno = sockerrno; 799 Fprintf(stderr, "%s: icmp socket: %s\n", prog, strerror(errno)); 800 exit(1); 801 } 802 if (options & SO_DEBUG) 803 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on, 804 sizeof(on)); 805 if (options & SO_DONTROUTE) 806 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on, 807 sizeof(on)); 808 809#if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) 810 if (setpolicy(s, "in bypass") < 0) 811 errx(1, "%s", ipsec_strerror()); 812 813 if (setpolicy(s, "out bypass") < 0) 814 errx(1, "%s", ipsec_strerror()); 815#endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */ 816 817 if (sndsock < 0) { 818 errno = sockerrno; 819 Fprintf(stderr, "%s: raw socket: %s\n", prog, strerror(errno)); 820 exit(1); 821 } 822 823#ifdef SO_SNDBUF 824 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen, 825 sizeof(packlen)) < 0) { 826 Fprintf(stderr, "%s: SO_SNDBUF: %s\n", prog, strerror(errno)); 827 exit(1); 828 } 829#endif 830#ifdef IP_HDRINCL 831 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on, 832 sizeof(on)) < 0) { 833 Fprintf(stderr, "%s: IP_HDRINCL: %s\n", prog, strerror(errno)); 834 exit(1); 835 } 836#else 837#ifdef IP_TOS 838 if (settos && setsockopt(sndsock, IPPROTO_IP, IP_TOS, 839 (char *)&tos, sizeof(tos)) < 0) { 840 Fprintf(stderr, "%s: setsockopt tos %d: %s\n", 841 prog, tos, strerror(errno)); 842 exit(1); 843 } 844#endif 845#endif 846 if (options & SO_DEBUG) 847 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on, 848 sizeof(on)); 849 if (options & SO_DONTROUTE) 850 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on, 851 sizeof(on)); 852 853 /* Get the interface address list */ 854 n = ifaddrlist(&al, errbuf); 855 if (n < 0) { 856 Fprintf(stderr, "%s: ifaddrlist: %s\n", prog, errbuf); 857 exit(1); 858 } 859 if (n == 0) { 860 Fprintf(stderr, 861 "%s: Can't find any network interfaces\n", prog); 862 exit(1); 863 } 864 865 /* Look for a specific device */ 866 if (device != NULL) { 867 for (i = n; i > 0; --i, ++al) 868 if (strcmp(device, al->device) == 0) 869 break; 870 if (i <= 0) { 871 Fprintf(stderr, "%s: Can't find interface %.32s\n", 872 prog, device); 873 exit(1); 874 } 875 } 876 877 /* Determine our source address */ 878 if (source == NULL) { 879 /* 880 * If a device was specified, use the interface address. 881 * Otherwise, try to determine our source address. 882 */ 883 if (device != NULL) 884 setsin(from, al->addr); 885 else if ((err = findsaddr(to, from)) != NULL) { 886 Fprintf(stderr, "%s: findsaddr: %s\n", 887 prog, err); 888 exit(1); 889 } 890 } else { 891 hi = gethostinfo(source); 892 source = hi->name; 893 hi->name = NULL; 894 /* 895 * If the device was specified make sure it 896 * corresponds to the source address specified. 897 * Otherwise, use the first address (and warn if 898 * there are more than one). 899 */ 900 if (device != NULL) { 901 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap) 902 if (*ap == al->addr) 903 break; 904 if (i <= 0) { 905 Fprintf(stderr, 906 "%s: %s is not on interface %.32s\n", 907 prog, source, device); 908 exit(1); 909 } 910 setsin(from, *ap); 911 } else { 912 setsin(from, hi->addrs[0]); 913 if (hi->n > 1) 914 Fprintf(stderr, 915 "%s: Warning: %s has multiple addresses; using %s\n", 916 prog, source, inet_ntoa(from->sin_addr)); 917 } 918 freehostinfo(hi); 919 } 920 921 outip->ip_src = from->sin_addr; 922 923 /* Check the source address (-s), if any, is valid */ 924 if (bind(sndsock, (struct sockaddr *)from, sizeof(*from)) < 0) { 925 Fprintf(stderr, "%s: bind: %s\n", 926 prog, strerror(errno)); 927 exit(1); 928 } 929 930 if (as_path) { 931 asn = as_setup(as_server); 932 if (asn == NULL) { 933 Fprintf(stderr, "%s: as_setup failed, AS# lookups" 934 " disabled\n", prog); 935 (void)fflush(stderr); 936 as_path = 0; 937 } 938 } 939 940 if (connect(sndsock, (struct sockaddr *)&whereto, 941 sizeof(whereto)) != 0) { 942 Fprintf(stderr, "%s: connect: %s\n", prog, strerror(errno)); 943 exit(1); 944 } 945 946#ifdef WITH_CASPER 947 cansandbox = true; 948#else 949 if (nflag) 950 cansandbox = true; 951 else 952 cansandbox = false; 953#endif 954 955 caph_cache_catpages(); 956 957 /* 958 * Here we enter capability mode. Further down access to global 959 * namespaces (e.g filesystem) is restricted (see capsicum(4)). 960 * We must connect(2) our socket before this point. 961 */ 962 if (cansandbox && cap_enter() < 0) { 963 if (errno != ENOSYS) { 964 Fprintf(stderr, "%s: cap_enter: %s\n", prog, 965 strerror(errno)); 966 exit(1); 967 } else { 968 cansandbox = false; 969 } 970 } 971 972 cap_rights_init(&rights, CAP_SEND, CAP_SETSOCKOPT); 973 if (cansandbox && cap_rights_limit(sndsock, &rights) < 0) { 974 Fprintf(stderr, "%s: cap_rights_limit sndsock: %s\n", prog, 975 strerror(errno)); 976 exit(1); 977 } 978 979 cap_rights_init(&rights, CAP_RECV, CAP_EVENT); 980 if (cansandbox && cap_rights_limit(s, &rights) < 0) { 981 Fprintf(stderr, "%s: cap_rights_limit s: %s\n", prog, 982 strerror(errno)); 983 exit(1); 984 } 985 986#if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) 987 if (setpolicy(sndsock, "in bypass") < 0) 988 errx(1, "%s", ipsec_strerror()); 989 990 if (setpolicy(sndsock, "out bypass") < 0) 991 errx(1, "%s", ipsec_strerror()); 992#endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */ 993 994 Fprintf(stderr, "%s to %s (%s)", 995 prog, hostname, inet_ntoa(to->sin_addr)); 996 if (source) 997 Fprintf(stderr, " from %s", source); 998 Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen); 999 (void)fflush(stderr); 1000 1001 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) { 1002 u_int32_t lastaddr = 0; 1003 int gotlastaddr = 0; 1004 int got_there = 0; 1005 int unreachable = 0; 1006 int sentfirst = 0; 1007 int loss; 1008 1009 Printf("%2d ", ttl); 1010 for (probe = 0, loss = 0; probe < nprobes; ++probe) { 1011 register int cc; 1012 struct timeval t1, t2; 1013 register struct ip *ip; 1014 struct outdata outdata; 1015 1016 if (sentfirst && pausemsecs > 0) 1017 usleep(pausemsecs * 1000); 1018 /* Prepare outgoing data */ 1019 outdata.seq = ++seq; 1020 outdata.ttl = ttl; 1021 1022 /* Avoid alignment problems by copying bytewise: */ 1023 (void)gettimeofday(&t1, NULL); 1024 memcpy(&outdata.tv, &t1, sizeof(outdata.tv)); 1025 1026 /* Finalize and send packet */ 1027 (*proto->prepare)(&outdata); 1028 send_probe(seq, ttl); 1029 ++sentfirst; 1030 1031 /* Wait for a reply */ 1032 while ((cc = wait_for_reply(s, from, &t1)) != 0) { 1033 double T; 1034 int precis; 1035 1036 (void)gettimeofday(&t2, NULL); 1037 i = packet_ok(packet, cc, from, seq); 1038 /* Skip short packet */ 1039 if (i == 0) 1040 continue; 1041 if (!gotlastaddr || 1042 from->sin_addr.s_addr != lastaddr) { 1043 if (gotlastaddr) 1044 printf("\n "); 1045 print(packet, cc, from); 1046 lastaddr = from->sin_addr.s_addr; 1047 ++gotlastaddr; 1048 } 1049 T = deltaT(&t1, &t2); 1050#ifdef SANE_PRECISION 1051 if (T >= 1000.0) 1052 precis = 0; 1053 else if (T >= 100.0) 1054 precis = 1; 1055 else if (T >= 10.0) 1056 precis = 2; 1057 else 1058#endif 1059 precis = 3; 1060 Printf(" %.*f ms", precis, T); 1061 if (ecnflag) { 1062 u_char ecn = hip->ip_tos & IPTOS_ECN_MASK; 1063 switch (ecn) { 1064 case IPTOS_ECN_ECT1: 1065 Printf(" (ecn=passed)"); 1066 break; 1067 case IPTOS_ECN_NOTECT: 1068 Printf(" (ecn=bleached)"); 1069 break; 1070 case IPTOS_ECN_CE: 1071 Printf(" (ecn=congested)"); 1072 break; 1073 default: 1074 Printf(" (ecn=mangled)"); 1075 break; 1076 } 1077 } 1078 if (printdiff) { 1079 Printf("\n"); 1080 Printf("%*.*s%s\n", 1081 -(outip->ip_hl << 3), 1082 outip->ip_hl << 3, 1083 ip_hdr_key, 1084 proto->key); 1085 pkt_compare((void *)outip, packlen, 1086 (void *)hip, hiplen); 1087 } 1088 if (i == -2) { 1089#ifndef ARCHAIC 1090 ip = (struct ip *)packet; 1091 if (ip->ip_ttl <= 1) 1092 Printf(" !"); 1093#endif 1094 ++got_there; 1095 break; 1096 } 1097 /* time exceeded in transit */ 1098 if (i == -1) 1099 break; 1100 code = i - 1; 1101 switch (code) { 1102 1103 case ICMP_UNREACH_PORT: 1104#ifndef ARCHAIC 1105 ip = (struct ip *)packet; 1106 if (ip->ip_ttl <= 1) 1107 Printf(" !"); 1108#endif 1109 ++got_there; 1110 break; 1111 1112 case ICMP_UNREACH_NET: 1113 ++unreachable; 1114 Printf(" !N"); 1115 break; 1116 1117 case ICMP_UNREACH_HOST: 1118 ++unreachable; 1119 Printf(" !H"); 1120 break; 1121 1122 case ICMP_UNREACH_PROTOCOL: 1123 ++got_there; 1124 Printf(" !P"); 1125 break; 1126 1127 case ICMP_UNREACH_NEEDFRAG: 1128 ++unreachable; 1129 Printf(" !F-%d", pmtu); 1130 break; 1131 1132 case ICMP_UNREACH_SRCFAIL: 1133 ++unreachable; 1134 Printf(" !S"); 1135 break; 1136 1137 case ICMP_UNREACH_NET_UNKNOWN: 1138 ++unreachable; 1139 Printf(" !U"); 1140 break; 1141 1142 case ICMP_UNREACH_HOST_UNKNOWN: 1143 ++unreachable; 1144 Printf(" !W"); 1145 break; 1146 1147 case ICMP_UNREACH_ISOLATED: 1148 ++unreachable; 1149 Printf(" !I"); 1150 break; 1151 1152 case ICMP_UNREACH_NET_PROHIB: 1153 ++unreachable; 1154 Printf(" !A"); 1155 break; 1156 1157 case ICMP_UNREACH_HOST_PROHIB: 1158 ++unreachable; 1159 Printf(" !Z"); 1160 break; 1161 1162 case ICMP_UNREACH_TOSNET: 1163 ++unreachable; 1164 Printf(" !Q"); 1165 break; 1166 1167 case ICMP_UNREACH_TOSHOST: 1168 ++unreachable; 1169 Printf(" !T"); 1170 break; 1171 1172 case ICMP_UNREACH_FILTER_PROHIB: 1173 ++unreachable; 1174 Printf(" !X"); 1175 break; 1176 1177 case ICMP_UNREACH_HOST_PRECEDENCE: 1178 ++unreachable; 1179 Printf(" !V"); 1180 break; 1181 1182 case ICMP_UNREACH_PRECEDENCE_CUTOFF: 1183 ++unreachable; 1184 Printf(" !C"); 1185 break; 1186 1187 default: 1188 ++unreachable; 1189 Printf(" !<%d>", code); 1190 break; 1191 } 1192 break; 1193 } 1194 if (cc == 0) { 1195 loss++; 1196 Printf(" *"); 1197 } 1198 (void)fflush(stdout); 1199 } 1200 if (sump) { 1201 Printf(" (%d%% loss)", (loss * 100) / nprobes); 1202 } 1203 putchar('\n'); 1204 if (got_there || 1205 (unreachable > 0 && unreachable >= nprobes - 1)) 1206 break; 1207 } 1208 if (as_path) 1209 as_shutdown(asn); 1210 exit(0); 1211} 1212 1213int 1214wait_for_reply(register int sock, register struct sockaddr_in *fromp, 1215 register const struct timeval *tp) 1216{ 1217 fd_set *fdsp; 1218 size_t nfds; 1219 struct timeval now, wait; 1220 register int cc = 0; 1221 register int error; 1222 int fromlen = sizeof(*fromp); 1223 1224 nfds = howmany(sock + 1, NFDBITS); 1225 if ((fdsp = malloc(nfds * sizeof(fd_mask))) == NULL) 1226 err(1, "malloc"); 1227 memset(fdsp, 0, nfds * sizeof(fd_mask)); 1228 FD_SET(sock, fdsp); 1229 1230 wait.tv_sec = tp->tv_sec + waittime; 1231 wait.tv_usec = tp->tv_usec; 1232 (void)gettimeofday(&now, NULL); 1233 tvsub(&wait, &now); 1234 if (wait.tv_sec < 0) { 1235 wait.tv_sec = 0; 1236 wait.tv_usec = 1; 1237 } 1238 1239 error = select(sock + 1, fdsp, NULL, NULL, &wait); 1240 if (error == -1 && errno == EINVAL) { 1241 Fprintf(stderr, "%s: botched select() args\n", prog); 1242 exit(1); 1243 } 1244 if (error > 0) 1245 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0, 1246 (struct sockaddr *)fromp, &fromlen); 1247 1248 free(fdsp); 1249 return (cc); 1250} 1251 1252void 1253send_probe(int seq, int ttl) 1254{ 1255 register int cc; 1256 1257 outip->ip_ttl = ttl; 1258 outip->ip_id = htons(ident + seq); 1259 1260 /* XXX undocumented debugging hack */ 1261 if (verbose > 1) { 1262 register const u_short *sp; 1263 register int nshorts, i; 1264 1265 sp = (u_short *)outip; 1266 nshorts = (u_int)packlen / sizeof(u_short); 1267 i = 0; 1268 Printf("[ %d bytes", packlen); 1269 while (--nshorts >= 0) { 1270 if ((i++ % 8) == 0) 1271 Printf("\n\t"); 1272 Printf(" %04x", ntohs(*sp++)); 1273 } 1274 if (packlen & 1) { 1275 if ((i % 8) == 0) 1276 Printf("\n\t"); 1277 Printf(" %02x", *(u_char *)sp); 1278 } 1279 Printf("]\n"); 1280 } 1281 1282#if !defined(IP_HDRINCL) && defined(IP_TTL) 1283 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL, 1284 (char *)&ttl, sizeof(ttl)) < 0) { 1285 Fprintf(stderr, "%s: setsockopt ttl %d: %s\n", 1286 prog, ttl, strerror(errno)); 1287 exit(1); 1288 } 1289#endif 1290 1291 cc = send(sndsock, (char *)outip, packlen, 0); 1292 if (cc < 0 || cc != packlen) { 1293 if (cc < 0) 1294 Fprintf(stderr, "%s: sendto: %s\n", 1295 prog, strerror(errno)); 1296 Printf("%s: wrote %s %d chars, ret=%d\n", 1297 prog, hostname, packlen, cc); 1298 (void)fflush(stdout); 1299 } 1300} 1301 1302#if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) 1303int 1304setpolicy(int so, char *policy) 1305{ 1306 char *buf; 1307 1308 buf = ipsec_set_policy(policy, strlen(policy)); 1309 if (buf == NULL) { 1310 warnx("%s", ipsec_strerror()); 1311 return (-1); 1312 } 1313 (void)setsockopt(so, IPPROTO_IP, IP_IPSEC_POLICY, 1314 buf, ipsec_get_policylen(buf)); 1315 1316 free(buf); 1317 1318 return (0); 1319} 1320#endif 1321 1322double 1323deltaT(struct timeval *t1p, struct timeval *t2p) 1324{ 1325 register double dt; 1326 1327 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 + 1328 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0; 1329 return (dt); 1330} 1331 1332/* 1333 * Convert an ICMP "type" field to a printable string. 1334 */ 1335char * 1336pr_type(register u_char t) 1337{ 1338 static char *ttab[] = { 1339 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable", 1340 "Source Quench", "Redirect", "ICMP 6", "ICMP 7", 1341 "Echo", "ICMP 9", "ICMP 10", "Time Exceeded", 1342 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request", 1343 "Info Reply" 1344 }; 1345 1346 if (t > 16) 1347 return ("OUT-OF-RANGE"); 1348 1349 return (ttab[t]); 1350} 1351 1352int 1353packet_ok(register u_char *buf, int cc, register struct sockaddr_in *from, 1354 register int seq) 1355{ 1356 register struct icmp *icp; 1357 register u_char type, code; 1358 register int hlen; 1359#ifndef ARCHAIC 1360 register struct ip *ip; 1361 1362 ip = (struct ip *) buf; 1363 hlen = ip->ip_hl << 2; 1364 if (cc < hlen + ICMP_MINLEN) { 1365 if (verbose) 1366 Printf("packet too short (%d bytes) from %s\n", cc, 1367 inet_ntoa(from->sin_addr)); 1368 return (0); 1369 } 1370 cc -= hlen; 1371 icp = (struct icmp *)(buf + hlen); 1372#else 1373 icp = (struct icmp *)buf; 1374#endif 1375 type = icp->icmp_type; 1376 code = icp->icmp_code; 1377 /* Path MTU Discovery (RFC1191) */ 1378 if (code != ICMP_UNREACH_NEEDFRAG) 1379 pmtu = 0; 1380 else { 1381 pmtu = ntohs(icp->icmp_nextmtu); 1382 } 1383 if (type == ICMP_ECHOREPLY 1384 && proto->num == IPPROTO_ICMP 1385 && (*proto->check)((u_char *)icp, (u_char)seq)) 1386 return (-2); 1387 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) || 1388 type == ICMP_UNREACH) { 1389 u_char *inner; 1390 1391 hip = &icp->icmp_ip; 1392 hiplen = ((u_char *)icp + cc) - (u_char *)hip; 1393 hlen = hip->ip_hl << 2; 1394 inner = (u_char *)((u_char *)hip + hlen); 1395 if (hlen + 16 <= cc 1396 && hip->ip_p == proto->num 1397 && (*proto->check)(inner, (u_char)seq)) 1398 return (type == ICMP_TIMXCEED ? -1 : code + 1); 1399 } 1400#ifndef ARCHAIC 1401 if (verbose) { 1402 register int i; 1403 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip; 1404 1405 Printf("\n%d bytes from %s to ", cc, inet_ntoa(from->sin_addr)); 1406 Printf("%s: icmp type %d (%s) code %d\n", 1407 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code); 1408 for (i = 4; i <= cc - ICMP_MINLEN; i += sizeof(*lp)) 1409 Printf("%2d: %8.8x\n", i, ntohl(*lp++)); 1410 } 1411#endif 1412 return (0); 1413} 1414 1415void 1416icmp_prep(struct outdata *outdata) 1417{ 1418 struct icmp *const icmpheader = (struct icmp *) outp; 1419 1420 icmpheader->icmp_type = ICMP_ECHO; 1421 icmpheader->icmp_id = htons(ident); 1422 icmpheader->icmp_seq = htons(outdata->seq); 1423 icmpheader->icmp_cksum = 0; 1424 icmpheader->icmp_cksum = in_cksum((u_short *)icmpheader, protlen); 1425 if (icmpheader->icmp_cksum == 0) 1426 icmpheader->icmp_cksum = 0xffff; 1427} 1428 1429int 1430icmp_check(const u_char *data, int seq) 1431{ 1432 struct icmp *const icmpheader = (struct icmp *) data; 1433 1434 return (icmpheader->icmp_id == htons(ident) 1435 && icmpheader->icmp_seq == htons(seq)); 1436} 1437 1438void 1439udp_prep(struct outdata *outdata) 1440{ 1441 struct udphdr *const outudp = (struct udphdr *) outp; 1442 1443 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0)); 1444 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq)); 1445 outudp->uh_ulen = htons((u_short)protlen); 1446 outudp->uh_sum = 0; 1447 if (doipcksum) { 1448 u_short sum = p_cksum(outip, (u_short *)outudp, protlen, protlen); 1449 outudp->uh_sum = (sum) ? sum : 0xffff; 1450 } 1451 1452 return; 1453} 1454 1455int 1456udp_check(const u_char *data, int seq) 1457{ 1458 struct udphdr *const udp = (struct udphdr *) data; 1459 1460 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) && 1461 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq)); 1462} 1463 1464void 1465udplite_prep(struct outdata *outdata) 1466{ 1467 struct udphdr *const outudp = (struct udphdr *) outp; 1468 1469 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0)); 1470 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq)); 1471 outudp->uh_ulen = htons(8); 1472 outudp->uh_sum = 0; 1473 if (doipcksum) { 1474 u_short sum = p_cksum(outip, (u_short *)outudp, protlen, 8); 1475 outudp->uh_sum = (sum) ? sum : 0xffff; 1476 } 1477 1478 return; 1479} 1480 1481int 1482udplite_check(const u_char *data, int seq) 1483{ 1484 struct udphdr *const udp = (struct udphdr *) data; 1485 1486 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) && 1487 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq)); 1488} 1489 1490void 1491tcp_prep(struct outdata *outdata) 1492{ 1493 struct tcphdr *const tcp = (struct tcphdr *) outp; 1494 1495 tcp->th_sport = htons(ident); 1496 tcp->th_dport = htons(port + (fixedPort ? 0 : outdata->seq)); 1497 tcp->th_seq = (tcp->th_sport << 16) | tcp->th_dport; 1498 tcp->th_ack = 0; 1499 tcp->th_off = 5; 1500 tcp->th_flags = TH_SYN; 1501 tcp->th_sum = 0; 1502 1503 if (doipcksum) 1504 tcp->th_sum = p_cksum(outip, (u_short *)tcp, protlen, protlen); 1505} 1506 1507int 1508tcp_check(const u_char *data, int seq) 1509{ 1510 struct tcphdr *const tcp = (struct tcphdr *) data; 1511 1512 return (ntohs(tcp->th_sport) == ident 1513 && ntohs(tcp->th_dport) == port + (fixedPort ? 0 : seq) 1514 && tcp->th_seq == (tcp_seq)((tcp->th_sport << 16) | tcp->th_dport)); 1515} 1516 1517void 1518sctp_prep(struct outdata *outdata) 1519{ 1520 struct sctphdr *const sctp = (struct sctphdr *) outp; 1521 struct sctp_chunkhdr *chk; 1522 struct sctp_init_chunk *init; 1523 struct sctp_paramhdr *param; 1524 1525 sctp->src_port = htons(ident); 1526 sctp->dest_port = htons(port + (fixedPort ? 0 : outdata->seq)); 1527 if (protlen >= (int)(sizeof(struct sctphdr) + 1528 sizeof(struct sctp_init_chunk))) { 1529 sctp->v_tag = 0; 1530 } else { 1531 sctp->v_tag = (sctp->src_port << 16) | sctp->dest_port; 1532 } 1533 sctp->checksum = htonl(0); 1534 if (protlen >= (int)(sizeof(struct sctphdr) + 1535 sizeof(struct sctp_init_chunk))) { 1536 /* 1537 * Send a packet containing an INIT chunk. This works 1538 * better in case of firewalls on the path, but 1539 * results in a probe packet containing at least 1540 * 32 bytes of payload. For shorter payloads, use 1541 * SHUTDOWN-ACK chunks. 1542 */ 1543 init = (struct sctp_init_chunk *)(sctp + 1); 1544 init->ch.chunk_type = SCTP_INITIATION; 1545 init->ch.chunk_flags = 0; 1546 init->ch.chunk_length = htons((u_int16_t)(protlen - 1547 sizeof(struct sctphdr))); 1548 init->init.initiate_tag = (sctp->src_port << 16) | 1549 sctp->dest_port; 1550 init->init.a_rwnd = htonl(1500); 1551 init->init.num_outbound_streams = htons(1); 1552 init->init.num_inbound_streams = htons(1); 1553 init->init.initial_tsn = htonl(0); 1554 if (protlen >= (int)(sizeof(struct sctphdr) + 1555 sizeof(struct sctp_init_chunk) + 1556 sizeof(struct sctp_paramhdr))) { 1557 param = (struct sctp_paramhdr *)(init + 1); 1558 param->param_type = htons(SCTP_PAD); 1559 param->param_length = 1560 htons((u_int16_t)(protlen - 1561 sizeof(struct sctphdr) - 1562 sizeof(struct sctp_init_chunk))); 1563 } 1564 } else { 1565 /* 1566 * Send a packet containing a SHUTDOWN-ACK chunk, 1567 * possibly followed by a PAD chunk. 1568 */ 1569 if (protlen >= 1570 (int)(sizeof(struct sctphdr) + 1571 sizeof(struct sctp_chunkhdr))) { 1572 chk = (struct sctp_chunkhdr *)(sctp + 1); 1573 chk->chunk_type = SCTP_SHUTDOWN_ACK; 1574 chk->chunk_flags = 0; 1575 chk->chunk_length = htons(4); 1576 } 1577 if (protlen >= 1578 (int)(sizeof(struct sctphdr) + 1579 2 * sizeof(struct sctp_chunkhdr))) { 1580 chk = chk + 1; 1581 chk->chunk_type = SCTP_PAD_CHUNK; 1582 chk->chunk_flags = 0; 1583 chk->chunk_length = htons(protlen - 1584 (sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))); 1585 } 1586 } 1587 if (doipcksum) { 1588 sctp->checksum = sctp_crc32c(sctp, protlen); 1589 } 1590} 1591 1592int 1593sctp_check(const u_char *data, int seq) 1594{ 1595 struct sctphdr *const sctp = (struct sctphdr *) data; 1596 1597 if (ntohs(sctp->src_port) != ident || 1598 ntohs(sctp->dest_port) != port + (fixedPort ? 0 : seq)) 1599 return (0); 1600 if (protlen < (int)(sizeof(struct sctphdr) + 1601 sizeof(struct sctp_init_chunk))) { 1602 return (sctp->v_tag == 1603 (u_int32_t)((sctp->src_port << 16) | sctp->dest_port)); 1604 } else { 1605 /* 1606 * Don't verify the initiate_tag, since it is not available, 1607 * most of the time. 1608 */ 1609 return (sctp->v_tag == 0); 1610 } 1611} 1612 1613void 1614gre_prep(struct outdata *outdata) 1615{ 1616 struct grehdr *const gre = (struct grehdr *) outp; 1617 1618 gre->flags = htons(0x2001); 1619 gre->proto = htons(port); 1620 gre->length = 0; 1621 gre->callId = htons(ident + outdata->seq); 1622} 1623 1624int 1625gre_check(const u_char *data, int seq) 1626{ 1627 struct grehdr *const gre = (struct grehdr *) data; 1628 1629 return (ntohs(gre->proto) == port 1630 && ntohs(gre->callId) == ident + seq); 1631} 1632 1633void 1634gen_prep(struct outdata *outdata) 1635{ 1636 u_int16_t *const ptr = (u_int16_t *) outp; 1637 1638 ptr[0] = htons(ident); 1639 ptr[1] = htons(port + outdata->seq); 1640} 1641 1642int 1643gen_check(const u_char *data, int seq) 1644{ 1645 u_int16_t *const ptr = (u_int16_t *) data; 1646 1647 return (ntohs(ptr[0]) == ident 1648 && ntohs(ptr[1]) == port + seq); 1649} 1650 1651void 1652print(register u_char *buf, register int cc, register struct sockaddr_in *from) 1653{ 1654 register struct ip *ip; 1655 register int hlen; 1656 char addr[INET_ADDRSTRLEN]; 1657 1658 ip = (struct ip *) buf; 1659 hlen = ip->ip_hl << 2; 1660 cc -= hlen; 1661 1662 strlcpy(addr, inet_ntoa(from->sin_addr), sizeof(addr)); 1663 1664 if (as_path) 1665 Printf(" [AS%u]", as_lookup(asn, addr, AF_INET)); 1666 1667 if (nflag) 1668 Printf(" %s", addr); 1669 else 1670 Printf(" %s (%s)", inetname(from->sin_addr), addr); 1671 1672 if (verbose) 1673 Printf(" %d bytes to %s", cc, inet_ntoa(ip->ip_dst)); 1674} 1675 1676/* 1677 * Checksum routine for UDP and TCP headers. 1678 */ 1679u_short 1680p_cksum(struct ip *ip, u_short *data, int len, int cov) 1681{ 1682 static struct ipovly ipo; 1683 u_short sum[2]; 1684 1685 ipo.ih_pr = ip->ip_p; 1686 ipo.ih_len = htons(len); 1687 ipo.ih_src = ip->ip_src; 1688 ipo.ih_dst = ip->ip_dst; 1689 1690 sum[1] = in_cksum((u_short *)&ipo, sizeof(ipo)); /* pseudo ip hdr cksum */ 1691 sum[0] = in_cksum(data, cov); /* payload data cksum */ 1692 1693 return (~in_cksum(sum, sizeof(sum))); 1694} 1695 1696/* 1697 * Checksum routine for Internet Protocol family headers (C Version) 1698 */ 1699u_short 1700in_cksum(register u_short *addr, register int len) 1701{ 1702 register int nleft = len; 1703 register u_short *w = addr; 1704 register u_short answer; 1705 register int sum = 0; 1706 1707 /* 1708 * Our algorithm is simple, using a 32 bit accumulator (sum), 1709 * we add sequential 16 bit words to it, and at the end, fold 1710 * back all the carry bits from the top 16 bits into the lower 1711 * 16 bits. 1712 */ 1713 while (nleft > 1) { 1714 sum += *w++; 1715 nleft -= 2; 1716 } 1717 1718 /* mop up an odd byte, if necessary */ 1719 if (nleft == 1) 1720 sum += *(u_char *)w; 1721 1722 /* 1723 * add back carry outs from top 16 bits to low 16 bits 1724 */ 1725 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */ 1726 sum += (sum >> 16); /* add carry */ 1727 answer = ~sum; /* truncate to 16 bits */ 1728 return (answer); 1729} 1730 1731/* 1732 * CRC32C routine for the Stream Control Transmission Protocol 1733 */ 1734 1735#define CRC32C(c, d) (c = (c >> 8) ^ crc_c[(c ^ (d)) & 0xFF]) 1736 1737static u_int32_t crc_c[256] = { 1738 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 1739 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 1740 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 1741 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, 1742 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 1743 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 1744 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 1745 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, 1746 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 1747 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 1748 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 1749 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, 1750 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 1751 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 1752 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 1753 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, 1754 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 1755 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 1756 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 1757 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, 1758 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 1759 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 1760 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 1761 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, 1762 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 1763 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 1764 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 1765 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, 1766 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 1767 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 1768 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 1769 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, 1770 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 1771 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 1772 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 1773 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, 1774 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 1775 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 1776 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 1777 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, 1778 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 1779 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 1780 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 1781 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, 1782 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 1783 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 1784 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 1785 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, 1786 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 1787 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 1788 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 1789 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, 1790 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 1791 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 1792 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 1793 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, 1794 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 1795 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 1796 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 1797 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, 1798 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 1799 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 1800 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 1801 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 1802}; 1803 1804u_int32_t 1805sctp_crc32c(const void *packet, u_int32_t len) 1806{ 1807 u_int32_t i, crc32c; 1808 u_int8_t byte0, byte1, byte2, byte3; 1809 const u_int8_t *buf = (const u_int8_t *)packet; 1810 1811 crc32c = ~0; 1812 for (i = 0; i < len; i++) 1813 CRC32C(crc32c, buf[i]); 1814 crc32c = ~crc32c; 1815 byte0 = crc32c & 0xff; 1816 byte1 = (crc32c >> 8) & 0xff; 1817 byte2 = (crc32c >> 16) & 0xff; 1818 byte3 = (crc32c >> 24) & 0xff; 1819 crc32c = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3); 1820 return (htonl(crc32c)); 1821} 1822 1823/* 1824 * Subtract 2 timeval structs: out = out - in. 1825 * Out is assumed to be within about LONG_MAX seconds of in. 1826 */ 1827void 1828tvsub(register struct timeval *out, register struct timeval *in) 1829{ 1830 1831 if ((out->tv_usec -= in->tv_usec) < 0) { 1832 --out->tv_sec; 1833 out->tv_usec += 1000000; 1834 } 1835 out->tv_sec -= in->tv_sec; 1836} 1837 1838/* 1839 * Construct an Internet address representation. 1840 * If the nflag has been supplied, give 1841 * numeric value, otherwise try for symbolic name. 1842 */ 1843char * 1844inetname(struct in_addr in) 1845{ 1846 register char *cp; 1847 register struct hostent *hp; 1848 static int first = 1; 1849 static char domain[MAXHOSTNAMELEN + 1], line[MAXHOSTNAMELEN + 1]; 1850 1851 if (first && !nflag) { 1852 first = 0; 1853 if (gethostname(domain, sizeof(domain) - 1) < 0) 1854 domain[0] = '\0'; 1855 else { 1856 cp = strchr(domain, '.'); 1857 if (cp == NULL) { 1858#ifdef WITH_CASPER 1859 if (capdns != NULL) 1860 hp = cap_gethostbyname(capdns, domain); 1861 else 1862#endif 1863 hp = gethostbyname(domain); 1864 if (hp != NULL) 1865 cp = strchr(hp->h_name, '.'); 1866 } 1867 if (cp == NULL) 1868 domain[0] = '\0'; 1869 else { 1870 ++cp; 1871 (void)strncpy(domain, cp, sizeof(domain) - 1); 1872 domain[sizeof(domain) - 1] = '\0'; 1873 } 1874 } 1875 } 1876 if (!nflag && in.s_addr != INADDR_ANY) { 1877#ifdef WITH_CASPER 1878 if (capdns != NULL) 1879 hp = cap_gethostbyaddr(capdns, (char *)&in, sizeof(in), 1880 AF_INET); 1881 else 1882#endif 1883 hp = gethostbyaddr((char *)&in, sizeof(in), AF_INET); 1884 if (hp != NULL) { 1885 if ((cp = strchr(hp->h_name, '.')) != NULL && 1886 strcmp(cp + 1, domain) == 0) 1887 *cp = '\0'; 1888 (void)strncpy(line, hp->h_name, sizeof(line) - 1); 1889 line[sizeof(line) - 1] = '\0'; 1890 return (line); 1891 } 1892 } 1893 return (inet_ntoa(in)); 1894} 1895 1896struct hostinfo * 1897gethostinfo(register char *hostname) 1898{ 1899 register int n; 1900 register struct hostent *hp; 1901 register struct hostinfo *hi; 1902 register char **p; 1903 register u_int32_t addr, *ap; 1904 1905 if (strlen(hostname) >= MAXHOSTNAMELEN) { 1906 Fprintf(stderr, "%s: hostname \"%.32s...\" is too long\n", 1907 prog, hostname); 1908 exit(1); 1909 } 1910 hi = calloc(1, sizeof(*hi)); 1911 if (hi == NULL) { 1912 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno)); 1913 exit(1); 1914 } 1915 addr = inet_addr(hostname); 1916 if ((int32_t)addr != -1) { 1917 hi->name = strdup(hostname); 1918 hi->n = 1; 1919 hi->addrs = calloc(1, sizeof(hi->addrs[0])); 1920 if (hi->addrs == NULL) { 1921 Fprintf(stderr, "%s: calloc %s\n", 1922 prog, strerror(errno)); 1923 exit(1); 1924 } 1925 hi->addrs[0] = addr; 1926 return (hi); 1927 } 1928 1929#ifdef WITH_CASPER 1930 if (capdns != NULL) 1931 hp = cap_gethostbyname(capdns, hostname); 1932 else 1933#endif 1934 hp = gethostbyname(hostname); 1935 if (hp == NULL) { 1936 Fprintf(stderr, "%s: unknown host %s\n", prog, hostname); 1937 exit(1); 1938 } 1939 if (hp->h_addrtype != AF_INET || hp->h_length != 4) { 1940 Fprintf(stderr, "%s: bad host %s\n", prog, hostname); 1941 exit(1); 1942 } 1943 hi->name = strdup(hp->h_name); 1944 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p) 1945 continue; 1946 hi->n = n; 1947 hi->addrs = calloc(n, sizeof(hi->addrs[0])); 1948 if (hi->addrs == NULL) { 1949 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno)); 1950 exit(1); 1951 } 1952 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p) 1953 memcpy(ap, *p, sizeof(*ap)); 1954 return (hi); 1955} 1956 1957void 1958freehostinfo(register struct hostinfo *hi) 1959{ 1960 if (hi->name != NULL) { 1961 free(hi->name); 1962 hi->name = NULL; 1963 } 1964 free((char *)hi->addrs); 1965 free((char *)hi); 1966} 1967 1968void 1969getaddr(register u_int32_t *ap, register char *hostname) 1970{ 1971 register struct hostinfo *hi; 1972 1973 hi = gethostinfo(hostname); 1974 *ap = hi->addrs[0]; 1975 freehostinfo(hi); 1976} 1977 1978void 1979setsin(register struct sockaddr_in *sin, register u_int32_t addr) 1980{ 1981 1982 memset(sin, 0, sizeof(*sin)); 1983 sin->sin_len = sizeof(*sin); 1984 sin->sin_family = AF_INET; 1985 sin->sin_addr.s_addr = addr; 1986} 1987 1988/* String to value with optional min and max. Handles decimal and hex. */ 1989int 1990str2val(register const char *str, register const char *what, 1991 register int mi, register int ma) 1992{ 1993 register const char *cp; 1994 register int val; 1995 char *ep; 1996 1997 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) { 1998 cp = str + 2; 1999 val = (int)strtol(cp, &ep, 16); 2000 } else 2001 val = (int)strtol(str, &ep, 10); 2002 if (*ep != '\0') { 2003 Fprintf(stderr, "%s: \"%s\" bad value for %s\n", 2004 prog, str, what); 2005 exit(1); 2006 } 2007 if (val < mi && mi >= 0) { 2008 if (mi == 0) 2009 Fprintf(stderr, "%s: %s must be >= %d\n", 2010 prog, what, mi); 2011 else 2012 Fprintf(stderr, "%s: %s must be > %d\n", 2013 prog, what, mi - 1); 2014 exit(1); 2015 } 2016 if (val > ma && ma >= 0) { 2017 Fprintf(stderr, "%s: %s must be <= %d\n", prog, what, ma); 2018 exit(1); 2019 } 2020 return (val); 2021} 2022 2023struct outproto * 2024setproto(char *pname) 2025{ 2026 struct outproto *proto; 2027 int i; 2028 2029 for (i = 0; protos[i].name != NULL; i++) { 2030 if (strcasecmp(protos[i].name, pname) == 0) { 2031 break; 2032 } 2033 } 2034 proto = &protos[i]; 2035 if (proto->name == NULL) { /* generic handler */ 2036 struct protoent *pe; 2037 u_long pnum; 2038 2039 /* Determine the IP protocol number */ 2040 if ((pe = getprotobyname(pname)) != NULL) 2041 pnum = pe->p_proto; 2042 else 2043 pnum = str2val(optarg, "proto number", 1, 255); 2044 proto->num = pnum; 2045 } 2046 return (proto); 2047} 2048 2049void 2050pkt_compare(const u_char *a, int la, const u_char *b, int lb) { 2051 int l; 2052 int i; 2053 2054 for (i = 0; i < la; i++) 2055 Printf("%02x", (unsigned int)a[i]); 2056 Printf("\n"); 2057 l = (la <= lb) ? la : lb; 2058 for (i = 0; i < l; i++) 2059 if (a[i] == b[i]) 2060 Printf("__"); 2061 else 2062 Printf("%02x", (unsigned int)b[i]); 2063 for (; i < lb; i++) 2064 Printf("%02x", (unsigned int)b[i]); 2065 Printf("\n"); 2066} 2067 2068 2069void 2070usage(void) 2071{ 2072 Fprintf(stderr, 2073 "Usage: %s [-adDeEFInrSvx] [-A as_server] [-f first_ttl] [-g gateway]\n" 2074 "\t[-i iface] [-m max_ttl] [-M first_ttl] [-p port] [-P proto]\n" 2075 "\t[-q nprobes] [-s src_addr] [-t tos] [-w waittime]\n" 2076 "\t[-z pausemsecs] host [packetlen]\n", prog); 2077 exit(1); 2078} 2079