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/udp.h>
225 #include <netinet/tcp.h>
226 #include <netinet/tcpip.h>
228 #include <arpa/inet.h>
231 #include <libcasper.h>
232 #include <casper/cap_dns.h>
236 #include <net/route.h>
237 #include <netipsec/ipsec.h> /* XXX */
241 #include <capsicum_helpers.h>
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 */
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;
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) {
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 /* WITH_CASPER */
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 */
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));
1018 caph_cache_catpages();
1021 * Here we enter capability mode. Further down access to global
1022 * namespaces (e.g filesystem) is restricted (see capsicum(4)).
1023 * We must connect(2) our socket before this point.
1025 if (cansandbox && cap_enter() < 0) {
1026 if (errno != ENOSYS) {
1027 Fprintf(stderr, "%s: cap_enter: %s\n", prog,
1035 cap_rights_init(&rights, CAP_SEND, CAP_SETSOCKOPT);
1036 if (cansandbox && cap_rights_limit(sndsock, &rights) < 0) {
1037 Fprintf(stderr, "%s: cap_rights_limit sndsock: %s\n", prog,
1042 cap_rights_init(&rights, CAP_RECV, CAP_EVENT);
1043 if (cansandbox && cap_rights_limit(s, &rights) < 0) {
1044 Fprintf(stderr, "%s: cap_rights_limit s: %s\n", prog,
1049 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1050 if (setpolicy(sndsock, "in bypass") < 0)
1051 errx(1, "%s", ipsec_strerror());
1053 if (setpolicy(sndsock, "out bypass") < 0)
1054 errx(1, "%s", ipsec_strerror());
1055 #endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
1057 Fprintf(stderr, "%s to %s (%s)",
1058 prog, hostname, inet_ntoa(to->sin_addr));
1060 Fprintf(stderr, " from %s", source);
1061 Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1062 (void)fflush(stderr);
1064 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1065 u_int32_t lastaddr = 0;
1066 int gotlastaddr = 0;
1068 int unreachable = 0;
1072 Printf("%2d ", ttl);
1073 for (probe = 0, loss = 0; probe < nprobes; ++probe) {
1075 struct timeval t1, t2;
1076 register struct ip *ip;
1077 struct outdata outdata;
1079 if (sentfirst && pausemsecs > 0)
1080 usleep(pausemsecs * 1000);
1081 /* Prepare outgoing data */
1082 outdata.seq = ++seq;
1085 /* Avoid alignment problems by copying bytewise: */
1086 (void)gettimeofday(&t1, NULL);
1087 memcpy(&outdata.tv, &t1, sizeof(outdata.tv));
1089 /* Finalize and send packet */
1090 (*proto->prepare)(&outdata);
1091 send_probe(seq, ttl);
1094 /* Wait for a reply */
1095 while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1099 (void)gettimeofday(&t2, NULL);
1100 i = packet_ok(packet, cc, from, seq);
1101 /* Skip short packet */
1105 from->sin_addr.s_addr != lastaddr) {
1106 if (gotlastaddr) printf("\n ");
1107 print(packet, cc, from);
1108 lastaddr = from->sin_addr.s_addr;
1111 T = deltaT(&t1, &t2);
1112 #ifdef SANE_PRECISION
1115 else if (T >= 100.0)
1122 Printf(" %.*f ms", precis, T);
1126 -(outip->ip_hl << 3),
1130 pkt_compare((void *)outip, packlen,
1131 (void *)hip, hiplen);
1135 ip = (struct ip *)packet;
1136 if (ip->ip_ttl <= 1)
1142 /* time exceeded in transit */
1148 case ICMP_UNREACH_PORT:
1150 ip = (struct ip *)packet;
1151 if (ip->ip_ttl <= 1)
1157 case ICMP_UNREACH_NET:
1162 case ICMP_UNREACH_HOST:
1167 case ICMP_UNREACH_PROTOCOL:
1172 case ICMP_UNREACH_NEEDFRAG:
1174 Printf(" !F-%d", pmtu);
1177 case ICMP_UNREACH_SRCFAIL:
1182 case ICMP_UNREACH_NET_UNKNOWN:
1187 case ICMP_UNREACH_HOST_UNKNOWN:
1192 case ICMP_UNREACH_ISOLATED:
1197 case ICMP_UNREACH_NET_PROHIB:
1202 case ICMP_UNREACH_HOST_PROHIB:
1207 case ICMP_UNREACH_TOSNET:
1212 case ICMP_UNREACH_TOSHOST:
1217 case ICMP_UNREACH_FILTER_PROHIB:
1222 case ICMP_UNREACH_HOST_PRECEDENCE:
1227 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1234 Printf(" !<%d>", code);
1243 (void)fflush(stdout);
1246 Printf(" (%d%% loss)", (loss * 100) / nprobes);
1250 (unreachable > 0 && unreachable >= nprobes - 1))
1259 wait_for_reply(register int sock, register struct sockaddr_in *fromp,
1260 register const struct timeval *tp)
1264 struct timeval now, wait;
1265 register int cc = 0;
1267 int fromlen = sizeof(*fromp);
1269 nfds = howmany(sock + 1, NFDBITS);
1270 if ((fdsp = malloc(nfds * sizeof(fd_mask))) == NULL)
1272 memset(fdsp, 0, nfds * sizeof(fd_mask));
1275 wait.tv_sec = tp->tv_sec + waittime;
1276 wait.tv_usec = tp->tv_usec;
1277 (void)gettimeofday(&now, NULL);
1279 if (wait.tv_sec < 0) {
1284 error = select(sock + 1, fdsp, NULL, NULL, &wait);
1285 if (error == -1 && errno == EINVAL) {
1286 Fprintf(stderr, "%s: botched select() args\n", prog);
1290 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
1291 (struct sockaddr *)fromp, &fromlen);
1298 send_probe(int seq, int ttl)
1302 outip->ip_ttl = ttl;
1303 outip->ip_id = htons(ident + seq);
1305 /* XXX undocumented debugging hack */
1307 register const u_short *sp;
1308 register int nshorts, i;
1310 sp = (u_short *)outip;
1311 nshorts = (u_int)packlen / sizeof(u_short);
1313 Printf("[ %d bytes", packlen);
1314 while (--nshorts >= 0) {
1317 Printf(" %04x", ntohs(*sp++));
1322 Printf(" %02x", *(u_char *)sp);
1327 #if !defined(IP_HDRINCL) && defined(IP_TTL)
1328 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
1329 (char *)&ttl, sizeof(ttl)) < 0) {
1330 Fprintf(stderr, "%s: setsockopt ttl %d: %s\n",
1331 prog, ttl, strerror(errno));
1336 cc = send(sndsock, (char *)outip, packlen, 0);
1337 if (cc < 0 || cc != packlen) {
1339 Fprintf(stderr, "%s: sendto: %s\n",
1340 prog, strerror(errno));
1341 Printf("%s: wrote %s %d chars, ret=%d\n",
1342 prog, hostname, packlen, cc);
1343 (void)fflush(stdout);
1347 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1349 setpolicy(so, policy)
1355 buf = ipsec_set_policy(policy, strlen(policy));
1357 warnx("%s", ipsec_strerror());
1360 (void)setsockopt(so, IPPROTO_IP, IP_IPSEC_POLICY,
1361 buf, ipsec_get_policylen(buf));
1370 deltaT(struct timeval *t1p, struct timeval *t2p)
1374 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
1375 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
1380 * Convert an ICMP "type" field to a printable string.
1383 pr_type(register u_char t)
1385 static char *ttab[] = {
1386 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable",
1387 "Source Quench", "Redirect", "ICMP 6", "ICMP 7",
1388 "Echo", "ICMP 9", "ICMP 10", "Time Exceeded",
1389 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request",
1394 return("OUT-OF-RANGE");
1400 packet_ok(register u_char *buf, int cc, register struct sockaddr_in *from,
1403 register struct icmp *icp;
1404 register u_char type, code;
1407 register struct ip *ip;
1409 ip = (struct ip *) buf;
1410 hlen = ip->ip_hl << 2;
1411 if (cc < hlen + ICMP_MINLEN) {
1413 Printf("packet too short (%d bytes) from %s\n", cc,
1414 inet_ntoa(from->sin_addr));
1418 icp = (struct icmp *)(buf + hlen);
1420 icp = (struct icmp *)buf;
1422 type = icp->icmp_type;
1423 code = icp->icmp_code;
1424 /* Path MTU Discovery (RFC1191) */
1425 if (code != ICMP_UNREACH_NEEDFRAG)
1428 #ifdef HAVE_ICMP_NEXTMTU
1429 pmtu = ntohs(icp->icmp_nextmtu);
1431 pmtu = ntohs(((struct my_pmtu *)&icp->icmp_void)->ipm_nextmtu);
1434 if (type == ICMP_ECHOREPLY
1435 && proto->num == IPPROTO_ICMP
1436 && (*proto->check)((u_char *)icp, (u_char)seq))
1438 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
1439 type == ICMP_UNREACH) {
1442 hip = &icp->icmp_ip;
1443 hiplen = ((u_char *)icp + cc) - (u_char *)hip;
1444 hlen = hip->ip_hl << 2;
1445 inner = (u_char *)((u_char *)hip + hlen);
1447 && hip->ip_p == proto->num
1448 && (*proto->check)(inner, (u_char)seq))
1449 return (type == ICMP_TIMXCEED ? -1 : code + 1);
1454 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
1456 Printf("\n%d bytes from %s to ", cc, inet_ntoa(from->sin_addr));
1457 Printf("%s: icmp type %d (%s) code %d\n",
1458 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
1459 for (i = 4; i <= cc - ICMP_MINLEN; i += sizeof(*lp))
1460 Printf("%2d: %8.8x\n", i, ntohl(*lp++));
1467 icmp_prep(struct outdata *outdata)
1469 struct icmp *const icmpheader = (struct icmp *) outp;
1471 icmpheader->icmp_type = ICMP_ECHO;
1472 icmpheader->icmp_id = htons(ident);
1473 icmpheader->icmp_seq = htons(outdata->seq);
1474 icmpheader->icmp_cksum = 0;
1475 icmpheader->icmp_cksum = in_cksum((u_short *)icmpheader, protlen);
1476 if (icmpheader->icmp_cksum == 0)
1477 icmpheader->icmp_cksum = 0xffff;
1481 icmp_check(const u_char *data, int seq)
1483 struct icmp *const icmpheader = (struct icmp *) data;
1485 return (icmpheader->icmp_id == htons(ident)
1486 && icmpheader->icmp_seq == htons(seq));
1490 udp_prep(struct outdata *outdata)
1492 struct udphdr *const outudp = (struct udphdr *) outp;
1494 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0));
1495 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1496 outudp->uh_ulen = htons((u_short)protlen);
1499 u_short sum = p_cksum(outip, (u_short*)outudp, protlen, protlen);
1500 outudp->uh_sum = (sum) ? sum : 0xffff;
1507 udp_check(const u_char *data, int seq)
1509 struct udphdr *const udp = (struct udphdr *) data;
1511 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) &&
1512 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq));
1516 udplite_prep(struct outdata *outdata)
1518 struct udphdr *const outudp = (struct udphdr *) outp;
1520 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0));
1521 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1522 outudp->uh_ulen = htons(8);
1525 u_short sum = p_cksum(outip, (u_short*)outudp, protlen, 8);
1526 outudp->uh_sum = (sum) ? sum : 0xffff;
1533 udplite_check(const u_char *data, int seq)
1535 struct udphdr *const udp = (struct udphdr *) data;
1537 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) &&
1538 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq));
1542 tcp_prep(struct outdata *outdata)
1544 struct tcphdr *const tcp = (struct tcphdr *) outp;
1546 tcp->th_sport = htons(ident);
1547 tcp->th_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1548 tcp->th_seq = (tcp->th_sport << 16) | tcp->th_dport;
1551 tcp->th_flags = TH_SYN;
1555 tcp->th_sum = p_cksum(outip, (u_short*)tcp, protlen, protlen);
1559 tcp_check(const u_char *data, int seq)
1561 struct tcphdr *const tcp = (struct tcphdr *) data;
1563 return (ntohs(tcp->th_sport) == ident
1564 && ntohs(tcp->th_dport) == port + (fixedPort ? 0 : seq)
1565 && tcp->th_seq == (tcp_seq)((tcp->th_sport << 16) | tcp->th_dport));
1569 sctp_prep(struct outdata *outdata)
1571 struct sctphdr *const sctp = (struct sctphdr *) outp;
1572 struct sctp_chunkhdr *chk;
1574 sctp->src_port = htons(ident);
1575 sctp->dest_port = htons(port + (fixedPort ? 0 : outdata->seq));
1576 sctp->v_tag = (sctp->src_port << 16) | sctp->dest_port;
1577 sctp->checksum = htonl(0);
1579 (int)(sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))) {
1580 chk = (struct sctp_chunkhdr *)(sctp + 1);
1581 chk->chunk_type = SCTP_SHUTDOWN_ACK;
1582 chk->chunk_flags = 0;
1583 chk->chunk_length = htons(4);
1586 (int)(sizeof(struct sctphdr) + 2 * sizeof(struct sctp_chunkhdr))) {
1588 chk->chunk_type = SCTP_PAD_CHUNK;
1589 chk->chunk_flags = 0;
1590 chk->chunk_length = htons(protlen -
1591 (sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr)));
1594 sctp->checksum = sctp_crc32c(sctp, protlen);
1599 sctp_check(const u_char *data, int seq)
1601 struct sctphdr *const sctp = (struct sctphdr *) data;
1603 return (ntohs(sctp->src_port) == ident
1604 && ntohs(sctp->dest_port) == port + (fixedPort ? 0 : seq)
1606 (u_int32_t)((sctp->src_port << 16) | sctp->dest_port));
1610 gre_prep(struct outdata *outdata)
1612 struct grehdr *const gre = (struct grehdr *) outp;
1614 gre->flags = htons(0x2001);
1615 gre->proto = htons(port);
1617 gre->callId = htons(ident + outdata->seq);
1621 gre_check(const u_char *data, int seq)
1623 struct grehdr *const gre = (struct grehdr *) data;
1625 return(ntohs(gre->proto) == port
1626 && ntohs(gre->callId) == ident + seq);
1630 gen_prep(struct outdata *outdata)
1632 u_int16_t *const ptr = (u_int16_t *) outp;
1634 ptr[0] = htons(ident);
1635 ptr[1] = htons(port + outdata->seq);
1639 gen_check(const u_char *data, int seq)
1641 u_int16_t *const ptr = (u_int16_t *) data;
1643 return(ntohs(ptr[0]) == ident
1644 && ntohs(ptr[1]) == port + seq);
1648 print(register u_char *buf, register int cc, register struct sockaddr_in *from)
1650 register struct ip *ip;
1652 char addr[INET_ADDRSTRLEN];
1654 ip = (struct ip *) buf;
1655 hlen = ip->ip_hl << 2;
1658 strlcpy(addr, inet_ntoa(from->sin_addr), sizeof(addr));
1661 Printf(" [AS%u]", as_lookup(asn, addr, AF_INET));
1664 Printf(" %s", addr);
1666 Printf(" %s (%s)", inetname(from->sin_addr), addr);
1669 Printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
1673 * Checksum routine for UDP and TCP headers.
1676 p_cksum(struct ip *ip, u_short *data, int len, int cov)
1678 static struct ipovly ipo;
1681 ipo.ih_pr = ip->ip_p;
1682 ipo.ih_len = htons(len);
1683 ipo.ih_src = ip->ip_src;
1684 ipo.ih_dst = ip->ip_dst;
1686 sum[1] = in_cksum((u_short*)&ipo, sizeof(ipo)); /* pseudo ip hdr cksum */
1687 sum[0] = in_cksum(data, cov); /* payload data cksum */
1689 return ~in_cksum(sum, sizeof(sum));
1693 * Checksum routine for Internet Protocol family headers (C Version)
1696 in_cksum(register u_short *addr, register int len)
1698 register int nleft = len;
1699 register u_short *w = addr;
1700 register u_short answer;
1701 register int sum = 0;
1704 * Our algorithm is simple, using a 32 bit accumulator (sum),
1705 * we add sequential 16 bit words to it, and at the end, fold
1706 * back all the carry bits from the top 16 bits into the lower
1714 /* mop up an odd byte, if necessary */
1716 sum += *(u_char *)w;
1719 * add back carry outs from top 16 bits to low 16 bits
1721 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
1722 sum += (sum >> 16); /* add carry */
1723 answer = ~sum; /* truncate to 16 bits */
1728 * CRC32C routine for the Stream Control Transmission Protocol
1731 #define CRC32C(c, d) (c = (c>>8) ^ crc_c[(c^(d))&0xFF])
1733 static u_int32_t crc_c[256] = {
1734 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
1735 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
1736 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
1737 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
1738 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
1739 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
1740 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
1741 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
1742 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
1743 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
1744 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
1745 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
1746 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
1747 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
1748 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
1749 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
1750 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
1751 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
1752 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
1753 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
1754 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
1755 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
1756 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
1757 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
1758 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
1759 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
1760 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
1761 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
1762 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
1763 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
1764 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
1765 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
1766 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
1767 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
1768 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
1769 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
1770 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
1771 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
1772 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
1773 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
1774 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
1775 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
1776 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
1777 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
1778 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
1779 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
1780 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
1781 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
1782 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
1783 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
1784 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
1785 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
1786 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
1787 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
1788 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
1789 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
1790 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
1791 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
1792 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
1793 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
1794 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
1795 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
1796 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
1797 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351
1801 sctp_crc32c(const void *packet, u_int32_t len)
1803 u_int32_t i, crc32c;
1804 u_int8_t byte0, byte1, byte2, byte3;
1805 const u_int8_t *buf = (const u_int8_t *)packet;
1808 for (i = 0; i < len; i++)
1809 CRC32C(crc32c, buf[i]);
1811 byte0 = crc32c & 0xff;
1812 byte1 = (crc32c>>8) & 0xff;
1813 byte2 = (crc32c>>16) & 0xff;
1814 byte3 = (crc32c>>24) & 0xff;
1815 crc32c = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
1816 return htonl(crc32c);
1820 * Subtract 2 timeval structs: out = out - in.
1821 * Out is assumed to be within about LONG_MAX seconds of in.
1824 tvsub(register struct timeval *out, register struct timeval *in)
1827 if ((out->tv_usec -= in->tv_usec) < 0) {
1829 out->tv_usec += 1000000;
1831 out->tv_sec -= in->tv_sec;
1835 * Construct an Internet address representation.
1836 * If the nflag has been supplied, give
1837 * numeric value, otherwise try for symbolic name.
1840 inetname(struct in_addr in)
1843 register struct hostent *hp;
1844 static int first = 1;
1845 static char domain[MAXHOSTNAMELEN + 1], line[MAXHOSTNAMELEN + 1];
1847 if (first && !nflag) {
1849 if (gethostname(domain, sizeof(domain) - 1) < 0)
1852 cp = strchr(domain, '.');
1856 hp = cap_gethostbyname(capdns, domain);
1859 hp = gethostbyname(domain);
1861 cp = strchr(hp->h_name, '.');
1867 (void)strncpy(domain, cp, sizeof(domain) - 1);
1868 domain[sizeof(domain) - 1] = '\0';
1872 if (!nflag && in.s_addr != INADDR_ANY) {
1875 hp = cap_gethostbyaddr(capdns, (char *)&in, sizeof(in),
1879 hp = gethostbyaddr((char *)&in, sizeof(in), AF_INET);
1881 if ((cp = strchr(hp->h_name, '.')) != NULL &&
1882 strcmp(cp + 1, domain) == 0)
1884 (void)strncpy(line, hp->h_name, sizeof(line) - 1);
1885 line[sizeof(line) - 1] = '\0';
1889 return (inet_ntoa(in));
1893 gethostinfo(register char *hostname)
1896 register struct hostent *hp;
1897 register struct hostinfo *hi;
1899 register u_int32_t addr, *ap;
1901 if (strlen(hostname) >= MAXHOSTNAMELEN) {
1902 Fprintf(stderr, "%s: hostname \"%.32s...\" is too long\n",
1906 hi = calloc(1, sizeof(*hi));
1908 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno));
1911 addr = inet_addr(hostname);
1912 if ((int32_t)addr != -1) {
1913 hi->name = strdup(hostname);
1915 hi->addrs = calloc(1, sizeof(hi->addrs[0]));
1916 if (hi->addrs == NULL) {
1917 Fprintf(stderr, "%s: calloc %s\n",
1918 prog, strerror(errno));
1921 hi->addrs[0] = addr;
1927 hp = cap_gethostbyname(capdns, hostname);
1930 hp = gethostbyname(hostname);
1932 Fprintf(stderr, "%s: unknown host %s\n", prog, hostname);
1935 if (hp->h_addrtype != AF_INET || hp->h_length != 4) {
1936 Fprintf(stderr, "%s: bad host %s\n", prog, hostname);
1939 hi->name = strdup(hp->h_name);
1940 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
1943 hi->addrs = calloc(n, sizeof(hi->addrs[0]));
1944 if (hi->addrs == NULL) {
1945 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno));
1948 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
1949 memcpy(ap, *p, sizeof(*ap));
1954 freehostinfo(register struct hostinfo *hi)
1956 if (hi->name != NULL) {
1960 free((char *)hi->addrs);
1965 getaddr(register u_int32_t *ap, register char *hostname)
1967 register struct hostinfo *hi;
1969 hi = gethostinfo(hostname);
1975 setsin(register struct sockaddr_in *sin, register u_int32_t addr)
1978 memset(sin, 0, sizeof(*sin));
1979 #ifdef HAVE_SOCKADDR_SA_LEN
1980 sin->sin_len = sizeof(*sin);
1982 sin->sin_family = AF_INET;
1983 sin->sin_addr.s_addr = addr;
1986 /* String to value with optional min and max. Handles decimal and hex. */
1988 str2val(register const char *str, register const char *what,
1989 register int mi, register int ma)
1991 register const char *cp;
1995 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
1997 val = (int)strtol(cp, &ep, 16);
1999 val = (int)strtol(str, &ep, 10);
2001 Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
2005 if (val < mi && mi >= 0) {
2007 Fprintf(stderr, "%s: %s must be >= %d\n",
2010 Fprintf(stderr, "%s: %s must be > %d\n",
2011 prog, what, mi - 1);
2014 if (val > ma && ma >= 0) {
2015 Fprintf(stderr, "%s: %s must be <= %d\n", prog, what, ma);
2022 setproto(char *pname)
2024 struct outproto *proto;
2027 for (i = 0; protos[i].name != NULL; i++) {
2028 if (strcasecmp(protos[i].name, pname) == 0) {
2033 if (proto->name == NULL) { /* generic handler */
2034 struct protoent *pe;
2037 /* Determine the IP protocol number */
2038 if ((pe = getprotobyname(pname)) != NULL)
2041 pnum = str2val(optarg, "proto number", 1, 255);
2048 pkt_compare(const u_char *a, int la, const u_char *b, int lb) {
2052 for (i = 0; i < la; i++)
2053 Printf("%02x", (unsigned int)a[i]);
2055 l = (la <= lb) ? la : lb;
2056 for (i = 0; i < l; i++)
2060 Printf("%02x", (unsigned int)b[i]);
2062 Printf("%02x", (unsigned int)b[i]);
2070 extern char version[];
2072 Fprintf(stderr, "Version %s\n", version);
2074 "Usage: %s [-adDeFInrSvx] [-f first_ttl] [-g gateway] [-i iface]\n"
2075 "\t[-m max_ttl] [-p port] [-P proto] [-q nqueries] [-s src_addr]\n"
2076 "\t[-t tos] [-w waittime] [-A as_server] [-z pausemsecs] host [packetlen]\n", prog);