2 * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 * The Regents of the University of California. All rights reserved.
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
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.
23 static const char copyright[] =
24 "@(#) Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999, 2000\n\
25 The Regents of the University of California. All rights reserved.\n";
27 static const char rcsid[] =
28 "@(#)$Id: traceroute.c,v 1.68 2000/12/14 08:04:33 leres Exp $ (LBL)";
30 static const char rcsid[] =
35 * traceroute host - trace the route ip packets follow going to "host".
37 * Attempt to trace the route an ip packet would follow to some
38 * internet host. We find out intermediate hops by launching probe
39 * packets with a small ttl (time to live) then listening for an
40 * icmp "time exceeded" reply from a gateway. We start our probes
41 * with a ttl of one and increase by one until we get an icmp "port
42 * unreachable" (which means we got to "host") or hit a max (which
43 * defaults to net.inet.ip.ttl hops & can be changed with the -m flag).
44 * Three probes (change with -q flag) are sent at each ttl setting and
45 * a line is printed showing the ttl, address of the gateway and
46 * round trip time of each probe. If the probe answers come from
47 * different gateways, the address of each responding system will
48 * be printed. If there is no response within a 5 sec. timeout
49 * interval (changed with the -w flag), a "*" is printed for that
52 * Probe packets are UDP format. We don't want the destination
53 * host to process them so the destination port is set to an
54 * unlikely value (if some clod on the destination is using that
55 * value, it can be changed with the -p flag).
57 * A sample use might be:
59 * [yak 71]% traceroute nis.nsf.net.
60 * traceroute to nis.nsf.net (35.1.1.48), 64 hops max, 56 byte packet
61 * 1 helios.ee.lbl.gov (128.3.112.1) 19 ms 19 ms 0 ms
62 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms
63 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 39 ms 19 ms
64 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 39 ms
65 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 39 ms 39 ms 39 ms
66 * 6 128.32.197.4 (128.32.197.4) 40 ms 59 ms 59 ms
67 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 59 ms
68 * 8 129.140.70.13 (129.140.70.13) 99 ms 99 ms 80 ms
69 * 9 129.140.71.6 (129.140.71.6) 139 ms 239 ms 319 ms
70 * 10 129.140.81.7 (129.140.81.7) 220 ms 199 ms 199 ms
71 * 11 nic.merit.edu (35.1.1.48) 239 ms 239 ms 239 ms
73 * Note that lines 2 & 3 are the same. This is due to a buggy
74 * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards
75 * packets with a zero ttl.
77 * A more interesting example is:
79 * [yak 72]% traceroute allspice.lcs.mit.edu.
80 * traceroute to allspice.lcs.mit.edu (18.26.0.115), 64 hops max
81 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms
82 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 19 ms 19 ms
83 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 19 ms
84 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 19 ms 39 ms 39 ms
85 * 5 ccn-nerif22.Berkeley.EDU (128.32.168.22) 20 ms 39 ms 39 ms
86 * 6 128.32.197.4 (128.32.197.4) 59 ms 119 ms 39 ms
87 * 7 131.119.2.5 (131.119.2.5) 59 ms 59 ms 39 ms
88 * 8 129.140.70.13 (129.140.70.13) 80 ms 79 ms 99 ms
89 * 9 129.140.71.6 (129.140.71.6) 139 ms 139 ms 159 ms
90 * 10 129.140.81.7 (129.140.81.7) 199 ms 180 ms 300 ms
91 * 11 129.140.72.17 (129.140.72.17) 300 ms 239 ms 239 ms
93 * 13 128.121.54.72 (128.121.54.72) 259 ms 499 ms 279 ms
98 * 18 ALLSPICE.LCS.MIT.EDU (18.26.0.115) 339 ms 279 ms 279 ms
100 * (I start to see why I'm having so much trouble with mail to
101 * MIT.) Note that the gateways 12, 14, 15, 16 & 17 hops away
102 * either don't send ICMP "time exceeded" messages or send them
103 * with a ttl too small to reach us. 14 - 17 are running the
104 * MIT C Gateway code that doesn't send "time exceeded"s. God
105 * only knows what's going on with 12.
107 * The silent gateway 12 in the above may be the result of a bug in
108 * the 4.[23]BSD network code (and its derivatives): 4.x (x <= 3)
109 * sends an unreachable message using whatever ttl remains in the
110 * original datagram. Since, for gateways, the remaining ttl is
111 * zero, the icmp "time exceeded" is guaranteed to not make it back
112 * to us. The behavior of this bug is slightly more interesting
113 * when it appears on the destination system:
115 * 1 helios.ee.lbl.gov (128.3.112.1) 0 ms 0 ms 0 ms
116 * 2 lilac-dmc.Berkeley.EDU (128.32.216.1) 39 ms 19 ms 39 ms
117 * 3 lilac-dmc.Berkeley.EDU (128.32.216.1) 19 ms 39 ms 19 ms
118 * 4 ccngw-ner-cc.Berkeley.EDU (128.32.136.23) 39 ms 40 ms 19 ms
119 * 5 ccn-nerif35.Berkeley.EDU (128.32.168.35) 39 ms 39 ms 39 ms
120 * 6 csgw.Berkeley.EDU (128.32.133.254) 39 ms 59 ms 39 ms
127 * 13 rip.Berkeley.EDU (128.32.131.22) 59 ms ! 39 ms ! 39 ms !
129 * Notice that there are 12 "gateways" (13 is the final
130 * destination) and exactly the last half of them are "missing".
131 * What's really happening is that rip (a Sun-3 running Sun OS3.5)
132 * is using the ttl from our arriving datagram as the ttl in its
133 * icmp reply. So, the reply will time out on the return path
134 * (with no notice sent to anyone since icmp's aren't sent for
135 * icmp's) until we probe with a ttl that's at least twice the path
136 * length. I.e., rip is really only 7 hops away. A reply that
137 * returns with a ttl of 1 is a clue this problem exists.
138 * Traceroute prints a "!" after the time if the ttl is <= 1.
139 * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or
140 * non-standard (HPUX) software, expect to see this problem
141 * frequently and/or take care picking the target host of your
144 * Other possible annotations after the time are !H, !N, !P (got a host,
145 * network or protocol unreachable, respectively), !S or !F (source
146 * route failed or fragmentation needed -- neither of these should
147 * ever occur and the associated gateway is busted if you see one). If
148 * almost all the probes result in some kind of unreachable, traceroute
149 * will give up and exit.
153 * This program must be run by root or be setuid. (I suggest that
154 * you *don't* make it setuid -- casual use could result in a lot
155 * of unnecessary traffic on our poor, congested nets.)
157 * This program requires a kernel mod that does not appear in any
158 * system available from Berkeley: A raw ip socket using proto
159 * IPPROTO_RAW must interpret the data sent as an ip datagram (as
160 * opposed to data to be wrapped in a ip datagram). See the README
161 * file that came with the source to this program for a description
162 * of the mods I made to /sys/netinet/raw_ip.c. Your mileage may
163 * vary. But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE
164 * MODIFIED TO RUN THIS PROGRAM.
166 * The udp port usage may appear bizarre (well, ok, it is bizarre).
167 * The problem is that an icmp message only contains 8 bytes of
168 * data from the original datagram. 8 bytes is the size of a udp
169 * header so, if we want to associate replies with the original
170 * datagram, the necessary information must be encoded into the
171 * udp header (the ip id could be used but there's no way to
172 * interlock with the kernel's assignment of ip id's and, anyway,
173 * it would have taken a lot more kernel hacking to allow this
174 * code to set the ip id). So, to allow two or more users to
175 * use traceroute simultaneously, we use this task's pid as the
176 * source port (the high bit is set to move the port number out
177 * of the "likely" range). To keep track of which probe is being
178 * replied to (so times and/or hop counts don't get confused by a
179 * reply that was delayed in transit), we increment the destination
180 * port number before each probe.
182 * Don't use this as a coding example. I was trying to find a
183 * routing problem and this code sort-of popped out after 48 hours
184 * without sleep. I was amazed it ever compiled, much less ran.
186 * I stole the idea for this program from Steve Deering. Since
187 * the first release, I've learned that had I attended the right
188 * IETF working group meetings, I also could have stolen it from Guy
189 * Almes or Matt Mathis. I don't know (or care) who came up with
190 * the idea first. I envy the originators' perspicacity and I'm
191 * glad they didn't keep the idea a secret.
193 * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
194 * enhancements to the original distribution.
196 * I've hacked up a round-trip-route version of this that works by
197 * sending a loose-source-routed udp datagram through the destination
198 * back to yourself. Unfortunately, SO many gateways botch source
199 * routing, the thing is almost worthless. Maybe one day...
201 * -- Van Jacobson (van@ee.lbl.gov)
202 * Tue Dec 20 03:50:13 PST 1988
205 #include <sys/param.h>
206 #include <sys/capsicum.h>
207 #include <sys/file.h>
208 #include <sys/ioctl.h>
209 #ifdef HAVE_SYS_SELECT_H
210 #include <sys/select.h>
212 #include <sys/socket.h>
213 #ifdef HAVE_SYS_SYSCTL_H
214 #include <sys/sysctl.h>
216 #include <sys/time.h>
218 #include <netinet/in_systm.h>
219 #include <netinet/in.h>
220 #include <netinet/ip.h>
221 #include <netinet/ip_var.h>
222 #include <netinet/ip_icmp.h>
223 #include <netinet/sctp.h>
224 #include <netinet/sctp_header.h>
225 #include <netinet/udp.h>
226 #include <netinet/tcp.h>
227 #include <netinet/tcpip.h>
229 #include <arpa/inet.h>
231 #ifdef HAVE_LIBCASPER
232 #include <libcasper.h>
233 #include <casper/cap_dns.h>
237 #include <net/route.h>
238 #include <netipsec/ipsec.h> /* XXX */
256 #ifndef ICMP_UNREACH_FILTER_PROHIB
257 #define ICMP_UNREACH_FILTER_PROHIB 13 /* admin prohibited filter */
259 #ifndef ICMP_UNREACH_HOST_PRECEDENCE
260 #define ICMP_UNREACH_HOST_PRECEDENCE 14 /* host precedence violation */
262 #ifndef ICMP_UNREACH_PRECEDENCE_CUTOFF
263 #define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 /* precedence cutoff */
266 #include "findsaddr.h"
267 #include "ifaddrlist.h"
269 #include "traceroute.h"
271 /* Maximum number of gateways (include room for one noop) */
272 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
274 #ifndef MAXHOSTNAMELEN
275 #define MAXHOSTNAMELEN 64
278 #define Fprintf (void)fprintf
279 #define Printf (void)printf
281 /* What a GRE packet header looks like */
285 u_int16_t length; /* PPTP version of these fields */
289 #define IPPROTO_GRE 47
292 /* For GRE, we prepare what looks like a PPTP packet */
293 #define GRE_PPTP_PROTO 0x880b
295 /* Host name and address list */
302 /* Data section of the probe packet */
304 u_char seq; /* sequence number of this packet */
305 u_char ttl; /* ttl packet left with */
306 struct timeval tv; /* time packet left */
309 #ifndef HAVE_ICMP_NEXTMTU
310 /* Path MTU Discovery (RFC1191) */
317 u_char packet[512]; /* last inbound (icmp) packet */
319 struct ip *outip; /* last output ip packet */
320 u_char *outp; /* last output inner protocol packet */
322 struct ip *hip = NULL; /* Quoted IP header */
325 /* loose source route gateway list (including room for final destination) */
326 u_int32_t gwlist[NGATEWAYS + 1];
328 int s; /* receive (icmp) socket file descriptor */
329 int sndsock; /* send (udp) socket file descriptor */
331 struct sockaddr whereto; /* Who to try to reach */
332 struct sockaddr wherefrom; /* Who we are */
333 int packlen; /* total length of packet */
334 int protlen; /* length of protocol part of packet */
335 int minpacket; /* min ip packet size */
336 int maxpacket = 32 * 1024; /* max ip packet size */
337 int pmtu; /* Path MTU Discovery (RFC1191) */
344 static const char devnull[] = "/dev/null";
350 u_short port; /* protocol specific base "port" */
352 int options; /* socket options */
354 int waittime = 5; /* time to wait for response (in seconds) */
355 int nflag; /* print addresses numerically */
356 int as_path; /* print as numbers for each hop */
357 char *as_server = NULL;
359 #ifdef CANT_HACK_IPCKSUM
360 int doipcksum = 0; /* don't calculate ip checksums by default */
362 int doipcksum = 1; /* calculate ip checksums by default */
364 int optlen; /* length of ip options */
365 int fixedPort = 0; /* Use fixed destination port for TCP and UDP */
366 int printdiff = 0; /* Print the difference between sent and quoted */
372 #ifdef HAVE_LIBCASPER
373 static cap_channel_t *capdns;
377 double deltaT(struct timeval *, struct timeval *);
378 void freehostinfo(struct hostinfo *);
379 void getaddr(u_int32_t *, char *);
380 struct hostinfo *gethostinfo(char *);
381 u_short in_cksum(u_short *, int);
382 u_int32_t sctp_crc32c(const void *, u_int32_t);
383 char *inetname(struct in_addr);
384 int main(int, char **);
385 u_short p_cksum(struct ip *, u_short *, int, int);
386 int packet_ok(u_char *, int, struct sockaddr_in *, int);
387 char *pr_type(u_char);
388 void print(u_char *, int, struct sockaddr_in *);
390 int setpolicy __P((int so, char *policy));
392 void send_probe(int, int);
393 struct outproto *setproto(char *);
394 int str2val(const char *, const char *, int, int);
395 void tvsub(struct timeval *, struct timeval *);
397 int wait_for_reply(int, struct sockaddr_in *, const struct timeval *);
398 void pkt_compare(const u_char *, int, const u_char *, int);
403 void udp_prep(struct outdata *);
404 int udp_check(const u_char *, int);
405 void udplite_prep(struct outdata *);
406 int udplite_check(const u_char *, int);
407 void tcp_prep(struct outdata *);
408 int tcp_check(const u_char *, int);
409 void sctp_prep(struct outdata *);
410 int sctp_check(const u_char *, int);
411 void gre_prep(struct outdata *);
412 int gre_check(const u_char *, int);
413 void gen_prep(struct outdata *);
414 int gen_check(const u_char *, int);
415 void icmp_prep(struct outdata *);
416 int icmp_check(const u_char *, int);
418 /* Descriptor structure for each outgoing protocol we support */
420 char *name; /* name of protocol */
421 const char *key; /* An ascii key for the bytes of the header */
422 u_char num; /* IP protocol number */
423 u_short hdrlen; /* max size of protocol header */
424 u_short port; /* default base protocol-specific "port" */
425 void (*prepare)(struct outdata *);
426 /* finish preparing an outgoing packet */
427 int (*check)(const u_char *, int);
428 /* check an incoming packet */
431 /* List of supported protocols. The first one is the default. The last
432 one is the handler for generic protocols not explicitly listed. */
433 struct outproto protos[] = {
438 sizeof(struct udphdr),
447 sizeof(struct udphdr),
454 "spt dpt seq ack xxflwin sum urp",
456 sizeof(struct tcphdr),
463 "spt dpt vtag crc tyfllen tyfllen ",
465 sizeof(struct sctphdr),
474 sizeof(struct grehdr),
498 struct outproto *proto = &protos[0];
500 const char *ip_hdr_key = "vhtslen id off tlprsum srcip dstip opts";
503 main(int argc, char **argv)
505 register int op, code, n;
507 register const char *err;
508 register u_int32_t *ap;
509 register struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
510 register struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
511 register struct hostinfo *hi;
513 register struct protoent *pe;
514 register int ttl, probe, i;
515 register int seq = 0;
516 int tos = 0, settos = 0;
517 register int lsrr = 0;
518 register u_short off = 0;
519 struct ifaddrlist *al;
521 int requestPort = -1;
524 #ifdef HAVE_LIBCASPER
525 const char *types[] = { "NAME", "ADDR" };
527 cap_channel_t *casper;
532 /* Insure the socket fds won't be 0, 1 or 2 */
533 if (open(devnull, O_RDONLY) < 0 ||
534 open(devnull, O_RDONLY) < 0 ||
535 open(devnull, O_RDONLY) < 0) {
536 Fprintf(stderr, "%s: open \"%s\": %s\n",
537 prog, devnull, strerror(errno));
541 * Do the setuid-required stuff first, then lose priveleges ASAP.
542 * Do error checking for these two calls where they appeared in
546 pe = getprotobyname(cp);
548 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0)
550 else if ((sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
554 if (setuid(getuid()) != 0) {
559 #ifdef HAVE_LIBCASPER
562 errx(1, "unable to create casper process");
563 capdns = cap_service_open(casper, "system.dns");
565 errx(1, "unable to open system.dns service");
566 if (cap_dns_type_limit(capdns, types, 2) < 0)
567 errx(1, "unable to limit access to system.dns service");
568 families[0] = AF_INET;
569 if (cap_dns_family_limit(capdns, families, 1) < 0)
570 errx(1, "unable to limit access to system.dns service");
571 #endif /* HAVE_LIBCASPER */
575 int mib[4] = { CTL_NET, PF_INET, IPPROTO_IP, IPCTL_DEFTTL };
576 size_t sz = sizeof(max_ttl);
578 if (sysctl(mib, 4, &max_ttl, &sz, NULL, 0) == -1) {
579 perror("sysctl(net.inet.ip.ttl)");
583 #else /* !IPCTL_DEFTTL */
587 #ifdef HAVE_LIBCASPER
593 else if ((cp = strrchr(argv[0], '/')) != NULL)
599 while ((op = getopt(argc, argv, "aA:edDFInrSvxf:g:i:M:m:P:p:q:s:t:w:z:")) != EOF)
623 case 'M': /* FreeBSD compat. */
624 first_ttl = str2val(optarg, "first ttl", 1, 255);
632 if (lsrr >= NGATEWAYS) {
634 "%s: No more than %d gateways\n",
638 getaddr(gwlist + lsrr, optarg);
647 proto = setproto("icmp");
651 max_ttl = str2val(optarg, "max ttl", 1, 255);
659 proto = setproto(optarg);
663 requestPort = (u_short)str2val(optarg, "port",
668 nprobes = str2val(optarg, "nprobes", 1, -1);
672 options |= SO_DONTROUTE;
677 * set the ip source address of the outbound
678 * probe (e.g., on a multi-homed host).
688 tos = str2val(optarg, "tos", 0, 255);
697 doipcksum = (doipcksum == 0);
701 waittime = str2val(optarg, "wait time",
706 pausemsecs = str2val(optarg, "pause msecs",
714 /* Set requested port, if any, else default for this protocol */
715 port = (requestPort != -1) ? requestPort : proto->port;
718 nprobes = printdiff ? 1 : 3;
720 if (first_ttl > max_ttl) {
722 "%s: first ttl (%d) may not be greater than max ttl (%d)\n",
723 prog, first_ttl, max_ttl);
728 Fprintf(stderr, "%s: Warning: ip checksums disabled\n", prog);
731 optlen = (lsrr + 1) * sizeof(gwlist[0]);
732 minpacket = sizeof(*outip) + proto->hdrlen + optlen;
738 /* Process destination and optional packet size */
739 switch (argc - optind) {
742 packlen = str2val(argv[optind + 1],
743 "packet length", minpacket, maxpacket);
747 hostname = argv[optind];
748 hi = gethostinfo(hostname);
749 setsin(to, hi->addrs[0]);
752 "%s: Warning: %s has multiple addresses; using %s\n",
753 prog, hostname, inet_ntoa(to->sin_addr));
763 #ifdef HAVE_SETLINEBUF
766 setvbuf(stdout, NULL, _IOLBF, 0);
769 protlen = packlen - sizeof(*outip) - optlen;
770 if ((proto->num == IPPROTO_SCTP) && (packlen & 3)) {
771 Fprintf(stderr, "%s: packet length must be a multiple of 4\n",
776 outip = (struct ip *)malloc((unsigned)packlen);
778 Fprintf(stderr, "%s: malloc: %s\n", prog, strerror(errno));
781 memset((char *)outip, 0, packlen);
783 outip->ip_v = IPVERSION;
786 #ifdef BYTESWAP_IP_HDR
787 outip->ip_len = htons(packlen);
788 outip->ip_off = htons(off);
790 outip->ip_len = packlen;
793 outip->ip_p = proto->num;
794 outp = (u_char *)(outip + 1);
795 #ifdef HAVE_RAW_OPTIONS
797 register u_char *optlist;
803 gwlist[lsrr] = to->sin_addr.s_addr;
805 outip->ip_dst.s_addr = gwlist[0];
807 /* force 4 byte alignment */
808 optlist[0] = IPOPT_NOP;
809 /* loose source route option */
810 optlist[1] = IPOPT_LSRR;
811 i = lsrr * sizeof(gwlist[0]);
813 /* Pointer to LSRR addresses */
814 optlist[3] = IPOPT_MINOFF;
815 memcpy(optlist + 4, gwlist + 1, i);
818 outip->ip_dst = to->sin_addr;
820 outip->ip_hl = (outp - (u_char *)outip) >> 2;
821 ident = (getpid() & 0xffff) | 0x8000;
824 Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp);
829 Fprintf(stderr, "%s: icmp socket: %s\n", prog, strerror(errno));
832 if (options & SO_DEBUG)
833 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
835 if (options & SO_DONTROUTE)
836 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
839 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
840 if (setpolicy(s, "in bypass") < 0)
841 errx(1, "%s", ipsec_strerror());
843 if (setpolicy(s, "out bypass") < 0)
844 errx(1, "%s", ipsec_strerror());
845 #endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
849 Fprintf(stderr, "%s: raw socket: %s\n", prog, strerror(errno));
853 #if defined(IP_OPTIONS) && !defined(HAVE_RAW_OPTIONS)
855 u_char optlist[MAX_IPOPTLEN];
858 if ((pe = getprotobyname(cp)) == NULL) {
859 Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp);
864 gwlist[lsrr] = to->sin_addr.s_addr;
867 /* force 4 byte alignment */
868 optlist[0] = IPOPT_NOP;
869 /* loose source route option */
870 optlist[1] = IPOPT_LSRR;
871 i = lsrr * sizeof(gwlist[0]);
873 /* Pointer to LSRR addresses */
874 optlist[3] = IPOPT_MINOFF;
875 memcpy(optlist + 4, gwlist, i);
877 if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS,
878 (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
879 Fprintf(stderr, "%s: IP_OPTIONS: %s\n",
880 prog, strerror(errno));
887 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
888 sizeof(packlen)) < 0) {
889 Fprintf(stderr, "%s: SO_SNDBUF: %s\n", prog, strerror(errno));
894 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
896 Fprintf(stderr, "%s: IP_HDRINCL: %s\n", prog, strerror(errno));
901 if (settos && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
902 (char *)&tos, sizeof(tos)) < 0) {
903 Fprintf(stderr, "%s: setsockopt tos %d: %s\n",
904 prog, tos, strerror(errno));
909 if (options & SO_DEBUG)
910 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
912 if (options & SO_DONTROUTE)
913 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
916 /* Get the interface address list */
917 n = ifaddrlist(&al, errbuf);
919 Fprintf(stderr, "%s: ifaddrlist: %s\n", prog, errbuf);
924 "%s: Can't find any network interfaces\n", prog);
928 /* Look for a specific device */
929 if (device != NULL) {
930 for (i = n; i > 0; --i, ++al)
931 if (strcmp(device, al->device) == 0)
934 Fprintf(stderr, "%s: Can't find interface %.32s\n",
940 /* Determine our source address */
941 if (source == NULL) {
943 * If a device was specified, use the interface address.
944 * Otherwise, try to determine our source address.
947 setsin(from, al->addr);
948 else if ((err = findsaddr(to, from)) != NULL) {
949 Fprintf(stderr, "%s: findsaddr: %s\n",
954 hi = gethostinfo(source);
958 * If the device was specified make sure it
959 * corresponds to the source address specified.
960 * Otherwise, use the first address (and warn if
961 * there are more than one).
963 if (device != NULL) {
964 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
969 "%s: %s is not on interface %.32s\n",
970 prog, source, device);
975 setsin(from, hi->addrs[0]);
978 "%s: Warning: %s has multiple addresses; using %s\n",
979 prog, source, inet_ntoa(from->sin_addr));
984 outip->ip_src = from->sin_addr;
986 /* Check the source address (-s), if any, is valid */
987 if (bind(sndsock, (struct sockaddr *)from, sizeof(*from)) < 0) {
988 Fprintf(stderr, "%s: bind: %s\n",
989 prog, strerror(errno));
994 asn = as_setup(as_server);
996 Fprintf(stderr, "%s: as_setup failed, AS# lookups"
997 " disabled\n", prog);
998 (void)fflush(stderr);
1003 if (connect(sndsock, (struct sockaddr *)&whereto,
1004 sizeof(whereto)) != 0) {
1005 Fprintf(stderr, "%s: connect: %s\n", prog, strerror(errno));
1009 #ifdef HAVE_LIBCASPER
1019 * Here we enter capability mode. Further down access to global
1020 * namespaces (e.g filesystem) is restricted (see capsicum(4)).
1021 * We must connect(2) our socket before this point.
1023 if (cansandbox && cap_enter() < 0) {
1024 if (errno != ENOSYS) {
1025 Fprintf(stderr, "%s: cap_enter: %s\n", prog,
1033 cap_rights_init(&rights, CAP_SEND, CAP_SETSOCKOPT);
1034 if (cansandbox && cap_rights_limit(sndsock, &rights) < 0) {
1035 Fprintf(stderr, "%s: cap_rights_limit sndsock: %s\n", prog,
1040 cap_rights_init(&rights, CAP_RECV, CAP_EVENT);
1041 if (cansandbox && cap_rights_limit(s, &rights) < 0) {
1042 Fprintf(stderr, "%s: cap_rights_limit s: %s\n", prog,
1047 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1048 if (setpolicy(sndsock, "in bypass") < 0)
1049 errx(1, "%s", ipsec_strerror());
1051 if (setpolicy(sndsock, "out bypass") < 0)
1052 errx(1, "%s", ipsec_strerror());
1053 #endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
1055 Fprintf(stderr, "%s to %s (%s)",
1056 prog, hostname, inet_ntoa(to->sin_addr));
1058 Fprintf(stderr, " from %s", source);
1059 Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1060 (void)fflush(stderr);
1062 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1063 u_int32_t lastaddr = 0;
1064 int gotlastaddr = 0;
1066 int unreachable = 0;
1070 Printf("%2d ", ttl);
1071 for (probe = 0, loss = 0; probe < nprobes; ++probe) {
1073 struct timeval t1, t2;
1074 register struct ip *ip;
1075 struct outdata outdata;
1077 if (sentfirst && pausemsecs > 0)
1078 usleep(pausemsecs * 1000);
1079 /* Prepare outgoing data */
1080 outdata.seq = ++seq;
1083 /* Avoid alignment problems by copying bytewise: */
1084 (void)gettimeofday(&t1, NULL);
1085 memcpy(&outdata.tv, &t1, sizeof(outdata.tv));
1087 /* Finalize and send packet */
1088 (*proto->prepare)(&outdata);
1089 send_probe(seq, ttl);
1092 /* Wait for a reply */
1093 while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1097 (void)gettimeofday(&t2, NULL);
1098 i = packet_ok(packet, cc, from, seq);
1099 /* Skip short packet */
1103 from->sin_addr.s_addr != lastaddr) {
1104 if (gotlastaddr) printf("\n ");
1105 print(packet, cc, from);
1106 lastaddr = from->sin_addr.s_addr;
1109 T = deltaT(&t1, &t2);
1110 #ifdef SANE_PRECISION
1113 else if (T >= 100.0)
1120 Printf(" %.*f ms", precis, T);
1124 -(outip->ip_hl << 3),
1128 pkt_compare((void *)outip, packlen,
1129 (void *)hip, hiplen);
1133 ip = (struct ip *)packet;
1134 if (ip->ip_ttl <= 1)
1140 /* time exceeded in transit */
1146 case ICMP_UNREACH_PORT:
1148 ip = (struct ip *)packet;
1149 if (ip->ip_ttl <= 1)
1155 case ICMP_UNREACH_NET:
1160 case ICMP_UNREACH_HOST:
1165 case ICMP_UNREACH_PROTOCOL:
1170 case ICMP_UNREACH_NEEDFRAG:
1172 Printf(" !F-%d", pmtu);
1175 case ICMP_UNREACH_SRCFAIL:
1180 case ICMP_UNREACH_NET_UNKNOWN:
1185 case ICMP_UNREACH_HOST_UNKNOWN:
1190 case ICMP_UNREACH_ISOLATED:
1195 case ICMP_UNREACH_NET_PROHIB:
1200 case ICMP_UNREACH_HOST_PROHIB:
1205 case ICMP_UNREACH_TOSNET:
1210 case ICMP_UNREACH_TOSHOST:
1215 case ICMP_UNREACH_FILTER_PROHIB:
1220 case ICMP_UNREACH_HOST_PRECEDENCE:
1225 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1232 Printf(" !<%d>", code);
1241 (void)fflush(stdout);
1244 Printf(" (%d%% loss)", (loss * 100) / nprobes);
1248 (unreachable > 0 && unreachable >= nprobes - 1))
1257 wait_for_reply(register int sock, register struct sockaddr_in *fromp,
1258 register const struct timeval *tp)
1262 struct timeval now, wait;
1263 register int cc = 0;
1265 int fromlen = sizeof(*fromp);
1267 nfds = howmany(sock + 1, NFDBITS);
1268 if ((fdsp = malloc(nfds * sizeof(fd_mask))) == NULL)
1270 memset(fdsp, 0, nfds * sizeof(fd_mask));
1273 wait.tv_sec = tp->tv_sec + waittime;
1274 wait.tv_usec = tp->tv_usec;
1275 (void)gettimeofday(&now, NULL);
1277 if (wait.tv_sec < 0) {
1282 error = select(sock + 1, fdsp, NULL, NULL, &wait);
1283 if (error == -1 && errno == EINVAL) {
1284 Fprintf(stderr, "%s: botched select() args\n", prog);
1288 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
1289 (struct sockaddr *)fromp, &fromlen);
1296 send_probe(int seq, int ttl)
1300 outip->ip_ttl = ttl;
1301 outip->ip_id = htons(ident + seq);
1303 /* XXX undocumented debugging hack */
1305 register const u_short *sp;
1306 register int nshorts, i;
1308 sp = (u_short *)outip;
1309 nshorts = (u_int)packlen / sizeof(u_short);
1311 Printf("[ %d bytes", packlen);
1312 while (--nshorts >= 0) {
1315 Printf(" %04x", ntohs(*sp++));
1320 Printf(" %02x", *(u_char *)sp);
1325 #if !defined(IP_HDRINCL) && defined(IP_TTL)
1326 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
1327 (char *)&ttl, sizeof(ttl)) < 0) {
1328 Fprintf(stderr, "%s: setsockopt ttl %d: %s\n",
1329 prog, ttl, strerror(errno));
1334 cc = send(sndsock, (char *)outip, packlen, 0);
1335 if (cc < 0 || cc != packlen) {
1337 Fprintf(stderr, "%s: sendto: %s\n",
1338 prog, strerror(errno));
1339 Printf("%s: wrote %s %d chars, ret=%d\n",
1340 prog, hostname, packlen, cc);
1341 (void)fflush(stdout);
1345 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1347 setpolicy(so, policy)
1353 buf = ipsec_set_policy(policy, strlen(policy));
1355 warnx("%s", ipsec_strerror());
1358 (void)setsockopt(so, IPPROTO_IP, IP_IPSEC_POLICY,
1359 buf, ipsec_get_policylen(buf));
1368 deltaT(struct timeval *t1p, struct timeval *t2p)
1372 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
1373 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
1378 * Convert an ICMP "type" field to a printable string.
1381 pr_type(register u_char t)
1383 static char *ttab[] = {
1384 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable",
1385 "Source Quench", "Redirect", "ICMP 6", "ICMP 7",
1386 "Echo", "ICMP 9", "ICMP 10", "Time Exceeded",
1387 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request",
1392 return("OUT-OF-RANGE");
1398 packet_ok(register u_char *buf, int cc, register struct sockaddr_in *from,
1401 register struct icmp *icp;
1402 register u_char type, code;
1405 register struct ip *ip;
1407 ip = (struct ip *) buf;
1408 hlen = ip->ip_hl << 2;
1409 if (cc < hlen + ICMP_MINLEN) {
1411 Printf("packet too short (%d bytes) from %s\n", cc,
1412 inet_ntoa(from->sin_addr));
1416 icp = (struct icmp *)(buf + hlen);
1418 icp = (struct icmp *)buf;
1420 type = icp->icmp_type;
1421 code = icp->icmp_code;
1422 /* Path MTU Discovery (RFC1191) */
1423 if (code != ICMP_UNREACH_NEEDFRAG)
1426 #ifdef HAVE_ICMP_NEXTMTU
1427 pmtu = ntohs(icp->icmp_nextmtu);
1429 pmtu = ntohs(((struct my_pmtu *)&icp->icmp_void)->ipm_nextmtu);
1432 if (type == ICMP_ECHOREPLY
1433 && proto->num == IPPROTO_ICMP
1434 && (*proto->check)((u_char *)icp, (u_char)seq))
1436 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
1437 type == ICMP_UNREACH) {
1440 hip = &icp->icmp_ip;
1441 hiplen = ((u_char *)icp + cc) - (u_char *)hip;
1442 hlen = hip->ip_hl << 2;
1443 inner = (u_char *)((u_char *)hip + hlen);
1445 && hip->ip_p == proto->num
1446 && (*proto->check)(inner, (u_char)seq))
1447 return (type == ICMP_TIMXCEED ? -1 : code + 1);
1452 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
1454 Printf("\n%d bytes from %s to ", cc, inet_ntoa(from->sin_addr));
1455 Printf("%s: icmp type %d (%s) code %d\n",
1456 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
1457 for (i = 4; i <= cc - ICMP_MINLEN; i += sizeof(*lp))
1458 Printf("%2d: %8.8x\n", i, ntohl(*lp++));
1465 icmp_prep(struct outdata *outdata)
1467 struct icmp *const icmpheader = (struct icmp *) outp;
1469 icmpheader->icmp_type = ICMP_ECHO;
1470 icmpheader->icmp_id = htons(ident);
1471 icmpheader->icmp_seq = htons(outdata->seq);
1472 icmpheader->icmp_cksum = 0;
1473 icmpheader->icmp_cksum = in_cksum((u_short *)icmpheader, protlen);
1474 if (icmpheader->icmp_cksum == 0)
1475 icmpheader->icmp_cksum = 0xffff;
1479 icmp_check(const u_char *data, int seq)
1481 struct icmp *const icmpheader = (struct icmp *) data;
1483 return (icmpheader->icmp_id == htons(ident)
1484 && icmpheader->icmp_seq == htons(seq));
1488 udp_prep(struct outdata *outdata)
1490 struct udphdr *const outudp = (struct udphdr *) outp;
1492 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0));
1493 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1494 outudp->uh_ulen = htons((u_short)protlen);
1497 u_short sum = p_cksum(outip, (u_short*)outudp, protlen, protlen);
1498 outudp->uh_sum = (sum) ? sum : 0xffff;
1505 udp_check(const u_char *data, int seq)
1507 struct udphdr *const udp = (struct udphdr *) data;
1509 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) &&
1510 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq));
1514 udplite_prep(struct outdata *outdata)
1516 struct udphdr *const outudp = (struct udphdr *) outp;
1518 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0));
1519 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1520 outudp->uh_ulen = htons(8);
1523 u_short sum = p_cksum(outip, (u_short*)outudp, protlen, 8);
1524 outudp->uh_sum = (sum) ? sum : 0xffff;
1531 udplite_check(const u_char *data, int seq)
1533 struct udphdr *const udp = (struct udphdr *) data;
1535 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) &&
1536 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq));
1540 tcp_prep(struct outdata *outdata)
1542 struct tcphdr *const tcp = (struct tcphdr *) outp;
1544 tcp->th_sport = htons(ident);
1545 tcp->th_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1546 tcp->th_seq = (tcp->th_sport << 16) | tcp->th_dport;
1549 tcp->th_flags = TH_SYN;
1553 tcp->th_sum = p_cksum(outip, (u_short*)tcp, protlen, protlen);
1557 tcp_check(const u_char *data, int seq)
1559 struct tcphdr *const tcp = (struct tcphdr *) data;
1561 return (ntohs(tcp->th_sport) == ident
1562 && ntohs(tcp->th_dport) == port + (fixedPort ? 0 : seq)
1563 && tcp->th_seq == (tcp_seq)((tcp->th_sport << 16) | tcp->th_dport));
1567 sctp_prep(struct outdata *outdata)
1569 struct sctphdr *const sctp = (struct sctphdr *) outp;
1570 struct sctp_chunkhdr *chk;
1571 struct sctp_init_chunk *init;
1572 struct sctp_paramhdr *param;
1574 sctp->src_port = htons(ident);
1575 sctp->dest_port = htons(port + (fixedPort ? 0 : outdata->seq));
1576 if (protlen >= (int)(sizeof(struct sctphdr) +
1577 sizeof(struct sctp_init_chunk))) {
1580 sctp->v_tag = (sctp->src_port << 16) | sctp->dest_port;
1582 sctp->checksum = htonl(0);
1583 if (protlen >= (int)(sizeof(struct sctphdr) +
1584 sizeof(struct sctp_init_chunk))) {
1586 * Send a packet containing an INIT chunk. This works
1587 * better in case of firewalls on the path, but
1588 * results in a probe packet containing at least
1589 * 32 bytes of payload. For shorter payloads, use
1590 * SHUTDOWN-ACK chunks.
1592 init = (struct sctp_init_chunk *)(sctp + 1);
1593 init->ch.chunk_type = SCTP_INITIATION;
1594 init->ch.chunk_flags = 0;
1595 init->ch.chunk_length = htons((u_int16_t)(protlen -
1596 sizeof(struct sctphdr)));
1597 init->init.initiate_tag = (sctp->src_port << 16) |
1599 init->init.a_rwnd = htonl(1500);
1600 init->init.num_outbound_streams = htons(1);
1601 init->init.num_inbound_streams = htons(1);
1602 init->init.initial_tsn = htonl(0);
1603 if (protlen >= (int)(sizeof(struct sctphdr) +
1604 sizeof(struct sctp_init_chunk) +
1605 sizeof(struct sctp_paramhdr))) {
1606 param = (struct sctp_paramhdr *)(init + 1);
1607 param->param_type = htons(SCTP_PAD);
1608 param->param_length =
1609 htons((u_int16_t)(protlen -
1610 sizeof(struct sctphdr) -
1611 sizeof(struct sctp_init_chunk)));
1615 * Send a packet containing a SHUTDOWN-ACK chunk,
1616 * possibly followed by a PAD chunk.
1619 (int)(sizeof(struct sctphdr) +
1620 sizeof(struct sctp_chunkhdr))) {
1621 chk = (struct sctp_chunkhdr *)(sctp + 1);
1622 chk->chunk_type = SCTP_SHUTDOWN_ACK;
1623 chk->chunk_flags = 0;
1624 chk->chunk_length = htons(4);
1627 (int)(sizeof(struct sctphdr) +
1628 2 * sizeof(struct sctp_chunkhdr))) {
1630 chk->chunk_type = SCTP_PAD_CHUNK;
1631 chk->chunk_flags = 0;
1632 chk->chunk_length = htons(protlen -
1633 (sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr)));
1637 sctp->checksum = sctp_crc32c(sctp, protlen);
1642 sctp_check(const u_char *data, int seq)
1644 struct sctphdr *const sctp = (struct sctphdr *) data;
1646 if (ntohs(sctp->src_port) != ident ||
1647 ntohs(sctp->dest_port) != port + (fixedPort ? 0 : seq))
1649 if (protlen < (int)(sizeof(struct sctphdr) +
1650 sizeof(struct sctp_init_chunk))) {
1651 return (sctp->v_tag ==
1652 (u_int32_t)((sctp->src_port << 16) | sctp->dest_port));
1655 * Don't verify the initiate_tag, since it is not available,
1658 return (sctp->v_tag == 0);
1663 gre_prep(struct outdata *outdata)
1665 struct grehdr *const gre = (struct grehdr *) outp;
1667 gre->flags = htons(0x2001);
1668 gre->proto = htons(port);
1670 gre->callId = htons(ident + outdata->seq);
1674 gre_check(const u_char *data, int seq)
1676 struct grehdr *const gre = (struct grehdr *) data;
1678 return(ntohs(gre->proto) == port
1679 && ntohs(gre->callId) == ident + seq);
1683 gen_prep(struct outdata *outdata)
1685 u_int16_t *const ptr = (u_int16_t *) outp;
1687 ptr[0] = htons(ident);
1688 ptr[1] = htons(port + outdata->seq);
1692 gen_check(const u_char *data, int seq)
1694 u_int16_t *const ptr = (u_int16_t *) data;
1696 return(ntohs(ptr[0]) == ident
1697 && ntohs(ptr[1]) == port + seq);
1701 print(register u_char *buf, register int cc, register struct sockaddr_in *from)
1703 register struct ip *ip;
1705 char addr[INET_ADDRSTRLEN];
1707 ip = (struct ip *) buf;
1708 hlen = ip->ip_hl << 2;
1711 strlcpy(addr, inet_ntoa(from->sin_addr), sizeof(addr));
1714 Printf(" [AS%u]", as_lookup(asn, addr, AF_INET));
1717 Printf(" %s", addr);
1719 Printf(" %s (%s)", inetname(from->sin_addr), addr);
1722 Printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
1726 * Checksum routine for UDP and TCP headers.
1729 p_cksum(struct ip *ip, u_short *data, int len, int cov)
1731 static struct ipovly ipo;
1734 ipo.ih_pr = ip->ip_p;
1735 ipo.ih_len = htons(len);
1736 ipo.ih_src = ip->ip_src;
1737 ipo.ih_dst = ip->ip_dst;
1739 sum[1] = in_cksum((u_short*)&ipo, sizeof(ipo)); /* pseudo ip hdr cksum */
1740 sum[0] = in_cksum(data, cov); /* payload data cksum */
1742 return ~in_cksum(sum, sizeof(sum));
1746 * Checksum routine for Internet Protocol family headers (C Version)
1749 in_cksum(register u_short *addr, register int len)
1751 register int nleft = len;
1752 register u_short *w = addr;
1753 register u_short answer;
1754 register int sum = 0;
1757 * Our algorithm is simple, using a 32 bit accumulator (sum),
1758 * we add sequential 16 bit words to it, and at the end, fold
1759 * back all the carry bits from the top 16 bits into the lower
1767 /* mop up an odd byte, if necessary */
1769 sum += *(u_char *)w;
1772 * add back carry outs from top 16 bits to low 16 bits
1774 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
1775 sum += (sum >> 16); /* add carry */
1776 answer = ~sum; /* truncate to 16 bits */
1781 * CRC32C routine for the Stream Control Transmission Protocol
1784 #define CRC32C(c, d) (c = (c>>8) ^ crc_c[(c^(d))&0xFF])
1786 static u_int32_t crc_c[256] = {
1787 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
1788 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
1789 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
1790 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
1791 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
1792 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
1793 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
1794 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
1795 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
1796 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
1797 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
1798 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
1799 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
1800 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
1801 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
1802 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
1803 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
1804 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
1805 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
1806 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
1807 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
1808 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
1809 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
1810 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
1811 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
1812 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
1813 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
1814 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
1815 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
1816 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
1817 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
1818 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
1819 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
1820 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
1821 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
1822 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
1823 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
1824 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
1825 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
1826 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
1827 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
1828 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
1829 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
1830 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
1831 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
1832 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
1833 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
1834 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
1835 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
1836 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
1837 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
1838 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
1839 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
1840 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
1841 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
1842 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
1843 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
1844 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
1845 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
1846 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
1847 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
1848 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
1849 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
1850 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351
1854 sctp_crc32c(const void *packet, u_int32_t len)
1856 u_int32_t i, crc32c;
1857 u_int8_t byte0, byte1, byte2, byte3;
1858 const u_int8_t *buf = (const u_int8_t *)packet;
1861 for (i = 0; i < len; i++)
1862 CRC32C(crc32c, buf[i]);
1864 byte0 = crc32c & 0xff;
1865 byte1 = (crc32c>>8) & 0xff;
1866 byte2 = (crc32c>>16) & 0xff;
1867 byte3 = (crc32c>>24) & 0xff;
1868 crc32c = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
1869 return htonl(crc32c);
1873 * Subtract 2 timeval structs: out = out - in.
1874 * Out is assumed to be within about LONG_MAX seconds of in.
1877 tvsub(register struct timeval *out, register struct timeval *in)
1880 if ((out->tv_usec -= in->tv_usec) < 0) {
1882 out->tv_usec += 1000000;
1884 out->tv_sec -= in->tv_sec;
1888 * Construct an Internet address representation.
1889 * If the nflag has been supplied, give
1890 * numeric value, otherwise try for symbolic name.
1893 inetname(struct in_addr in)
1896 register struct hostent *hp;
1897 static int first = 1;
1898 static char domain[MAXHOSTNAMELEN + 1], line[MAXHOSTNAMELEN + 1];
1900 if (first && !nflag) {
1902 if (gethostname(domain, sizeof(domain) - 1) < 0)
1905 cp = strchr(domain, '.');
1907 #ifdef HAVE_LIBCASPER
1909 hp = cap_gethostbyname(capdns, domain);
1912 hp = gethostbyname(domain);
1914 cp = strchr(hp->h_name, '.');
1920 (void)strncpy(domain, cp, sizeof(domain) - 1);
1921 domain[sizeof(domain) - 1] = '\0';
1925 if (!nflag && in.s_addr != INADDR_ANY) {
1926 #ifdef HAVE_LIBCASPER
1928 hp = cap_gethostbyaddr(capdns, (char *)&in, sizeof(in),
1932 hp = gethostbyaddr((char *)&in, sizeof(in), AF_INET);
1934 if ((cp = strchr(hp->h_name, '.')) != NULL &&
1935 strcmp(cp + 1, domain) == 0)
1937 (void)strncpy(line, hp->h_name, sizeof(line) - 1);
1938 line[sizeof(line) - 1] = '\0';
1942 return (inet_ntoa(in));
1946 gethostinfo(register char *hostname)
1949 register struct hostent *hp;
1950 register struct hostinfo *hi;
1952 register u_int32_t addr, *ap;
1954 if (strlen(hostname) >= MAXHOSTNAMELEN) {
1955 Fprintf(stderr, "%s: hostname \"%.32s...\" is too long\n",
1959 hi = calloc(1, sizeof(*hi));
1961 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno));
1964 addr = inet_addr(hostname);
1965 if ((int32_t)addr != -1) {
1966 hi->name = strdup(hostname);
1968 hi->addrs = calloc(1, sizeof(hi->addrs[0]));
1969 if (hi->addrs == NULL) {
1970 Fprintf(stderr, "%s: calloc %s\n",
1971 prog, strerror(errno));
1974 hi->addrs[0] = addr;
1978 #ifdef HAVE_LIBCASPER
1980 hp = cap_gethostbyname(capdns, hostname);
1983 hp = gethostbyname(hostname);
1985 Fprintf(stderr, "%s: unknown host %s\n", prog, hostname);
1988 if (hp->h_addrtype != AF_INET || hp->h_length != 4) {
1989 Fprintf(stderr, "%s: bad host %s\n", prog, hostname);
1992 hi->name = strdup(hp->h_name);
1993 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
1996 hi->addrs = calloc(n, sizeof(hi->addrs[0]));
1997 if (hi->addrs == NULL) {
1998 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno));
2001 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
2002 memcpy(ap, *p, sizeof(*ap));
2007 freehostinfo(register struct hostinfo *hi)
2009 if (hi->name != NULL) {
2013 free((char *)hi->addrs);
2018 getaddr(register u_int32_t *ap, register char *hostname)
2020 register struct hostinfo *hi;
2022 hi = gethostinfo(hostname);
2028 setsin(register struct sockaddr_in *sin, register u_int32_t addr)
2031 memset(sin, 0, sizeof(*sin));
2032 #ifdef HAVE_SOCKADDR_SA_LEN
2033 sin->sin_len = sizeof(*sin);
2035 sin->sin_family = AF_INET;
2036 sin->sin_addr.s_addr = addr;
2039 /* String to value with optional min and max. Handles decimal and hex. */
2041 str2val(register const char *str, register const char *what,
2042 register int mi, register int ma)
2044 register const char *cp;
2048 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
2050 val = (int)strtol(cp, &ep, 16);
2052 val = (int)strtol(str, &ep, 10);
2054 Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
2058 if (val < mi && mi >= 0) {
2060 Fprintf(stderr, "%s: %s must be >= %d\n",
2063 Fprintf(stderr, "%s: %s must be > %d\n",
2064 prog, what, mi - 1);
2067 if (val > ma && ma >= 0) {
2068 Fprintf(stderr, "%s: %s must be <= %d\n", prog, what, ma);
2075 setproto(char *pname)
2077 struct outproto *proto;
2080 for (i = 0; protos[i].name != NULL; i++) {
2081 if (strcasecmp(protos[i].name, pname) == 0) {
2086 if (proto->name == NULL) { /* generic handler */
2087 struct protoent *pe;
2090 /* Determine the IP protocol number */
2091 if ((pe = getprotobyname(pname)) != NULL)
2094 pnum = str2val(optarg, "proto number", 1, 255);
2101 pkt_compare(const u_char *a, int la, const u_char *b, int lb) {
2105 for (i = 0; i < la; i++)
2106 Printf("%02x", (unsigned int)a[i]);
2108 l = (la <= lb) ? la : lb;
2109 for (i = 0; i < l; i++)
2113 Printf("%02x", (unsigned int)b[i]);
2115 Printf("%02x", (unsigned int)b[i]);
2123 extern char version[];
2125 Fprintf(stderr, "Version %s\n", version);
2127 "Usage: %s [-adDeFInrSvx] [-f first_ttl] [-g gateway] [-i iface]\n"
2128 "\t[-m max_ttl] [-p port] [-P proto] [-q nqueries] [-s src_addr]\n"
2129 "\t[-t tos] [-w waittime] [-A as_server] [-z pausemsecs] host [packetlen]\n", prog);