contrib/traceroute/traceroute.c

   1 /*
   2  * Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * @(#) Copyright (c) 1988, 1989, 1991, 1994, 1995, 1996 The Regents of the University of California.  All rights reserved.
  22  * @(#)$Header: traceroute.c,v 1.43 96/09/27 20:08:10 leres Exp $ (LBL)
  23  * $FreeBSD: src/contrib/traceroute/traceroute.c,v 1.11.2.6 2002/08/05 23:37:16 fenner Exp $
  24  * $DragonFly: src/contrib/traceroute/Attic/traceroute.c,v 1.2 2003/06/17 04:24:07 dillon Exp $
  25  */
  26
  27 /*
  28  * traceroute host  - trace the route ip packets follow going to "host".
  29  *
  30  * Attempt to trace the route an ip packet would follow to some
  31  * internet host.  We find out intermediate hops by launching probe
  32  * packets with a small ttl (time to live) then listening for an
  33  * icmp "time exceeded" reply from a gateway.  We start our probes
  34  * with a ttl of one and increase by one until we get an icmp "port
  35  * unreachable" (which means we got to "host") or hit a max (which
  36  * defaults to net.inet.ip.ttl hops & can be changed with the -m flag).
  37  * Three probes (change with -q flag) are sent at each ttl setting and
  38  * a line is printed showing the ttl, address of the gateway and
  39  * round trip time of each probe.  If the probe answers come from
  40  * different gateways, the address of each responding system will
  41  * be printed.  If there is no response within a 5 sec. timeout
  42  * interval (changed with the -w flag), a "*" is printed for that
  43  * probe.
  44  *
  45  * Probe packets are UDP format.  We don't want the destination
  46  * host to process them so the destination port is set to an
  47  * unlikely value (if some clod on the destination is using that
  48  * value, it can be changed with the -p flag).
  49  *
  50  * A sample use might be:
  51  *
  52  *     [yak 71]% traceroute nis.nsf.net.
  53  *     traceroute to nis.nsf.net (35.1.1.48), 64 hops max, 56 byte packet
  54  *      1  helios.ee.lbl.gov (128.3.112.1)  19 ms  19 ms  0 ms
  55  *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  39 ms  19 ms
  56  *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  39 ms  19 ms
  57  *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  39 ms  40 ms  39 ms
  58  *      5  ccn-nerif22.Berkeley.EDU (128.32.168.22)  39 ms  39 ms  39 ms
  59  *      6  128.32.197.4 (128.32.197.4)  40 ms  59 ms  59 ms
  60  *      7  131.119.2.5 (131.119.2.5)  59 ms  59 ms  59 ms
  61  *      8  129.140.70.13 (129.140.70.13)  99 ms  99 ms  80 ms
  62  *      9  129.140.71.6 (129.140.71.6)  139 ms  239 ms  319 ms
  63  *     10  129.140.81.7 (129.140.81.7)  220 ms  199 ms  199 ms
  64  *     11  nic.merit.edu (35.1.1.48)  239 ms  239 ms  239 ms
  65  *
  66  * Note that lines 2 & 3 are the same.  This is due to a buggy
  67  * kernel on the 2nd hop system -- lbl-csam.arpa -- that forwards
  68  * packets with a zero ttl.
  69  *
  70  * A more interesting example is:
  71  *
  72  *     [yak 72]% traceroute allspice.lcs.mit.edu.
  73  *     traceroute to allspice.lcs.mit.edu (18.26.0.115), 64 hops max
  74  *      1  helios.ee.lbl.gov (128.3.112.1)  0 ms  0 ms  0 ms
  75  *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  19 ms  19 ms  19 ms
  76  *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  19 ms  19 ms
  77  *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  19 ms  39 ms  39 ms
  78  *      5  ccn-nerif22.Berkeley.EDU (128.32.168.22)  20 ms  39 ms  39 ms
  79  *      6  128.32.197.4 (128.32.197.4)  59 ms  119 ms  39 ms
  80  *      7  131.119.2.5 (131.119.2.5)  59 ms  59 ms  39 ms
  81  *      8  129.140.70.13 (129.140.70.13)  80 ms  79 ms  99 ms
  82  *      9  129.140.71.6 (129.140.71.6)  139 ms  139 ms  159 ms
  83  *     10  129.140.81.7 (129.140.81.7)  199 ms  180 ms  300 ms
  84  *     11  129.140.72.17 (129.140.72.17)  300 ms  239 ms  239 ms
  85  *     12  * * *
  86  *     13  128.121.54.72 (128.121.54.72)  259 ms  499 ms  279 ms
  87  *     14  * * *
  88  *     15  * * *
  89  *     16  * * *
  90  *     17  * * *
  91  *     18  ALLSPICE.LCS.MIT.EDU (18.26.0.115)  339 ms  279 ms  279 ms
  92  *
  93  * (I start to see why I'm having so much trouble with mail to
  94  * MIT.)  Note that the gateways 12, 14, 15, 16 & 17 hops away
  95  * either don't send ICMP "time exceeded" messages or send them
  96  * with a ttl too small to reach us.  14 - 17 are running the
  97  * MIT C Gateway code that doesn't send "time exceeded"s.  God
  98  * only knows what's going on with 12.
  99  *
 100  * The silent gateway 12 in the above may be the result of a bug in
 101  * the 4.[23]BSD network code (and its derivatives):  4.x (x <= 3)
 102  * sends an unreachable message using whatever ttl remains in the
 103  * original datagram.  Since, for gateways, the remaining ttl is
 104  * zero, the icmp "time exceeded" is guaranteed to not make it back
 105  * to us.  The behavior of this bug is slightly more interesting
 106  * when it appears on the destination system:
 107  *
 108  *      1  helios.ee.lbl.gov (128.3.112.1)  0 ms  0 ms  0 ms
 109  *      2  lilac-dmc.Berkeley.EDU (128.32.216.1)  39 ms  19 ms  39 ms
 110  *      3  lilac-dmc.Berkeley.EDU (128.32.216.1)  19 ms  39 ms  19 ms
 111  *      4  ccngw-ner-cc.Berkeley.EDU (128.32.136.23)  39 ms  40 ms  19 ms
 112  *      5  ccn-nerif35.Berkeley.EDU (128.32.168.35)  39 ms  39 ms  39 ms
 113  *      6  csgw.Berkeley.EDU (128.32.133.254)  39 ms  59 ms  39 ms
 114  *      7  * * *
 115  *      8  * * *
 116  *      9  * * *
 117  *     10  * * *
 118  *     11  * * *
 119  *     12  * * *
 120  *     13  rip.Berkeley.EDU (128.32.131.22)  59 ms !  39 ms !  39 ms !
 121  *
 122  * Notice that there are 12 "gateways" (13 is the final
 123  * destination) and exactly the last half of them are "missing".
 124  * What's really happening is that rip (a Sun-3 running Sun OS3.5)
 125  * is using the ttl from our arriving datagram as the ttl in its
 126  * icmp reply.  So, the reply will time out on the return path
 127  * (with no notice sent to anyone since icmp's aren't sent for
 128  * icmp's) until we probe with a ttl that's at least twice the path
 129  * length.  I.e., rip is really only 7 hops away.  A reply that
 130  * returns with a ttl of 1 is a clue this problem exists.
 131  * Traceroute prints a "!" after the time if the ttl is <= 1.
 132  * Since vendors ship a lot of obsolete (DEC's Ultrix, Sun 3.x) or
 133  * non-standard (HPUX) software, expect to see this problem
 134  * frequently and/or take care picking the target host of your
 135  * probes.
 136  *
 137  * Other possible annotations after the time are !H, !N, !P (got a host,
 138  * network or protocol unreachable, respectively), !S or !F (source
 139  * route failed or fragmentation needed -- neither of these should
 140  * ever occur and the associated gateway is busted if you see one).  If
 141  * almost all the probes result in some kind of unreachable, traceroute
 142  * will give up and exit.
 143  *
 144  * Notes
 145  * -----
 146  * This program must be run by root or be setuid.  (I suggest that
 147  * you *don't* make it setuid -- casual use could result in a lot
 148  * of unnecessary traffic on our poor, congested nets.)
 149  *
 150  * This program requires a kernel mod that does not appear in any
 151  * system available from Berkeley:  A raw ip socket using proto
 152  * IPPROTO_RAW must interpret the data sent as an ip datagram (as
 153  * opposed to data to be wrapped in a ip datagram).  See the README
 154  * file that came with the source to this program for a description
 155  * of the mods I made to /sys/netinet/raw_ip.c.  Your mileage may
 156  * vary.  But, again, ANY 4.x (x < 4) BSD KERNEL WILL HAVE TO BE
 157  * MODIFIED TO RUN THIS PROGRAM.
 158  *
 159  * The udp port usage may appear bizarre (well, ok, it is bizarre).
 160  * The problem is that an icmp message only contains 8 bytes of
 161  * data from the original datagram.  8 bytes is the size of a udp
 162  * header so, if we want to associate replies with the original
 163  * datagram, the necessary information must be encoded into the
 164  * udp header (the ip id could be used but there's no way to
 165  * interlock with the kernel's assignment of ip id's and, anyway,
 166  * it would have taken a lot more kernel hacking to allow this
 167  * code to set the ip id).  So, to allow two or more users to
 168  * use traceroute simultaneously, we use this task's pid as the
 169  * source port (the high bit is set to move the port number out
 170  * of the "likely" range).  To keep track of which probe is being
 171  * replied to (so times and/or hop counts don't get confused by a
 172  * reply that was delayed in transit), we increment the destination
 173  * port number before each probe.
 174  *
 175  * Don't use this as a coding example.  I was trying to find a
 176  * routing problem and this code sort-of popped out after 48 hours
 177  * without sleep.  I was amazed it ever compiled, much less ran.
 178  *
 179  * I stole the idea for this program from Steve Deering.  Since
 180  * the first release, I've learned that had I attended the right
 181  * IETF working group meetings, I also could have stolen it from Guy
 182  * Almes or Matt Mathis.  I don't know (or care) who came up with
 183  * the idea first.  I envy the originators' perspicacity and I'm
 184  * glad they didn't keep the idea a secret.
 185  *
 186  * Tim Seaver, Ken Adelman and C. Philip Wood provided bug fixes and/or
 187  * enhancements to the original distribution.
 188  *
 189  * I've hacked up a round-trip-route version of this that works by
 190  * sending a loose-source-routed udp datagram through the destination
 191  * back to yourself.  Unfortunately, SO many gateways botch source
 192  * routing, the thing is almost worthless.  Maybe one day...
 193  *
 194  *  -- Van Jacobson (van@ee.lbl.gov)
 195  *     Tue Dec 20 03:50:13 PST 1988
 196  */
 197
 198 #include <sys/param.h>
 199 #include <sys/file.h>
 200 #include <sys/ioctl.h>
 201 #ifdef HAVE_SYS_SELECT_H
 202 #include <sys/select.h>
 203 #endif
 204 #include <sys/socket.h>
 205 #ifdef HAVE_SYS_SYSCTL_H
 206 #include <sys/sysctl.h>
 207 #endif
 208 #include <sys/time.h>
 209
 210 #include <netinet/in_systm.h>
 211 #include <netinet/in.h>
 212 #include <netinet/ip.h>
 213 #include <netinet/ip_var.h>
 214 #include <netinet/ip_icmp.h>
 215 #include <netinet/udp.h>
 216 #include <netinet/tcp.h>
 217
 218 #include <arpa/inet.h>
 219
 220 #ifdef  IPSEC
 221 #include <net/route.h>
 222 #include <netinet6/ipsec.h>     /* XXX */
 223 #endif  /* IPSEC */
 224
 225 #include <ctype.h>
 226 #include <errno.h>
 227 #ifdef HAVE_MALLOC_H
 228 #include <malloc.h>
 229 #endif
 230 #include <memory.h>
 231 #include <netdb.h>
 232 #include <stdio.h>
 233 #include <stdlib.h>
 234 #include <string.h>
 235 #include <unistd.h>
 236
 237 #include "gnuc.h"
 238 #ifdef HAVE_OS_PROTO_H
 239 #include "os-proto.h"
 240 #endif
 241
 242 /* Maximum number of gateways (include room for one noop) */
 243 #define NGATEWAYS ((int)((MAX_IPOPTLEN - IPOPT_MINOFF - 1) / sizeof(u_int32_t)))
 244
 245 #ifndef MAXHOSTNAMELEN
 246 #define MAXHOSTNAMELEN  64
 247 #endif
 248
 249 #define Fprintf (void)fprintf
 250 #define Printf (void)printf
 251
 252 /* What a GRE packet header looks like */
 253 struct grehdr {
 254         u_int16_t   flags;
 255         u_int16_t   proto;
 256         u_int16_t   length;     /* PPTP version of these fields */
 257         u_int16_t   callId;
 258 };
 259 #ifndef IPPROTO_GRE
 260 #define IPPROTO_GRE     47
 261 #endif
 262
 263 /* For GRE, we prepare what looks like a PPTP packet */
 264 #define GRE_PPTP_PROTO  0x880b
 265
 266 /* Data section of the probe packet */
 267 struct outdata {
 268         u_char seq;             /* sequence number of this packet */
 269         u_char ttl;             /* ttl packet left with */
 270         struct timeval tv;      /* time packet left */
 271         int    optlen;          /* length of ip options */
 272 };
 273
 274 /* Descriptor structure for each outgoing protocol we support */
 275 struct outproto {
 276         char    *name;          /* name of protocol */
 277         u_char  num;            /* IP protocol number */
 278         u_short hdrlen;         /* max size of protocol header */
 279         u_short port;           /* default base protocol-specific "port" */
 280         void    (*prepare)(struct outdata *);
 281                                 /* finish preparing an outgoing packet */
 282         int     (*check)(const u_char *, int);
 283                                 /* check an incoming packet */
 284 };
 285
 286 u_char  packet[512];            /* last inbound (icmp) packet */
 287
 288 struct ip *outip;               /* last output ip packet */
 289 u_char *outprot;                /* last output inner protocol packet */
 290
 291 /* loose source route gateway list (including room for final destination) */
 292 u_int32_t gwlist[NGATEWAYS + 1];
 293
 294 int s;                          /* receive (icmp) socket file descriptor */
 295 int sndsock;                    /* send (udp) socket file descriptor */
 296
 297 struct sockaddr whereto;        /* Who to try to reach */
 298 int packlen;                    /* total length of packet */
 299 int protlen;                    /* length of protocol part of packet */
 300 int maxpacket = 32 * 1024;      /* max ip packet size */
 301
 302 char *prog;
 303 char *source;
 304 char *hostname;
 305
 306 int nprobes = 3;
 307 int min_ttl = 1;
 308 int max_ttl;
 309 u_short ident;
 310 u_short port;                   /* protocol specific base "port" */
 311
 312 int options;                    /* socket options */
 313 int verbose;
 314 int waittime = 5;               /* time to wait for response (in seconds) */
 315 int nflag;                      /* print addresses numerically */
 316
 317 extern int optind;
 318 extern int opterr;
 319 extern char *optarg;
 320
 321 /* Forwards */
 322 double  deltaT(struct timeval *, struct timeval *);
 323 u_short in_cksum(u_short *, int);
 324 char    *inetname(struct in_addr);
 325 int     main(int, char **);
 326 int     packet_ok(u_char *, int, struct sockaddr_in *, int);
 327 char    *pr_type(u_char);
 328 void    print(u_char *, int, struct sockaddr_in *);
 329 char    *getaddr(u_int32_t *, char *);
 330 char    *getsin(struct sockaddr_in *, char *);
 331 char    *savestr(const char *);
 332 #ifdef  IPSEC
 333 int     setpolicy __P((int so, char *policy));
 334 #endif
 335 void    send_probe(int, int);
 336 void    tvsub(struct timeval *, struct timeval *);
 337 __dead  void usage(void);
 338 int     wait_for_reply(int, struct sockaddr_in *, struct timeval *);
 339
 340 void    udp_prep(struct outdata *);
 341 int     udp_check(const u_char *, int);
 342 void    tcp_prep(struct outdata *);
 343 int     tcp_check(const u_char *, int);
 344 void    gre_prep(struct outdata *);
 345 int     gre_check(const u_char *, int);
 346 void    gen_prep(struct outdata *);
 347 int     gen_check(const u_char *, int);
 348 void    icmp_prep(struct outdata *);
 349 int     icmp_check(const u_char *, int);
 350
 351 /* List of supported protocols. The first one is the default. The last
 352    one is the handler for generic protocols not explicitly listed. */
 353 struct  outproto protos[] = {
 354         {
 355                 "udp",
 356                 IPPROTO_UDP,
 357                 sizeof(struct udphdr),
 358                 32768 + 666,
 359                 udp_prep,
 360                 udp_check
 361         },
 362         {
 363                 "tcp",
 364                 IPPROTO_TCP,
 365                 sizeof(struct tcphdr),
 366                 32768 + 666,
 367                 tcp_prep,
 368                 tcp_check
 369         },
 370         {
 371                 "gre",
 372                 IPPROTO_GRE,
 373                 sizeof(struct grehdr),
 374                 GRE_PPTP_PROTO,
 375                 gre_prep,
 376                 gre_check
 377         },
 378         {
 379                 "icmp",
 380                 IPPROTO_ICMP,
 381                 sizeof(struct icmp),
 382                 0,
 383                 icmp_prep,
 384                 icmp_check
 385         },
 386         {
 387                 NULL,
 388                 0,
 389                 2 * sizeof(u_short),
 390                 0,
 391                 gen_prep,
 392                 gen_check
 393         },
 394 };
 395 struct  outproto *proto = &protos[0];
 396
 397 int
 398 main(int argc, char **argv)
 399 {
 400         register int op, code;
 401         register char *cp;
 402         struct sockaddr_in from;
 403         register struct sockaddr_in *to = (struct sockaddr_in *)&whereto;
 404         int on = 1;
 405         register struct protoent *pe;
 406         register int ttl, probe, i;
 407         register int seq = 0;
 408         register int tos = 0;
 409         register int lsrr = 0;
 410         register int optlen = 0;
 411         int requestPort = -1;
 412         int sump = 0;
 413         int sockerrno;
 414
 415         /*
 416          * Do the setuid-required stuff first, then lose priveleges ASAP.
 417          * Do error checking for these two calls where they appeared in
 418          * the original code.
 419          */
 420         cp = "icmp";
 421         pe = getprotobyname(cp);
 422         if (pe) {
 423                 if ((s = socket(AF_INET, SOCK_RAW, pe->p_proto)) < 0)
 424                         sockerrno = errno;
 425                 else if ((sndsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
 426                         sockerrno = errno;
 427         }
 428
 429         setuid(getuid());
 430
 431 #ifdef IPCTL_DEFTTL
 432         {
 433                 int mib[4] = { CTL_NET, PF_INET, IPPROTO_IP, IPCTL_DEFTTL };
 434                 size_t sz = sizeof(max_ttl);
 435
 436                 if (sysctl(mib, 4, &max_ttl, &sz, NULL, 0) == -1)
 437                         err(1, "sysctl(net.inet.ip.ttl)");
 438         }
 439 #else
 440         max_ttl = 30;
 441 #endif
 442
 443         if ((cp = strrchr(argv[0], '/')) != NULL)
 444                 prog = cp + 1;
 445         else
 446                 prog = argv[0];
 447
 448         opterr = 0;
 449         while ((op = getopt(argc, argv, "Sdnrvg:M:m:P:p:q:s:t:w:")) != EOF)
 450                 switch (op) {
 451
 452                 case 'S':
 453                         sump = 1;
 454                         break;
 455                 case 'd':
 456                         options |= SO_DEBUG;
 457                         break;
 458
 459                 case 'g':
 460                         if (lsrr >= NGATEWAYS) {
 461                                 Fprintf(stderr,
 462                                     "%s: No more than %d gateways\n",
 463                                     prog, NGATEWAYS);
 464                                 exit(1);
 465                         }
 466                         (void)getaddr(gwlist + lsrr, optarg);
 467                         ++lsrr;
 468                         break;
 469
 470                 case 'M':
 471                         min_ttl = atoi(optarg);
 472                         if (min_ttl < 1 || min_ttl > 0xff) {
 473                                 Fprintf(stderr, "%s: invalid ttl value %s\n",
 474                                     prog, optarg);
 475                                 exit(1);
 476                         }
 477                         break;
 478
 479                 case 'm':
 480                         max_ttl = atoi(optarg);
 481                         if (max_ttl < 1 || max_ttl > 0xff) {
 482                                 Fprintf(stderr, "%s: invalid ttl value %s\n",
 483                                     prog, optarg);
 484                                 exit(1);
 485                         }
 486                         break;
 487
 488                 case 'n':
 489                         ++nflag;
 490                         break;
 491
 492                 case 'P':
 493                         for (i = 0; protos[i].name != NULL; i++) {
 494                                 if (strcasecmp(protos[i].name, optarg) == 0) {
 495                                         break;
 496                                 }
 497                         }
 498                         proto = &protos[i];
 499                         if (proto->name == NULL) {      /* generic handler */
 500                                 struct protoent *pe;
 501                                 u_long pnum;
 502                                 char *eptr;
 503
 504                                 /* Determine the IP protocol number */
 505                                 if ((pe = getprotobyname(optarg)) != NULL)
 506                                         pnum = pe->p_proto;
 507                                 else {
 508                                         pnum = strtoul(optarg, &eptr, 10);
 509                                         if (pnum > 0xff
 510                                             || *optarg == '\0'
 511                                             || *eptr != '\0') {
 512                                                 Fprintf(stderr, "%s: unknown "
 513                                                     "protocol \"%s\"\n",
 514                                                     prog, optarg);
 515                                                 exit(1);
 516                                         }
 517                                 }
 518                                 proto->num = pnum;
 519                         }
 520                         break;
 521
 522                 case 'p':
 523                         requestPort = atoi(optarg);
 524                         if (requestPort <= 0) {
 525                                 Fprintf(stderr, "%s: port must be > 0\n", prog);
 526                                 exit(1);
 527                         }
 528                         break;
 529
 530                 case 'q':
 531                         nprobes = atoi(optarg);
 532                         if (nprobes <= 0) {
 533                                 Fprintf(stderr, "%s: nprobes must be > 0\n",
 534                                     prog);
 535                                 exit(1);
 536                         }
 537                         break;
 538
 539                 case 'r':
 540                         options |= SO_DONTROUTE;
 541                         break;
 542
 543                 case 's':
 544                         /*
 545                          * set the ip source address of the outbound
 546                          * probe (e.g., on a multi-homed host).
 547                          */
 548                         source = optarg;
 549                         break;
 550
 551                 case 't':
 552                         tos = atoi(optarg);
 553                         if (tos < 0 || tos > 255) {
 554                                 Fprintf(stderr, "%s: tos must be 0 to 255\n",
 555                                     prog);
 556                                 exit(1);
 557                         }
 558                         break;
 559
 560                 case 'v':
 561                         ++verbose;
 562                         break;
 563
 564                 case 'w':
 565                         waittime = atoi(optarg);
 566                         if (waittime <= 1 || waittime >= 24L * 60 * 60) {
 567                                 Fprintf(stderr,
 568                                     "%s: wait must be > 1 sec and < 1 day\n",
 569                                     prog);
 570                                 exit(1);
 571                         }
 572                         break;
 573
 574                 default:
 575                         usage();
 576                 }
 577
 578         /* Set requested port, if any, else default for this protocol */
 579         port = (requestPort != -1) ? requestPort : proto->port;
 580
 581         /* Check min vs. max TTL */
 582         if (min_ttl > max_ttl) {
 583                 Fprintf(stderr, "%s: min ttl must be <= max ttl\n", prog);
 584                 exit(1);
 585         }
 586
 587         /* Process destination and optional packet size */
 588         switch (argc - optind) {
 589
 590         case 2:
 591                 packlen = atoi(argv[optind + 1]);
 592                 /* Fall thorugh */
 593
 594         case 1:
 595                 hostname = savestr(getsin(to, argv[optind]));
 596                 break;
 597
 598         default:
 599                 usage();
 600         }
 601
 602 #ifdef HAVE_SETLINEBUF
 603         setlinebuf (stdout);
 604 #else
 605         setvbuf(stdout, NULL, _IOLBF, 0);
 606 #endif
 607
 608         if (lsrr > 0)
 609                 optlen = (lsrr + 1) * sizeof(gwlist[0]);
 610         i = sizeof(*outip) + proto->hdrlen + sizeof(struct outdata) + optlen;
 611         if (packlen == 0)
 612                 packlen = i;                    /* minimum sized packet */
 613         else if (i > packlen || packlen > maxpacket) {
 614                 Fprintf(stderr, "%s: packet size must be %d <= s <= %d\n",
 615                     prog, i, maxpacket);
 616                 exit(1);
 617         }
 618         protlen = packlen - sizeof(*outip) - optlen;
 619
 620         outip = (struct ip *)malloc((unsigned)packlen);
 621         if (outip == NULL) {
 622                 Fprintf(stderr, "%s: malloc: %s\n", prog, strerror(errno));
 623                 exit(1);
 624         }
 625         memset((char *)outip, 0, packlen);
 626
 627         outip->ip_v = IPVERSION;
 628         outip->ip_tos = tos;
 629 #ifdef BYTESWAP_IP_LEN
 630         outip->ip_len = htons(packlen);
 631 #else
 632         outip->ip_len = packlen;
 633 #endif
 634         outip->ip_p = proto->num;
 635         outprot = (u_char *)(outip + 1);
 636 #ifdef HAVE_RAW_OPTIONS
 637         if (lsrr > 0) {
 638                 register u_char *optlist;
 639
 640                 optlist = (u_char *)outprot;
 641                 (u_char *)outprot += optlen;
 642
 643                 /* final hop */
 644                 gwlist[lsrr] = to->sin_addr.s_addr;
 645
 646                 outip->ip_dst.s_addr = gwlist[0];
 647
 648                 /* force 4 byte alignment */
 649                 optlist[0] = IPOPT_NOP;
 650                 /* loose source route option */
 651                 optlist[1] = IPOPT_LSRR;
 652                 i = lsrr * sizeof(gwlist[0]);
 653                 optlist[2] = i + 3;
 654                 /* Pointer to LSRR addresses */
 655                 optlist[3] = IPOPT_MINOFF;
 656                 memcpy(optlist + 4, gwlist + 1, i);
 657         } else
 658 #endif
 659                 outip->ip_dst = to->sin_addr;
 660
 661         outip->ip_hl = ((u_char *)outprot - (u_char *)outip) >> 2;
 662
 663         ident = (getpid() & 0xffff) | 0x8000;
 664
 665         if (pe == NULL) {
 666                 Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp);
 667                 exit(1);
 668         }
 669         if (s < 0) {
 670                 errno = sockerrno;
 671                 Fprintf(stderr, "%s: icmp socket: %s\n", prog, strerror(errno));
 672                 exit(1);
 673         }
 674         if (options & SO_DEBUG)
 675                 (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&on,
 676                     sizeof(on));
 677         if (options & SO_DONTROUTE)
 678                 (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
 679                     sizeof(on));
 680
 681 #if     defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
 682         if (setpolicy(s, "in bypass") < 0)
 683                 errx(1, "%s", ipsec_strerror());
 684
 685         if (setpolicy(s, "out bypass") < 0)
 686                 errx(1, "%s", ipsec_strerror());
 687 #endif  /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
 688
 689         if (sndsock < 0) {
 690                 errno = sockerrno;
 691                 Fprintf(stderr, "%s: raw socket: %s\n", prog, strerror(errno));
 692                 exit(1);
 693         }
 694
 695 #if defined(IP_OPTIONS) && !defined(HAVE_RAW_OPTIONS)
 696         if (lsrr > 0) {
 697                 u_char optlist[MAX_IPOPTLEN];
 698
 699                 cp = "ip";
 700                 if ((pe = getprotobyname(cp)) == NULL) {
 701                         Fprintf(stderr, "%s: unknown protocol %s\n", prog, cp);
 702                         exit(1);
 703                 }
 704
 705                 /* final hop */
 706                 gwlist[lsrr] = to->sin_addr.s_addr;
 707                 ++lsrr;
 708
 709                 /* force 4 byte alignment */
 710                 optlist[0] = IPOPT_NOP;
 711                 /* loose source route option */
 712                 optlist[1] = IPOPT_LSRR;
 713                 i = lsrr * sizeof(gwlist[0]);
 714                 optlist[2] = i + 3;
 715                 /* Pointer to LSRR addresses */
 716                 optlist[3] = IPOPT_MINOFF;
 717                 memcpy(optlist + 4, gwlist, i);
 718
 719                 if ((setsockopt(sndsock, pe->p_proto, IP_OPTIONS, optlist,
 720                     i + sizeof(gwlist[0]))) < 0) {
 721                         Fprintf(stderr, "%s: IP_OPTIONS: %s\n",
 722                             prog, strerror(errno));
 723                         exit(1);
 724                     }
 725         }
 726 #endif
 727
 728 #ifdef SO_SNDBUF
 729         if (setsockopt(sndsock, SOL_SOCKET, SO_SNDBUF, (char *)&packlen,
 730             sizeof(packlen)) < 0) {
 731                 Fprintf(stderr, "%s: SO_SNDBUF: %s\n", prog, strerror(errno));
 732                 exit(1);
 733         }
 734 #endif
 735 #ifdef IP_HDRINCL
 736         if (setsockopt(sndsock, IPPROTO_IP, IP_HDRINCL, (char *)&on,
 737             sizeof(on)) < 0) {
 738                 Fprintf(stderr, "%s: IP_HDRINCL: %s\n", prog, strerror(errno));
 739                 exit(1);
 740         }
 741 #endif
 742         if (options & SO_DEBUG)
 743                 (void)setsockopt(sndsock, SOL_SOCKET, SO_DEBUG, (char *)&on,
 744                     sizeof(on));
 745         if (options & SO_DONTROUTE)
 746                 (void)setsockopt(sndsock, SOL_SOCKET, SO_DONTROUTE, (char *)&on,
 747                     sizeof(on));
 748
 749         if (source != NULL) {
 750                 source = savestr(getsin(&from, source));
 751                 outip->ip_src = from.sin_addr;
 752 #ifndef IP_HDRINCL
 753                 if (bind(sndsock, (struct sockaddr *)&from, sizeof(from)) < 0) {
 754                         Fprintf(stderr, "%s: bind: %s\n",
 755                             prog, strerror(errno));
 756                         exit (1);
 757                 }
 758 #endif
 759         }
 760
 761 #if     defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
 762         if (setpolicy(sndsock, "in bypass") < 0)
 763                 errx(1, "%s", ipsec_strerror());
 764
 765         if (setpolicy(sndsock, "out bypass") < 0)
 766                 errx(1, "%s", ipsec_strerror());
 767 #endif  /* defined(IPSEC) && defined(IPSEC_POLICY_IPSEC) */
 768
 769         Fprintf(stderr, "%s to %s (%s)",
 770             prog, hostname, inet_ntoa(to->sin_addr));
 771         if (source)
 772                 Fprintf(stderr, " from %s", source);
 773         Fprintf(stderr, ", %d hops max, %d byte packets\n", max_ttl, packlen);
 774         (void)fflush(stderr);
 775
 776         for (ttl = min_ttl; ttl <= max_ttl; ++ttl) {
 777                 u_int32_t lastaddr = 0;
 778                 int got_there = 0;
 779                 int unreachable = 0;
 780                 int loss;
 781
 782                 Printf("%2d ", ttl);
 783                 for (probe = 0, loss = 0; probe < nprobes; ++probe) {
 784                         register int cc;
 785                         struct timeval t1, t2;
 786                         struct timezone tz;
 787                         register struct ip *ip;
 788                         struct outdata outdata;
 789
 790                         /* Prepare outgoing data */
 791                         outdata.seq = ++seq;
 792                         outdata.ttl = ttl;
 793                         outdata.optlen = optlen;
 794
 795                         /* Avoid alignment problems by copying bytewise: */
 796                         (void)gettimeofday(&t1, &tz);
 797                         memcpy(&outdata.tv, &t1, sizeof(outdata.tv));
 798
 799                         /* Finalize and send packet */
 800                         (*proto->prepare)(&outdata);
 801                         send_probe(seq, ttl);
 802
 803                         /* Wait for a reply */
 804                         while ((cc = wait_for_reply(s, &from, &t1)) != 0) {
 805                                 double T;
 806                                 int precis;
 807
 808                                 (void)gettimeofday(&t2, &tz);
 809                                 i = packet_ok(packet, cc, &from, seq);
 810                                 /* Skip short packet */
 811                                 if (i == 0)
 812                                         continue;
 813                                 if (from.sin_addr.s_addr != lastaddr) {
 814                                         print(packet, cc, &from);
 815                                         lastaddr = from.sin_addr.s_addr;
 816                                 }
 817                                 T = deltaT(&t1, &t2);
 818 #ifdef SANE_PRECISION
 819                                 if (T >= 1000.0)
 820                                         precis = 0;
 821                                 else if (T >= 100.0)
 822                                         precis = 1;
 823                                 else if (T >= 10.0)
 824                                         precis = 2;
 825                                 else
 826 #endif
 827                                         precis = 3;
 828                                 Printf("  %.*f ms", precis, T);
 829                                 if (i == -2) {
 830 #ifndef ARCHAIC
 831                                         ip = (struct ip *)packet;
 832                                         if (ip->ip_ttl <= 1)
 833                                                 Printf(" !");
 834 #endif
 835
 836                                         ++got_there;
 837                                         break;
 838                                 }
 839
 840                                 /* time exceeded in transit */
 841                                 if (i == -1)
 842                                         break;
 843
 844                                 code = i - 1;
 845                                 switch (code) {
 846
 847                                 case ICMP_UNREACH_PORT:
 848 #ifndef ARCHAIC
 849                                         ip = (struct ip *)packet;
 850                                         if (ip->ip_ttl <= 1)
 851                                                 Printf(" !");
 852 #endif
 853                                         ++got_there;
 854                                         break;
 855
 856                                 case ICMP_UNREACH_NET:
 857                                         ++unreachable;
 858                                         Printf(" !N");
 859                                         break;
 860
 861                                 case ICMP_UNREACH_HOST:
 862                                         ++unreachable;
 863                                         Printf(" !H");
 864                                         break;
 865
 866                                 case ICMP_UNREACH_PROTOCOL:
 867                                         ++got_there;
 868                                         Printf(" !P");
 869                                         break;
 870
 871                                 case ICMP_UNREACH_NEEDFRAG:
 872                                         ++unreachable;
 873                                         Printf(" !F");
 874                                         break;
 875
 876                                 case ICMP_UNREACH_SRCFAIL:
 877                                         ++unreachable;
 878                                         Printf(" !S");
 879                                         break;
 880
 881 /* rfc1716 */
 882 #ifndef ICMP_UNREACH_FILTER_PROHIB
 883 #define ICMP_UNREACH_FILTER_PROHIB      13      /* admin prohibited filter */
 884 #endif
 885                                 case ICMP_UNREACH_FILTER_PROHIB:
 886                                         ++unreachable;
 887                                         Printf(" !X");
 888                                         break;
 889
 890                                 default:
 891                                         ++unreachable;
 892                                         Printf(" !<%d>", code);
 893                                         break;
 894                                 }
 895                                 break;
 896                         }
 897                         if (cc == 0) {
 898                                 loss++;
 899                                 Printf(" *");
 900                         }
 901                         (void)fflush(stdout);
 902                 }
 903                 if (sump) {
 904                         Printf(" (%d%% loss)", (loss * 100) / nprobes);
 905                 }
 906                 putchar('\n');
 907                 if (got_there ||
 908                     (unreachable > 0 && unreachable >= nprobes - 1))
 909                         break;
 910         }
 911         exit(0);
 912 }
 913
 914 int
 915 wait_for_reply(register int sock, register struct sockaddr_in *fromp,
 916     register struct timeval *tp)
 917 {
 918         fd_set *fdsp;
 919         size_t nfds;
 920         struct timeval now, wait;
 921         struct timezone tz;
 922         register int cc = 0;
 923         register int error;
 924         int fromlen = sizeof(*fromp);
 925
 926         nfds = howmany(sock + 1, NFDBITS);
 927         if ((fdsp = malloc(nfds * sizeof(fd_mask))) == NULL)
 928                 err(1, "malloc");
 929         memset(fdsp, 0, nfds * sizeof(fd_mask));
 930         FD_SET(sock, fdsp);
 931
 932         wait.tv_sec = tp->tv_sec + waittime;
 933         wait.tv_usec = tp->tv_usec;
 934         (void)gettimeofday(&now, &tz);
 935         tvsub(&wait, &now);
 936         if (wait.tv_sec < 0) {
 937                 wait.tv_sec = 0;
 938                 wait.tv_usec = 1;
 939         }
 940
 941         error = select(sock + 1, fdsp, NULL, NULL, &wait);
 942         if (error == -1 && errno == EINVAL) {
 943                 Fprintf(stderr, "%s: botched select() args\n", prog);
 944                 exit(1);
 945         }
 946         if (error > 0)
 947                 cc = recvfrom(s, (char *)packet, sizeof(packet), 0,
 948                             (struct sockaddr *)fromp, &fromlen);
 949
 950         free(fdsp);
 951         return(cc);
 952 }
 953
 954 #if     defined(IPSEC) && defined(IPSEC_POLICY_IPSEC)
 955 int
 956 setpolicy(so, policy)
 957         int so;
 958         char *policy;
 959 {
 960         char *buf;
 961
 962         buf = ipsec_set_policy(policy, strlen(policy));
 963         if (buf == NULL) {
 964                 warnx("%s", ipsec_strerror());
 965                 return -1;
 966         }
 967         (void)setsockopt(so, IPPROTO_IP, IP_IPSEC_POLICY,
 968                 buf, ipsec_get_policylen(buf));
 969
 970         free(buf);
 971
 972         return 0;
 973 }
 974 #endif
 975
 976 void
 977 send_probe(int seq, int ttl)
 978 {
 979         register int i;
 980
 981         outip->ip_ttl = ttl;
 982         outip->ip_id = htons(ident + seq);
 983
 984         i = sendto(sndsock, (char *)outip, packlen, 0, &whereto,
 985                    sizeof(whereto));
 986         if (i < 0 || i != packlen)  {
 987                 if (i < 0)
 988                         Fprintf(stderr, "%s: sendto: %s\n",
 989                             prog, strerror(errno));
 990                 Printf("%s: wrote %s %d chars, ret=%d\n",
 991                     prog, hostname, packlen, i);
 992                 (void)fflush(stdout);
 993         }
 994 }
 995
 996 double
 997 deltaT(struct timeval *t1p, struct timeval *t2p)
 998 {
 999         register double dt;
1000
1001         dt = (double)(t2p->tv_sec - t1p->tv_sec) * 1000.0 +
1002              (double)(t2p->tv_usec - t1p->tv_usec) / 1000.0;
1003         return (dt);
1004 }
1005
1006 /*
1007  * Convert an ICMP "type" field to a printable string.
1008  */
1009 char *
1010 pr_type(register u_char t)
1011 {
1012         static char *ttab[] = {
1013         "Echo Reply",   "ICMP 1",       "ICMP 2",       "Dest Unreachable",
1014         "Source Quench", "Redirect",    "ICMP 6",       "ICMP 7",
1015         "Echo",         "ICMP 9",       "ICMP 10",      "Time Exceeded",
1016         "Param Problem", "Timestamp",   "Timestamp Reply", "Info Request",
1017         "Info Reply"
1018         };
1019
1020         if (t > 16)
1021                 return("OUT-OF-RANGE");
1022
1023         return(ttab[t]);
1024 }
1025
1026 int
1027 packet_ok(register u_char *buf, int cc, register struct sockaddr_in *from,
1028     register int seq)
1029 {
1030         register struct icmp *icp;
1031         register u_char type, code;
1032         register int hlen;
1033 #ifndef ARCHAIC
1034         register struct ip *ip;
1035
1036         ip = (struct ip *) buf;
1037         hlen = ip->ip_hl << 2;
1038         if (cc < hlen + ICMP_MINLEN) {
1039                 if (verbose)
1040                         Printf("packet too short (%d bytes) from %s\n", cc,
1041                                 inet_ntoa(from->sin_addr));
1042                 return (0);
1043         }
1044         cc -= hlen;
1045         icp = (struct icmp *)(buf + hlen);
1046 #else
1047         icp = (struct icmp *)buf;
1048 #endif
1049         type = icp->icmp_type;
1050         code = icp->icmp_code;
1051         if (type == ICMP_ECHOREPLY
1052             && proto->num == IPPROTO_ICMP
1053             && (*proto->check)((u_char *)icp,seq))
1054                 return -2;
1055         if ((type == ICMP_TIMXCEED && code == ICMP_TIMXCEED_INTRANS) ||
1056             type == ICMP_UNREACH) {
1057                 struct ip *hip;
1058                 u_char *inner;
1059
1060                 hip = &icp->icmp_ip;
1061                 hlen = hip->ip_hl << 2;
1062                 inner = (u_char *)((u_char *)hip + hlen);
1063                 if (hlen + 12 <= cc
1064                     && hip->ip_p == proto->num
1065                     && (*proto->check)(inner, seq))
1066                         return (type == ICMP_TIMXCEED ? -1 : code + 1);
1067         }
1068 #ifndef ARCHAIC
1069         if (verbose) {
1070                 register int i;
1071                 u_int32_t *lp = (u_int32_t *)&icp->icmp_ip;
1072
1073                 Printf("\n%d bytes from %s to ", cc, inet_ntoa(from->sin_addr));
1074                 Printf("%s: icmp type %d (%s) code %d\n",
1075                     inet_ntoa(ip->ip_dst), type, pr_type(type), icp->icmp_code);
1076                 for (i = 4; i < cc ; i += sizeof(*lp))
1077                         Printf("%2d: x%8.8x\n", i, *lp++);
1078         }
1079 #endif
1080         return(0);
1081 }
1082
1083 void
1084 icmp_prep(struct outdata *outdata)
1085 {
1086         struct icmp *const icmpheader = (struct icmp *) outprot;
1087
1088         icmpheader->icmp_type = ICMP_ECHO;
1089         icmpheader->icmp_id = htons(ident);
1090         icmpheader->icmp_seq = htons(outdata->seq);
1091
1092         icmpheader->icmp_cksum = 0;
1093         icmpheader->icmp_cksum = in_cksum((u_short *)icmpheader,
1094             packlen - (sizeof(*outip) + outdata->optlen));
1095         if (icmpheader->icmp_cksum == 0)
1096                 icmpheader->icmp_cksum = 0xffff;
1097
1098 }
1099
1100 int
1101 icmp_check(const u_char *data, int seq)
1102 {
1103         struct icmp *const icmpheader = (struct icmp *) data;
1104
1105         return (icmpheader->icmp_id == htons(ident)
1106             && icmpheader->icmp_seq == htons(seq));
1107 }
1108
1109 void
1110 udp_prep(struct outdata *outdata)
1111 {
1112         struct udphdr *const udp = (struct udphdr *) outprot;
1113
1114         udp->uh_sport = htons(ident);
1115         udp->uh_dport = htons(port + outdata->seq);
1116         udp->uh_ulen = htons((u_short)protlen);
1117 }
1118
1119 int
1120 udp_check(const u_char *data, int seq)
1121 {
1122         struct udphdr *const udp = (struct udphdr *) data;
1123
1124         return (ntohs(udp->uh_sport) == ident
1125             && ntohs(udp->uh_dport) == port + seq);
1126 }
1127
1128 void
1129 tcp_prep(struct outdata *outdata)
1130 {
1131         struct tcphdr *const tcp = (struct tcphdr *) outprot;
1132
1133         tcp->th_sport = htons(ident);
1134         tcp->th_dport = htons(port + outdata->seq);
1135         tcp->th_seq = (tcp->th_sport << 16) | tcp->th_dport;
1136         tcp->th_ack = 0;
1137         tcp->th_off = 5;
1138         tcp->th_flags = TH_SYN;
1139 }
1140
1141 int
1142 tcp_check(const u_char *data, int seq)
1143 {
1144         struct tcphdr *const tcp = (struct tcphdr *) data;
1145
1146         return (ntohs(tcp->th_sport) == ident
1147             && ntohs(tcp->th_dport) == port + seq);
1148 }
1149
1150 void
1151 gre_prep(struct outdata *outdata)
1152 {
1153         struct grehdr *const gre = (struct grehdr *) outprot;
1154
1155         gre->flags = htons(0x2001);
1156         gre->proto = htons(port);
1157         gre->length = 0;
1158         gre->callId = htons(ident + outdata->seq);
1159 }
1160
1161 int
1162 gre_check(const u_char *data, int seq)
1163 {
1164         struct grehdr *const gre = (struct grehdr *) data;
1165
1166         return(ntohs(gre->proto) == port
1167             && ntohs(gre->callId) == ident + seq);
1168 }
1169
1170 void
1171 gen_prep(struct outdata *outdata)
1172 {
1173         u_int16_t *const ptr = (u_int16_t *) outprot;
1174
1175         ptr[0] = htons(ident);
1176         ptr[1] = htons(port + outdata->seq);
1177 }
1178
1179 int
1180 gen_check(const u_char *data, int seq)
1181 {
1182         u_int16_t *const ptr = (u_int16_t *) data;
1183
1184         return(ntohs(ptr[0]) == ident
1185             && ntohs(ptr[1]) == port + seq);
1186 }
1187
1188 void
1189 print(register u_char *buf, register int cc, register struct sockaddr_in *from)
1190 {
1191         register struct ip *ip;
1192         register int hlen;
1193
1194         ip = (struct ip *) buf;
1195         hlen = ip->ip_hl << 2;
1196         cc -= hlen;
1197
1198         if (nflag)
1199                 Printf(" %s", inet_ntoa(from->sin_addr));
1200         else
1201                 Printf(" %s (%s)", inetname(from->sin_addr),
1202                     inet_ntoa(from->sin_addr));
1203
1204         if (verbose)
1205                 Printf(" %d bytes to %s", cc, inet_ntoa (ip->ip_dst));
1206 }
1207
1208 /*
1209  * Checksum routine for Internet Protocol family headers (C Version)
1210  */
1211 u_short
1212 in_cksum(register u_short *addr, register int len)
1213 {
1214         register int nleft = len;
1215         register u_short *w = addr;
1216         register u_short answer;
1217         register int sum = 0;
1218
1219         /*
1220          *  Our algorithm is simple, using a 32 bit accumulator (sum),
1221          *  we add sequential 16 bit words to it, and at the end, fold
1222          *  back all the carry bits from the top 16 bits into the lower
1223          *  16 bits.
1224          */
1225         while (nleft > 1)  {
1226                 sum += *w++;
1227                 nleft -= 2;
1228         }
1229
1230         /* mop up an odd byte, if necessary */
1231         if (nleft == 1)
1232                 sum += *(u_char *)w;
1233
1234         /*
1235          * add back carry outs from top 16 bits to low 16 bits
1236          */
1237         sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
1238         sum += (sum >> 16);                     /* add carry */
1239         answer = ~sum;                          /* truncate to 16 bits */
1240         return (answer);
1241 }
1242
1243 /*
1244  * Subtract 2 timeval structs:  out = out - in.
1245  * Out is assumed to be within about LONG_MAX seconds of in.
1246  */
1247 void
1248 tvsub(register struct timeval *out, register struct timeval *in)
1249 {
1250
1251         if ((out->tv_usec -= in->tv_usec) < 0)   {
1252                 --out->tv_sec;
1253                 out->tv_usec += 1000000;
1254         }
1255         out->tv_sec -= in->tv_sec;
1256 }
1257
1258 /*
1259  * Construct an Internet address representation.
1260  * If the nflag has been supplied, give
1261  * numeric value, otherwise try for symbolic name.
1262  */
1263 char *
1264 inetname(struct in_addr in)
1265 {
1266         register char *cp;
1267         register struct hostent *hp;
1268         static int first = 1;
1269         static char domain[MAXHOSTNAMELEN + 1], line[MAXHOSTNAMELEN + 1];
1270
1271         if (first && !nflag) {
1272                 first = 0;
1273                 if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
1274                     (cp = strchr(domain, '.')) != NULL) {
1275                         (void)strncpy(domain, cp + 1, sizeof(domain) - 1);
1276                         domain[sizeof(domain) - 1] = '\0';
1277                 } else
1278                         domain[0] = '\0';
1279         }
1280         if (!nflag && in.s_addr != INADDR_ANY) {
1281                 hp = gethostbyaddr((char *)&in, sizeof(in), AF_INET);
1282                 if (hp != NULL) {
1283                         if ((cp = strchr(hp->h_name, '.')) != NULL &&
1284                             strcmp(cp + 1, domain) == 0)
1285                                 *cp = '\0';
1286                         (void)strncpy(line, hp->h_name, sizeof(line) - 1);
1287                         line[sizeof(line) - 1] = '\0';
1288                         return (line);
1289                 }
1290         }
1291         return (inet_ntoa(in));
1292 }
1293
1294 char *
1295 getaddr(register u_int32_t *ap, register char *hostname)
1296 {
1297         register struct hostent *hp;
1298
1299         *ap = inet_addr(hostname);
1300         if ((int32_t)*ap != -1)
1301                 return (hostname);
1302
1303         hp = gethostbyname(hostname);
1304         if (hp == NULL) {
1305                 Fprintf(stderr, "%s: unknown host %s\n", prog, hostname);
1306                 exit(1);
1307         }
1308         if (hp->h_addrtype != AF_INET || hp->h_length != 4) {
1309                 Fprintf(stderr, "%s: bad host %s\n", prog, hostname);
1310                 exit(1);
1311         }
1312         memcpy((caddr_t)ap, hp->h_addr, hp->h_length);
1313         return (hp->h_name);
1314 }
1315
1316 char *
1317 getsin(register struct sockaddr_in *sin, register char *hostname)
1318 {
1319
1320         memset(sin, 0, sizeof(*sin));
1321         sin->sin_family = AF_INET;
1322         return (getaddr((u_int32_t *)&sin->sin_addr.s_addr, hostname));
1323 }
1324
1325 char *
1326 savestr(register const char *str)
1327 {
1328         register char *cp;
1329
1330         cp = strdup(str);
1331         if (cp == NULL) {
1332                 Fprintf(stderr, "%s: strdup: %s\n", prog, strerror(errno));
1333                 exit(1);
1334         }
1335         return (cp);
1336 }
1337
1338 __dead void
1339 usage(void)
1340 {
1341         extern char version[];
1342
1343         Fprintf(stderr, "Version %s\n", version);
1344         Fprintf(stderr, "Usage: %s [-Sdnrv] [-w wait] [-m max_ttl] [-M min_ttl] \
1345 [-P proto]\n\t [-p port#] [-q nqueries] [-t tos] [-s src_addr] [-g gateway] \
1346 \n\t host [data_size]\n", prog);
1347         exit(1);
1348 }