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>
232 #include <libcasper.h>
233 #include <casper/cap_dns.h>
237 #include <net/route.h>
238 #include <netipsec/ipsec.h> /* XXX */
242 #include <capsicum_helpers.h>
257 #ifndef ICMP_UNREACH_FILTER_PROHIB
258 #define ICMP_UNREACH_FILTER_PROHIB 13 /* admin prohibited filter */
260 #ifndef ICMP_UNREACH_HOST_PRECEDENCE
261 #define ICMP_UNREACH_HOST_PRECEDENCE 14 /* host precedence violation */
263 #ifndef ICMP_UNREACH_PRECEDENCE_CUTOFF
264 #define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 /* precedence cutoff */
267 #include "findsaddr.h"
268 #include "ifaddrlist.h"
270 #include "traceroute.h"
272 /* Maximum number of gateways (include room for one noop) */
273 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
275 #ifndef MAXHOSTNAMELEN
276 #define MAXHOSTNAMELEN 64
279 #define Fprintf (void)fprintf
280 #define Printf (void)printf
282 /* What a GRE packet header looks like */
286 u_int16_t length; /* PPTP version of these fields */
290 #define IPPROTO_GRE 47
293 /* For GRE, we prepare what looks like a PPTP packet */
294 #define GRE_PPTP_PROTO 0x880b
296 /* Host name and address list */
303 /* Data section of the probe packet */
305 u_char seq; /* sequence number of this packet */
306 u_char ttl; /* ttl packet left with */
307 struct timeval tv; /* time packet left */
310 #ifndef HAVE_ICMP_NEXTMTU
311 /* Path MTU Discovery (RFC1191) */
318 u_char packet[512]; /* last inbound (icmp) packet */
320 struct ip *outip; /* last output ip packet */
321 u_char *outp; /* last output inner protocol packet */
323 struct ip *hip = NULL; /* Quoted IP header */
326 /* loose source route gateway list (including room for final destination) */
327 u_int32_t gwlist[NGATEWAYS + 1];
329 int s; /* receive (icmp) socket file descriptor */
330 int sndsock; /* send (udp) socket file descriptor */
332 struct sockaddr whereto; /* Who to try to reach */
333 struct sockaddr wherefrom; /* Who we are */
334 int packlen; /* total length of packet */
335 int protlen; /* length of protocol part of packet */
336 int minpacket; /* min ip packet size */
337 int maxpacket = 32 * 1024; /* max ip packet size */
338 int pmtu; /* Path MTU Discovery (RFC1191) */
345 static const char devnull[] = "/dev/null";
351 u_short port; /* protocol specific base "port" */
353 int options; /* socket options */
355 int waittime = 5; /* time to wait for response (in seconds) */
356 int nflag; /* print addresses numerically */
357 int as_path; /* print as numbers for each hop */
358 char *as_server = NULL;
360 #ifdef CANT_HACK_IPCKSUM
361 int doipcksum = 0; /* don't calculate ip checksums by default */
363 int doipcksum = 1; /* calculate ip checksums by default */
365 int optlen; /* length of ip options */
366 int fixedPort = 0; /* Use fixed destination port for TCP and UDP */
367 int printdiff = 0; /* Print the difference between sent and quoted */
374 static cap_channel_t *capdns;
378 double deltaT(struct timeval *, struct timeval *);
379 void freehostinfo(struct hostinfo *);
380 void getaddr(u_int32_t *, char *);
381 struct hostinfo *gethostinfo(char *);
382 u_short in_cksum(u_short *, int);
383 u_int32_t sctp_crc32c(const void *, u_int32_t);
384 char *inetname(struct in_addr);
385 int main(int, char **);
386 u_short p_cksum(struct ip *, u_short *, int, int);
387 int packet_ok(u_char *, int, struct sockaddr_in *, int);
388 char *pr_type(u_char);
389 void print(u_char *, int, struct sockaddr_in *);
391 int setpolicy __P((int so, char *policy));
393 void send_probe(int, int);
394 struct outproto *setproto(char *);
395 int str2val(const char *, const char *, int, int);
396 void tvsub(struct timeval *, struct timeval *);
398 int wait_for_reply(int, struct sockaddr_in *, const struct timeval *);
399 void pkt_compare(const u_char *, int, const u_char *, int);
404 void udp_prep(struct outdata *);
405 int udp_check(const u_char *, int);
406 void udplite_prep(struct outdata *);
407 int udplite_check(const u_char *, int);
408 void tcp_prep(struct outdata *);
409 int tcp_check(const u_char *, int);
410 void sctp_prep(struct outdata *);
411 int sctp_check(const u_char *, int);
412 void gre_prep(struct outdata *);
413 int gre_check(const u_char *, int);
414 void gen_prep(struct outdata *);
415 int gen_check(const u_char *, int);
416 void icmp_prep(struct outdata *);
417 int icmp_check(const u_char *, int);
419 /* Descriptor structure for each outgoing protocol we support */
421 char *name; /* name of protocol */
422 const char *key; /* An ascii key for the bytes of the header */
423 u_char num; /* IP protocol number */
424 u_short hdrlen; /* max size of protocol header */
425 u_short port; /* default base protocol-specific "port" */
426 void (*prepare)(struct outdata *);
427 /* finish preparing an outgoing packet */
428 int (*check)(const u_char *, int);
429 /* check an incoming packet */
432 /* List of supported protocols. The first one is the default. The last
433 one is the handler for generic protocols not explicitly listed. */
434 struct outproto protos[] = {
439 sizeof(struct udphdr),
448 sizeof(struct udphdr),
455 "spt dpt seq ack xxflwin sum urp",
457 sizeof(struct tcphdr),
464 "spt dpt vtag crc tyfllen tyfllen ",
466 sizeof(struct sctphdr),
475 sizeof(struct grehdr),
499 struct outproto *proto = &protos[0];
501 const char *ip_hdr_key = "vhtslen id off tlprsum srcip dstip opts";
504 main(int argc, char **argv)
506 register int op, code, n;
508 register const char *err;
509 register u_int32_t *ap;
510 register struct sockaddr_in *from = (struct sockaddr_in *)&wherefrom;
511 register struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
512 register struct hostinfo *hi;
514 register struct protoent *pe;
515 register int ttl, probe, i;
516 register int seq = 0;
517 int tos = 0, settos = 0;
518 register int lsrr = 0;
519 register u_short off = 0;
520 struct ifaddrlist *al;
522 int requestPort = -1;
526 const char *types[] = { "NAME2ADDR", "ADDR2NAME" };
528 cap_channel_t *casper;
533 /* Insure the socket fds won't be 0, 1 or 2 */
534 if (open(devnull, O_RDONLY) < 0 ||
535 open(devnull, O_RDONLY) < 0 ||
536 open(devnull, O_RDONLY) < 0) {
537 Fprintf(stderr, "%s: open \"%s\": %s\n",
538 prog, devnull, strerror(errno));
542 * Do the setuid-required stuff first, then lose priveleges ASAP.
543 * Do error checking for these two calls where they appeared in
547 pe = getprotobyname(cp);
549 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0)
551 else if ((sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
555 if (setuid(getuid()) != 0) {
563 errx(1, "unable to create casper process");
564 capdns = cap_service_open(casper, "system.dns");
566 errx(1, "unable to open system.dns service");
567 if (cap_dns_type_limit(capdns, types, 2) < 0)
568 errx(1, "unable to limit access to system.dns service");
569 families[0] = AF_INET;
570 if (cap_dns_family_limit(capdns, families, 1) < 0)
571 errx(1, "unable to limit access to system.dns service");
572 #endif /* WITH_CASPER */
576 int mib[4] = { CTL_NET, PF_INET, IPPROTO_IP, IPCTL_DEFTTL };
577 size_t sz = sizeof(max_ttl);
579 if (sysctl(mib, 4, &max_ttl, &sz, NULL, 0) == -1) {
580 perror("sysctl(net.inet.ip.ttl)");
584 #else /* !IPCTL_DEFTTL */
594 else if ((cp = strrchr(argv[0], '/')) != NULL)
600 while ((op = getopt(argc, argv, "aA:edDFInrSvxf:g:i:M:m:P:p:q:s:t:w:z:")) != EOF)
624 case 'M': /* FreeBSD compat. */
625 first_ttl = str2val(optarg, "first ttl", 1, 255);
633 if (lsrr >= NGATEWAYS) {
635 "%s: No more than %d gateways\n",
639 getaddr(gwlist + lsrr, optarg);
648 proto = setproto("icmp");
652 max_ttl = str2val(optarg, "max ttl", 1, 255);
660 proto = setproto(optarg);
664 requestPort = (u_short)str2val(optarg, "port",
669 nprobes = str2val(optarg, "nprobes", 1, -1);
673 options |= SO_DONTROUTE;
678 * set the ip source address of the outbound
679 * probe (e.g., on a multi-homed host).
689 tos = str2val(optarg, "tos", 0, 255);
698 doipcksum = (doipcksum == 0);
702 waittime = str2val(optarg, "wait time",
707 pausemsecs = str2val(optarg, "pause msecs",
715 /* Set requested port, if any, else default for this protocol */
716 port = (requestPort != -1) ? requestPort : proto->port;
719 nprobes = printdiff ? 1 : 3;
721 if (first_ttl > max_ttl) {
723 "%s: first ttl (%d) may not be greater than max ttl (%d)\n",
724 prog, first_ttl, max_ttl);
729 Fprintf(stderr, "%s: Warning: ip checksums disabled\n", prog);
732 optlen = (lsrr + 1) * sizeof(gwlist[0]);
733 minpacket = sizeof(*outip) + proto->hdrlen + optlen;
739 /* Process destination and optional packet size */
740 switch (argc - optind) {
743 packlen = str2val(argv[optind + 1],
744 "packet length", minpacket, maxpacket);
748 hostname = argv[optind];
749 hi = gethostinfo(hostname);
750 setsin(to, hi->addrs[0]);
753 "%s: Warning: %s has multiple addresses; using %s\n",
754 prog, hostname, inet_ntoa(to->sin_addr));
764 #ifdef HAVE_SETLINEBUF
767 setvbuf(stdout, NULL, _IOLBF, 0);
770 protlen = packlen - sizeof(*outip) - optlen;
771 if ((proto->num == IPPROTO_SCTP) && (packlen & 3)) {
772 Fprintf(stderr, "%s: packet length must be a multiple of 4\n",
777 outip = (struct ip *)malloc((unsigned)packlen);
779 Fprintf(stderr, "%s: malloc: %s\n", prog, strerror(errno));
782 memset((char *)outip, 0, packlen);
784 outip->ip_v = IPVERSION;
787 #ifdef BYTESWAP_IP_HDR
788 outip->ip_len = htons(packlen);
789 outip->ip_off = htons(off);
791 outip->ip_len = packlen;
794 outip->ip_p = proto->num;
795 outp = (u_char *)(outip + 1);
796 #ifdef HAVE_RAW_OPTIONS
798 register u_char *optlist;
804 gwlist[lsrr] = to->sin_addr.s_addr;
806 outip->ip_dst.s_addr = gwlist[0];
808 /* force 4 byte alignment */
809 optlist[0] = IPOPT_NOP;
810 /* loose source route option */
811 optlist[1] = IPOPT_LSRR;
812 i = lsrr * sizeof(gwlist[0]);
814 /* Pointer to LSRR addresses */
815 optlist[3] = IPOPT_MINOFF;
816 memcpy(optlist + 4, gwlist + 1, i);
819 outip->ip_dst = to->sin_addr;
821 outip->ip_hl = (outp - (u_char *)outip) >> 2;
822 ident = (getpid() & 0xffff) | 0x8000;
825 Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp);
830 Fprintf(stderr, "%s: icmp socket: %s\n", prog, strerror(errno));
833 if (options & SO_DEBUG)
834 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
836 if (options & SO_DONTROUTE)
837 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
840 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
841 if (setpolicy(s, "in bypass") < 0)
842 errx(1, "%s", ipsec_strerror());
844 if (setpolicy(s, "out bypass") < 0)
845 errx(1, "%s", ipsec_strerror());
846 #endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
850 Fprintf(stderr, "%s: raw socket: %s\n", prog, strerror(errno));
854 #if defined(IP_OPTIONS) && !defined(HAVE_RAW_OPTIONS)
856 u_char optlist[MAX_IPOPTLEN];
859 if ((pe = getprotobyname(cp)) == NULL) {
860 Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp);
865 gwlist[lsrr] = to->sin_addr.s_addr;
868 /* force 4 byte alignment */
869 optlist[0] = IPOPT_NOP;
870 /* loose source route option */
871 optlist[1] = IPOPT_LSRR;
872 i = lsrr * sizeof(gwlist[0]);
874 /* Pointer to LSRR addresses */
875 optlist[3] = IPOPT_MINOFF;
876 memcpy(optlist + 4, gwlist, i);
878 if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS,
879 (char *)optlist, i + sizeof(gwlist[0]))) < 0) {
880 Fprintf(stderr, "%s: IP_OPTIONS: %s\n",
881 prog, strerror(errno));
888 if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
889 sizeof(packlen)) < 0) {
890 Fprintf(stderr, "%s: SO_SNDBUF: %s\n", prog, strerror(errno));
895 if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
897 Fprintf(stderr, "%s: IP_HDRINCL: %s\n", prog, strerror(errno));
902 if (settos && setsockopt(sndsock, IPPROTO_IP, IP_TOS,
903 (char *)&tos, sizeof(tos)) < 0) {
904 Fprintf(stderr, "%s: setsockopt tos %d: %s\n",
905 prog, tos, strerror(errno));
910 if (options & SO_DEBUG)
911 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
913 if (options & SO_DONTROUTE)
914 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
917 /* Get the interface address list */
918 n = ifaddrlist(&al, errbuf);
920 Fprintf(stderr, "%s: ifaddrlist: %s\n", prog, errbuf);
925 "%s: Can't find any network interfaces\n", prog);
929 /* Look for a specific device */
930 if (device != NULL) {
931 for (i = n; i > 0; --i, ++al)
932 if (strcmp(device, al->device) == 0)
935 Fprintf(stderr, "%s: Can't find interface %.32s\n",
941 /* Determine our source address */
942 if (source == NULL) {
944 * If a device was specified, use the interface address.
945 * Otherwise, try to determine our source address.
948 setsin(from, al->addr);
949 else if ((err = findsaddr(to, from)) != NULL) {
950 Fprintf(stderr, "%s: findsaddr: %s\n",
955 hi = gethostinfo(source);
959 * If the device was specified make sure it
960 * corresponds to the source address specified.
961 * Otherwise, use the first address (and warn if
962 * there are more than one).
964 if (device != NULL) {
965 for (i = hi->n, ap = hi->addrs; i > 0; --i, ++ap)
970 "%s: %s is not on interface %.32s\n",
971 prog, source, device);
976 setsin(from, hi->addrs[0]);
979 "%s: Warning: %s has multiple addresses; using %s\n",
980 prog, source, inet_ntoa(from->sin_addr));
985 outip->ip_src = from->sin_addr;
987 /* Check the source address (-s), if any, is valid */
988 if (bind(sndsock, (struct sockaddr *)from, sizeof(*from)) < 0) {
989 Fprintf(stderr, "%s: bind: %s\n",
990 prog, strerror(errno));
995 asn = as_setup(as_server);
997 Fprintf(stderr, "%s: as_setup failed, AS# lookups"
998 " disabled\n", prog);
999 (void)fflush(stderr);
1004 if (connect(sndsock, (struct sockaddr *)&whereto,
1005 sizeof(whereto)) != 0) {
1006 Fprintf(stderr, "%s: connect: %s\n", prog, strerror(errno));
1019 caph_cache_catpages();
1022 * Here we enter capability mode. Further down access to global
1023 * namespaces (e.g filesystem) is restricted (see capsicum(4)).
1024 * We must connect(2) our socket before this point.
1026 if (cansandbox && cap_enter() < 0) {
1027 if (errno != ENOSYS) {
1028 Fprintf(stderr, "%s: cap_enter: %s\n", prog,
1036 cap_rights_init(&rights, CAP_SEND, CAP_SETSOCKOPT);
1037 if (cansandbox && cap_rights_limit(sndsock, &rights) < 0) {
1038 Fprintf(stderr, "%s: cap_rights_limit sndsock: %s\n", prog,
1043 cap_rights_init(&rights, CAP_RECV, CAP_EVENT);
1044 if (cansandbox && cap_rights_limit(s, &rights) < 0) {
1045 Fprintf(stderr, "%s: cap_rights_limit s: %s\n", prog,
1050 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1051 if (setpolicy(sndsock, "in bypass") < 0)
1052 errx(1, "%s", ipsec_strerror());
1054 if (setpolicy(sndsock, "out bypass") < 0)
1055 errx(1, "%s", ipsec_strerror());
1056 #endif /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
1058 Fprintf(stderr, "%s to %s (%s)",
1059 prog, hostname, inet_ntoa(to->sin_addr));
1061 Fprintf(stderr, " from %s", source);
1062 Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
1063 (void)fflush(stderr);
1065 for (ttl = first_ttl; ttl <= max_ttl; ++ttl) {
1066 u_int32_t lastaddr = 0;
1067 int gotlastaddr = 0;
1069 int unreachable = 0;
1073 Printf("%2d ", ttl);
1074 for (probe = 0, loss = 0; probe < nprobes; ++probe) {
1076 struct timeval t1, t2;
1077 register struct ip *ip;
1078 struct outdata outdata;
1080 if (sentfirst && pausemsecs > 0)
1081 usleep(pausemsecs * 1000);
1082 /* Prepare outgoing data */
1083 outdata.seq = ++seq;
1086 /* Avoid alignment problems by copying bytewise: */
1087 (void)gettimeofday(&t1, NULL);
1088 memcpy(&outdata.tv, &t1, sizeof(outdata.tv));
1090 /* Finalize and send packet */
1091 (*proto->prepare)(&outdata);
1092 send_probe(seq, ttl);
1095 /* Wait for a reply */
1096 while ((cc = wait_for_reply(s, from, &t1)) != 0) {
1100 (void)gettimeofday(&t2, NULL);
1101 i = packet_ok(packet, cc, from, seq);
1102 /* Skip short packet */
1106 from->sin_addr.s_addr != lastaddr) {
1107 if (gotlastaddr) printf("\n ");
1108 print(packet, cc, from);
1109 lastaddr = from->sin_addr.s_addr;
1112 T = deltaT(&t1, &t2);
1113 #ifdef SANE_PRECISION
1116 else if (T >= 100.0)
1123 Printf(" %.*f ms", precis, T);
1127 -(outip->ip_hl << 3),
1131 pkt_compare((void *)outip, packlen,
1132 (void *)hip, hiplen);
1136 ip = (struct ip *)packet;
1137 if (ip->ip_ttl <= 1)
1143 /* time exceeded in transit */
1149 case ICMP_UNREACH_PORT:
1151 ip = (struct ip *)packet;
1152 if (ip->ip_ttl <= 1)
1158 case ICMP_UNREACH_NET:
1163 case ICMP_UNREACH_HOST:
1168 case ICMP_UNREACH_PROTOCOL:
1173 case ICMP_UNREACH_NEEDFRAG:
1175 Printf(" !F-%d", pmtu);
1178 case ICMP_UNREACH_SRCFAIL:
1183 case ICMP_UNREACH_NET_UNKNOWN:
1188 case ICMP_UNREACH_HOST_UNKNOWN:
1193 case ICMP_UNREACH_ISOLATED:
1198 case ICMP_UNREACH_NET_PROHIB:
1203 case ICMP_UNREACH_HOST_PROHIB:
1208 case ICMP_UNREACH_TOSNET:
1213 case ICMP_UNREACH_TOSHOST:
1218 case ICMP_UNREACH_FILTER_PROHIB:
1223 case ICMP_UNREACH_HOST_PRECEDENCE:
1228 case ICMP_UNREACH_PRECEDENCE_CUTOFF:
1235 Printf(" !<%d>", code);
1244 (void)fflush(stdout);
1247 Printf(" (%d%% loss)", (loss * 100) / nprobes);
1251 (unreachable > 0 && unreachable >= nprobes - 1))
1260 wait_for_reply(register int sock, register struct sockaddr_in *fromp,
1261 register const struct timeval *tp)
1265 struct timeval now, wait;
1266 register int cc = 0;
1268 int fromlen = sizeof(*fromp);
1270 nfds = howmany(sock + 1, NFDBITS);
1271 if ((fdsp = malloc(nfds * sizeof(fd_mask))) == NULL)
1273 memset(fdsp, 0, nfds * sizeof(fd_mask));
1276 wait.tv_sec = tp->tv_sec + waittime;
1277 wait.tv_usec = tp->tv_usec;
1278 (void)gettimeofday(&now, NULL);
1280 if (wait.tv_sec < 0) {
1285 error = select(sock + 1, fdsp, NULL, NULL, &wait);
1286 if (error == -1 && errno == EINVAL) {
1287 Fprintf(stderr, "%s: botched select() args\n", prog);
1291 cc = recvfrom(sock, (char *)packet, sizeof(packet), 0,
1292 (struct sockaddr *)fromp, &fromlen);
1299 send_probe(int seq, int ttl)
1303 outip->ip_ttl = ttl;
1304 outip->ip_id = htons(ident + seq);
1306 /* XXX undocumented debugging hack */
1308 register const u_short *sp;
1309 register int nshorts, i;
1311 sp = (u_short *)outip;
1312 nshorts = (u_int)packlen / sizeof(u_short);
1314 Printf("[ %d bytes", packlen);
1315 while (--nshorts >= 0) {
1318 Printf(" %04x", ntohs(*sp++));
1323 Printf(" %02x", *(u_char *)sp);
1328 #if !defined(IP_HDRINCL) && defined(IP_TTL)
1329 if (setsockopt(sndsock, IPPROTO_IP, IP_TTL,
1330 (char *)&ttl, sizeof(ttl)) < 0) {
1331 Fprintf(stderr, "%s: setsockopt ttl %d: %s\n",
1332 prog, ttl, strerror(errno));
1337 cc = send(sndsock, (char *)outip, packlen, 0);
1338 if (cc < 0 || cc != packlen) {
1340 Fprintf(stderr, "%s: sendto: %s\n",
1341 prog, strerror(errno));
1342 Printf("%s: wrote %s %d chars, ret=%d\n",
1343 prog, hostname, packlen, cc);
1344 (void)fflush(stdout);
1348 #if defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
1350 setpolicy(so, policy)
1356 buf = ipsec_set_policy(policy, strlen(policy));
1358 warnx("%s", ipsec_strerror());
1361 (void)setsockopt(so, IPPROTO_IP, IP_IPSEC_POLICY,
1362 buf, ipsec_get_policylen(buf));
1371 deltaT(struct timeval *t1p, struct timeval *t2p)
1375 dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
1376 (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
1381 * Convert an ICMP "type" field to a printable string.
1384 pr_type(register u_char t)
1386 static char *ttab[] = {
1387 "Echo Reply", "ICMP 1", "ICMP 2", "Dest Unreachable",
1388 "Source Quench", "Redirect", "ICMP 6", "ICMP 7",
1389 "Echo", "ICMP 9", "ICMP 10", "Time Exceeded",
1390 "Param Problem", "Timestamp", "Timestamp Reply", "Info Request",
1395 return("OUT-OF-RANGE");
1401 packet_ok(register u_char *buf, int cc, register struct sockaddr_in *from,
1404 register struct icmp *icp;
1405 register u_char type, code;
1408 register struct ip *ip;
1410 ip = (struct ip *) buf;
1411 hlen = ip->ip_hl << 2;
1412 if (cc < hlen + ICMP_MINLEN) {
1414 Printf("packet too short (%d bytes) from %s\n", cc,
1415 inet_ntoa(from->sin_addr));
1419 icp = (struct icmp *)(buf + hlen);
1421 icp = (struct icmp *)buf;
1423 type = icp->icmp_type;
1424 code = icp->icmp_code;
1425 /* Path MTU Discovery (RFC1191) */
1426 if (code != ICMP_UNREACH_NEEDFRAG)
1429 #ifdef HAVE_ICMP_NEXTMTU
1430 pmtu = ntohs(icp->icmp_nextmtu);
1432 pmtu = ntohs(((struct my_pmtu *)&icp->icmp_void)->ipm_nextmtu);
1435 if (type == ICMP_ECHOREPLY
1436 && proto->num == IPPROTO_ICMP
1437 && (*proto->check)((u_char *)icp, (u_char)seq))
1439 if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
1440 type == ICMP_UNREACH) {
1443 hip = &icp->icmp_ip;
1444 hiplen = ((u_char *)icp + cc) - (u_char *)hip;
1445 hlen = hip->ip_hl << 2;
1446 inner = (u_char *)((u_char *)hip + hlen);
1448 && hip->ip_p == proto->num
1449 && (*proto->check)(inner, (u_char)seq))
1450 return (type == ICMP_TIMXCEED ? -1 : code + 1);
1455 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
1457 Printf("\n%d bytes from %s to ", cc, inet_ntoa(from->sin_addr));
1458 Printf("%s: icmp type %d (%s) code %d\n",
1459 inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
1460 for (i = 4; i <= cc - ICMP_MINLEN; i += sizeof(*lp))
1461 Printf("%2d: %8.8x\n", i, ntohl(*lp++));
1468 icmp_prep(struct outdata *outdata)
1470 struct icmp *const icmpheader = (struct icmp *) outp;
1472 icmpheader->icmp_type = ICMP_ECHO;
1473 icmpheader->icmp_id = htons(ident);
1474 icmpheader->icmp_seq = htons(outdata->seq);
1475 icmpheader->icmp_cksum = 0;
1476 icmpheader->icmp_cksum = in_cksum((u_short *)icmpheader, protlen);
1477 if (icmpheader->icmp_cksum == 0)
1478 icmpheader->icmp_cksum = 0xffff;
1482 icmp_check(const u_char *data, int seq)
1484 struct icmp *const icmpheader = (struct icmp *) data;
1486 return (icmpheader->icmp_id == htons(ident)
1487 && icmpheader->icmp_seq == htons(seq));
1491 udp_prep(struct outdata *outdata)
1493 struct udphdr *const outudp = (struct udphdr *) outp;
1495 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0));
1496 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1497 outudp->uh_ulen = htons((u_short)protlen);
1500 u_short sum = p_cksum(outip, (u_short*)outudp, protlen, protlen);
1501 outudp->uh_sum = (sum) ? sum : 0xffff;
1508 udp_check(const u_char *data, int seq)
1510 struct udphdr *const udp = (struct udphdr *) data;
1512 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) &&
1513 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq));
1517 udplite_prep(struct outdata *outdata)
1519 struct udphdr *const outudp = (struct udphdr *) outp;
1521 outudp->uh_sport = htons(ident + (fixedPort ? outdata->seq : 0));
1522 outudp->uh_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1523 outudp->uh_ulen = htons(8);
1526 u_short sum = p_cksum(outip, (u_short*)outudp, protlen, 8);
1527 outudp->uh_sum = (sum) ? sum : 0xffff;
1534 udplite_check(const u_char *data, int seq)
1536 struct udphdr *const udp = (struct udphdr *) data;
1538 return (ntohs(udp->uh_sport) == ident + (fixedPort ? seq : 0) &&
1539 ntohs(udp->uh_dport) == port + (fixedPort ? 0 : seq));
1543 tcp_prep(struct outdata *outdata)
1545 struct tcphdr *const tcp = (struct tcphdr *) outp;
1547 tcp->th_sport = htons(ident);
1548 tcp->th_dport = htons(port + (fixedPort ? 0 : outdata->seq));
1549 tcp->th_seq = (tcp->th_sport << 16) | tcp->th_dport;
1552 tcp->th_flags = TH_SYN;
1556 tcp->th_sum = p_cksum(outip, (u_short*)tcp, protlen, protlen);
1560 tcp_check(const u_char *data, int seq)
1562 struct tcphdr *const tcp = (struct tcphdr *) data;
1564 return (ntohs(tcp->th_sport) == ident
1565 && ntohs(tcp->th_dport) == port + (fixedPort ? 0 : seq)
1566 && tcp->th_seq == (tcp_seq)((tcp->th_sport << 16) | tcp->th_dport));
1570 sctp_prep(struct outdata *outdata)
1572 struct sctphdr *const sctp = (struct sctphdr *) outp;
1573 struct sctp_chunkhdr *chk;
1574 struct sctp_init_chunk *init;
1575 struct sctp_paramhdr *param;
1577 sctp->src_port = htons(ident);
1578 sctp->dest_port = htons(port + (fixedPort ? 0 : outdata->seq));
1579 if (protlen >= (int)(sizeof(struct sctphdr) +
1580 sizeof(struct sctp_init_chunk))) {
1583 sctp->v_tag = (sctp->src_port << 16) | sctp->dest_port;
1585 sctp->checksum = htonl(0);
1586 if (protlen >= (int)(sizeof(struct sctphdr) +
1587 sizeof(struct sctp_init_chunk))) {
1589 * Send a packet containing an INIT chunk. This works
1590 * better in case of firewalls on the path, but
1591 * results in a probe packet containing at least
1592 * 32 bytes of payload. For shorter payloads, use
1593 * SHUTDOWN-ACK chunks.
1595 init = (struct sctp_init_chunk *)(sctp + 1);
1596 init->ch.chunk_type = SCTP_INITIATION;
1597 init->ch.chunk_flags = 0;
1598 init->ch.chunk_length = htons((u_int16_t)(protlen -
1599 sizeof(struct sctphdr)));
1600 init->init.initiate_tag = (sctp->src_port << 16) |
1602 init->init.a_rwnd = htonl(1500);
1603 init->init.num_outbound_streams = htons(1);
1604 init->init.num_inbound_streams = htons(1);
1605 init->init.initial_tsn = htonl(0);
1606 if (protlen >= (int)(sizeof(struct sctphdr) +
1607 sizeof(struct sctp_init_chunk) +
1608 sizeof(struct sctp_paramhdr))) {
1609 param = (struct sctp_paramhdr *)(init + 1);
1610 param->param_type = htons(SCTP_PAD);
1611 param->param_length =
1612 htons((u_int16_t)(protlen -
1613 sizeof(struct sctphdr) -
1614 sizeof(struct sctp_init_chunk)));
1618 * Send a packet containing a SHUTDOWN-ACK chunk,
1619 * possibly followed by a PAD chunk.
1622 (int)(sizeof(struct sctphdr) +
1623 sizeof(struct sctp_chunkhdr))) {
1624 chk = (struct sctp_chunkhdr *)(sctp + 1);
1625 chk->chunk_type = SCTP_SHUTDOWN_ACK;
1626 chk->chunk_flags = 0;
1627 chk->chunk_length = htons(4);
1630 (int)(sizeof(struct sctphdr) +
1631 2 * sizeof(struct sctp_chunkhdr))) {
1633 chk->chunk_type = SCTP_PAD_CHUNK;
1634 chk->chunk_flags = 0;
1635 chk->chunk_length = htons(protlen -
1636 (sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr)));
1640 sctp->checksum = sctp_crc32c(sctp, protlen);
1645 sctp_check(const u_char *data, int seq)
1647 struct sctphdr *const sctp = (struct sctphdr *) data;
1649 if (ntohs(sctp->src_port) != ident ||
1650 ntohs(sctp->dest_port) != port + (fixedPort ? 0 : seq))
1652 if (protlen < (int)(sizeof(struct sctphdr) +
1653 sizeof(struct sctp_init_chunk))) {
1654 return (sctp->v_tag ==
1655 (u_int32_t)((sctp->src_port << 16) | sctp->dest_port));
1658 * Don't verify the initiate_tag, since it is not available,
1661 return (sctp->v_tag == 0);
1666 gre_prep(struct outdata *outdata)
1668 struct grehdr *const gre = (struct grehdr *) outp;
1670 gre->flags = htons(0x2001);
1671 gre->proto = htons(port);
1673 gre->callId = htons(ident + outdata->seq);
1677 gre_check(const u_char *data, int seq)
1679 struct grehdr *const gre = (struct grehdr *) data;
1681 return(ntohs(gre->proto) == port
1682 && ntohs(gre->callId) == ident + seq);
1686 gen_prep(struct outdata *outdata)
1688 u_int16_t *const ptr = (u_int16_t *) outp;
1690 ptr[0] = htons(ident);
1691 ptr[1] = htons(port + outdata->seq);
1695 gen_check(const u_char *data, int seq)
1697 u_int16_t *const ptr = (u_int16_t *) data;
1699 return(ntohs(ptr[0]) == ident
1700 && ntohs(ptr[1]) == port + seq);
1704 print(register u_char *buf, register int cc, register struct sockaddr_in *from)
1706 register struct ip *ip;
1708 char addr[INET_ADDRSTRLEN];
1710 ip = (struct ip *) buf;
1711 hlen = ip->ip_hl << 2;
1714 strlcpy(addr, inet_ntoa(from->sin_addr), sizeof(addr));
1717 Printf(" [AS%u]", as_lookup(asn, addr, AF_INET));
1720 Printf(" %s", addr);
1722 Printf(" %s (%s)", inetname(from->sin_addr), addr);
1725 Printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
1729 * Checksum routine for UDP and TCP headers.
1732 p_cksum(struct ip *ip, u_short *data, int len, int cov)
1734 static struct ipovly ipo;
1737 ipo.ih_pr = ip->ip_p;
1738 ipo.ih_len = htons(len);
1739 ipo.ih_src = ip->ip_src;
1740 ipo.ih_dst = ip->ip_dst;
1742 sum[1] = in_cksum((u_short*)&ipo, sizeof(ipo)); /* pseudo ip hdr cksum */
1743 sum[0] = in_cksum(data, cov); /* payload data cksum */
1745 return ~in_cksum(sum, sizeof(sum));
1749 * Checksum routine for Internet Protocol family headers (C Version)
1752 in_cksum(register u_short *addr, register int len)
1754 register int nleft = len;
1755 register u_short *w = addr;
1756 register u_short answer;
1757 register int sum = 0;
1760 * Our algorithm is simple, using a 32 bit accumulator (sum),
1761 * we add sequential 16 bit words to it, and at the end, fold
1762 * back all the carry bits from the top 16 bits into the lower
1770 /* mop up an odd byte, if necessary */
1772 sum += *(u_char *)w;
1775 * add back carry outs from top 16 bits to low 16 bits
1777 sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
1778 sum += (sum >> 16); /* add carry */
1779 answer = ~sum; /* truncate to 16 bits */
1784 * CRC32C routine for the Stream Control Transmission Protocol
1787 #define CRC32C(c, d) (c = (c>>8) ^ crc_c[(c^(d))&0xFF])
1789 static u_int32_t crc_c[256] = {
1790 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
1791 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
1792 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
1793 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
1794 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
1795 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
1796 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
1797 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
1798 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
1799 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
1800 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
1801 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
1802 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
1803 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
1804 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
1805 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
1806 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
1807 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
1808 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
1809 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
1810 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
1811 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
1812 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
1813 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
1814 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
1815 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
1816 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
1817 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
1818 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
1819 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
1820 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
1821 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
1822 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
1823 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
1824 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
1825 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
1826 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
1827 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
1828 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
1829 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
1830 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
1831 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
1832 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
1833 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
1834 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
1835 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
1836 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
1837 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
1838 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
1839 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
1840 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
1841 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
1842 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
1843 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
1844 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
1845 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
1846 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
1847 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
1848 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
1849 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
1850 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
1851 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
1852 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
1853 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351
1857 sctp_crc32c(const void *packet, u_int32_t len)
1859 u_int32_t i, crc32c;
1860 u_int8_t byte0, byte1, byte2, byte3;
1861 const u_int8_t *buf = (const u_int8_t *)packet;
1864 for (i = 0; i < len; i++)
1865 CRC32C(crc32c, buf[i]);
1867 byte0 = crc32c & 0xff;
1868 byte1 = (crc32c>>8) & 0xff;
1869 byte2 = (crc32c>>16) & 0xff;
1870 byte3 = (crc32c>>24) & 0xff;
1871 crc32c = ((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
1872 return htonl(crc32c);
1876 * Subtract 2 timeval structs: out = out - in.
1877 * Out is assumed to be within about LONG_MAX seconds of in.
1880 tvsub(register struct timeval *out, register struct timeval *in)
1883 if ((out->tv_usec -= in->tv_usec) < 0) {
1885 out->tv_usec += 1000000;
1887 out->tv_sec -= in->tv_sec;
1891 * Construct an Internet address representation.
1892 * If the nflag has been supplied, give
1893 * numeric value, otherwise try for symbolic name.
1896 inetname(struct in_addr in)
1899 register struct hostent *hp;
1900 static int first = 1;
1901 static char domain[MAXHOSTNAMELEN + 1], line[MAXHOSTNAMELEN + 1];
1903 if (first && !nflag) {
1905 if (gethostname(domain, sizeof(domain) - 1) < 0)
1908 cp = strchr(domain, '.');
1912 hp = cap_gethostbyname(capdns, domain);
1915 hp = gethostbyname(domain);
1917 cp = strchr(hp->h_name, '.');
1923 (void)strncpy(domain, cp, sizeof(domain) - 1);
1924 domain[sizeof(domain) - 1] = '\0';
1928 if (!nflag && in.s_addr != INADDR_ANY) {
1931 hp = cap_gethostbyaddr(capdns, (char *)&in, sizeof(in),
1935 hp = gethostbyaddr((char *)&in, sizeof(in), AF_INET);
1937 if ((cp = strchr(hp->h_name, '.')) != NULL &&
1938 strcmp(cp + 1, domain) == 0)
1940 (void)strncpy(line, hp->h_name, sizeof(line) - 1);
1941 line[sizeof(line) - 1] = '\0';
1945 return (inet_ntoa(in));
1949 gethostinfo(register char *hostname)
1952 register struct hostent *hp;
1953 register struct hostinfo *hi;
1955 register u_int32_t addr, *ap;
1957 if (strlen(hostname) >= MAXHOSTNAMELEN) {
1958 Fprintf(stderr, "%s: hostname \"%.32s...\" is too long\n",
1962 hi = calloc(1, sizeof(*hi));
1964 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno));
1967 addr = inet_addr(hostname);
1968 if ((int32_t)addr != -1) {
1969 hi->name = strdup(hostname);
1971 hi->addrs = calloc(1, sizeof(hi->addrs[0]));
1972 if (hi->addrs == NULL) {
1973 Fprintf(stderr, "%s: calloc %s\n",
1974 prog, strerror(errno));
1977 hi->addrs[0] = addr;
1983 hp = cap_gethostbyname(capdns, hostname);
1986 hp = gethostbyname(hostname);
1988 Fprintf(stderr, "%s: unknown host %s\n", prog, hostname);
1991 if (hp->h_addrtype != AF_INET || hp->h_length != 4) {
1992 Fprintf(stderr, "%s: bad host %s\n", prog, hostname);
1995 hi->name = strdup(hp->h_name);
1996 for (n = 0, p = hp->h_addr_list; *p != NULL; ++n, ++p)
1999 hi->addrs = calloc(n, sizeof(hi->addrs[0]));
2000 if (hi->addrs == NULL) {
2001 Fprintf(stderr, "%s: calloc %s\n", prog, strerror(errno));
2004 for (ap = hi->addrs, p = hp->h_addr_list; *p != NULL; ++ap, ++p)
2005 memcpy(ap, *p, sizeof(*ap));
2010 freehostinfo(register struct hostinfo *hi)
2012 if (hi->name != NULL) {
2016 free((char *)hi->addrs);
2021 getaddr(register u_int32_t *ap, register char *hostname)
2023 register struct hostinfo *hi;
2025 hi = gethostinfo(hostname);
2031 setsin(register struct sockaddr_in *sin, register u_int32_t addr)
2034 memset(sin, 0, sizeof(*sin));
2035 #ifdef HAVE_SOCKADDR_SA_LEN
2036 sin->sin_len = sizeof(*sin);
2038 sin->sin_family = AF_INET;
2039 sin->sin_addr.s_addr = addr;
2042 /* String to value with optional min and max. Handles decimal and hex. */
2044 str2val(register const char *str, register const char *what,
2045 register int mi, register int ma)
2047 register const char *cp;
2051 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
2053 val = (int)strtol(cp, &ep, 16);
2055 val = (int)strtol(str, &ep, 10);
2057 Fprintf(stderr, "%s: \"%s\" bad value for %s \n",
2061 if (val < mi && mi >= 0) {
2063 Fprintf(stderr, "%s: %s must be >= %d\n",
2066 Fprintf(stderr, "%s: %s must be > %d\n",
2067 prog, what, mi - 1);
2070 if (val > ma && ma >= 0) {
2071 Fprintf(stderr, "%s: %s must be <= %d\n", prog, what, ma);
2078 setproto(char *pname)
2080 struct outproto *proto;
2083 for (i = 0; protos[i].name != NULL; i++) {
2084 if (strcasecmp(protos[i].name, pname) == 0) {
2089 if (proto->name == NULL) { /* generic handler */
2090 struct protoent *pe;
2093 /* Determine the IP protocol number */
2094 if ((pe = getprotobyname(pname)) != NULL)
2097 pnum = str2val(optarg, "proto number", 1, 255);
2104 pkt_compare(const u_char *a, int la, const u_char *b, int lb) {
2108 for (i = 0; i < la; i++)
2109 Printf("%02x", (unsigned int)a[i]);
2111 l = (la <= lb) ? la : lb;
2112 for (i = 0; i < l; i++)
2116 Printf("%02x", (unsigned int)b[i]);
2118 Printf("%02x", (unsigned int)b[i]);
2126 extern char version[];
2128 Fprintf(stderr, "Version %s\n", version);
2130 "Usage: %s [-adDeFInrSvx] [-f first_ttl] [-g gateway] [-i iface]\n"
2131 "\t[-m max_ttl] [-p port] [-P proto] [-q nqueries] [-s src_addr]\n"
2132 "\t[-t tos] [-w waittime] [-A as_server] [-z pausemsecs] host [packetlen]\n", prog);