![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ping.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / ping|
Return to ping.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / ping |
1.1 ! root 1: /* ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Mike Muuss. ! 7: * ! 8: * Redistribution and use in source and binary forms are permitted ! 9: * provided that: (1) source distributions retain this entire copyright ! 10: * notice and comment, and (2) distributions including binaries display ! 11: * the following acknowledgement: ``This product includes software ! 12: * developed by the University of California, Berkeley and its contributors'' ! 13: * in the documentation or other materials provided with the distribution ! 14: * and in all advertising materials mentioning features or use of this ! 15: * software. Neither the name of the University nor the names of its ! 16: * contributors may be used to endorse or promote products derived ! 17: * from this software without specific prior written permission. ! 18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 19: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 20: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 21: */ ! 22: ! 23: #ifndef lint ! 24: char copyright[] = ! 25: "@(#) Copyright (c) 1989 The Regents of the University of California.\n\ ! 26: All rights reserved.\n"; ! 27: #endif /* not lint */ ! 28: ! 29: #ifndef lint ! 30: static char sccsid[] = "@(#)ping.c 5.6 (Berkeley) 6/1/90"; ! 31: #endif /* not lint */ ! 32: ! 33: /* ! 34: * P I N G . C ! 35: * ! 36: * Using the InterNet Control Message Protocol (ICMP) "ECHO" facility, ! 37: * measure round-trip-delays and packet loss across network paths. ! 38: * ! 39: * Author - ! 40: * Mike Muuss ! 41: * U. S. Army Ballistic Research Laboratory ! 42: * December, 1983 ! 43: * ! 44: * Status - ! 45: * Public Domain. Distribution Unlimited. ! 46: * Bugs - ! 47: * More statistics could always be gathered. ! 48: * This program has to run SUID to ROOT to access the ICMP socket. ! 49: */ ! 50: ! 51: #include <sys/param.h> ! 52: #include <sys/socket.h> ! 53: #include <sys/file.h> ! 54: #include <sys/time.h> ! 55: #include <sys/signal.h> ! 56: ! 57: #include <netinet/in_systm.h> ! 58: #include <netinet/in.h> ! 59: #include <netinet/ip.h> ! 60: #include <netinet/ip_icmp.h> ! 61: #include <netinet/ip_var.h> ! 62: #include <netdb.h> ! 63: #include <unistd.h> ! 64: #include <stdio.h> ! 65: #include <ctype.h> ! 66: #include <errno.h> ! 67: #include <string.h> ! 68: ! 69: #define DEFDATALEN (64 - 8) /* default data length */ ! 70: #define MAXIPLEN 60 ! 71: #define MAXICMPLEN 76 ! 72: #define MAXPACKET (65536 - 60 - 8)/* max packet size */ ! 73: #define MAXWAIT 10 /* max seconds to wait for response */ ! 74: #define NROUTES 9 /* number of record route slots */ ! 75: ! 76: #define A(bit) rcvd_tbl[(bit)>>3] /* identify byte in array */ ! 77: #define B(bit) (1 << ((bit) & 0x07)) /* identify bit in byte */ ! 78: #define SET(bit) (A(bit) |= B(bit)) ! 79: #define CLR(bit) (A(bit) &= (~B(bit))) ! 80: #define TST(bit) (A(bit) & B(bit)) ! 81: ! 82: /* various options */ ! 83: int options; ! 84: #define F_FLOOD 0x001 ! 85: #define F_INTERVAL 0x002 ! 86: #define F_NUMERIC 0x004 ! 87: #define F_PINGFILLED 0x008 ! 88: #define F_QUIET 0x010 ! 89: #define F_RROUTE 0x020 ! 90: #define F_SO_DEBUG 0x040 ! 91: #define F_SO_DONTROUTE 0x080 ! 92: #define F_VERBOSE 0x100 ! 93: ! 94: /* ! 95: * MAX_DUP_CHK is the number of bits in received table, i.e. the maximum ! 96: * number of received sequence numbers we can keep track of. Change 128 ! 97: * to 8192 for complete accuracy... ! 98: */ ! 99: #define MAX_DUP_CHK (8 * 128) ! 100: int mx_dup_ck = MAX_DUP_CHK; ! 101: char rcvd_tbl[MAX_DUP_CHK / 8]; ! 102: ! 103: struct sockaddr whereto; /* who to ping */ ! 104: int datalen = DEFDATALEN; ! 105: int s; /* socket file descriptor */ ! 106: u_char outpack[MAXPACKET]; ! 107: char BSPACE = '\b'; /* characters written for flood */ ! 108: char DOT = '.'; ! 109: char *hostname; ! 110: int ident; /* process id to identify our packets */ ! 111: ! 112: /* counters */ ! 113: long npackets; /* max packets to transmit */ ! 114: long nreceived; /* # of packets we got back */ ! 115: long nrepeats; /* number of duplicates */ ! 116: long ntransmitted; /* sequence # for outbound packets = #sent */ ! 117: int interval = 1; /* interval between packets */ ! 118: ! 119: /* timing */ ! 120: int timing; /* flag to do timing */ ! 121: long tmin = LONG_MAX; /* minimum round trip time */ ! 122: long tmax; /* maximum round trip time */ ! 123: u_long tsum; /* sum of all times, for doing average */ ! 124: ! 125: u_long inet_addr(); ! 126: char *inet_ntoa(), *pr_addr(); ! 127: int catcher(), finish(); ! 128: ! 129: main(argc, argv) ! 130: int argc; ! 131: char **argv; ! 132: { ! 133: extern int errno, optind; ! 134: extern char *optarg; ! 135: struct timeval timeout; ! 136: struct hostent *hp; ! 137: struct sockaddr_in *to; ! 138: struct protoent *proto; ! 139: register int i; ! 140: int ch, fdmask, hold, packlen, preload; ! 141: u_char *datap, *packet; ! 142: char *target, hnamebuf[MAXHOSTNAMELEN], *malloc(); ! 143: #ifdef IP_OPTIONS ! 144: char rspace[3 + 4 * NROUTES + 1]; /* record route space */ ! 145: #endif ! 146: ! 147: preload = 0; ! 148: datap = &outpack[8 + sizeof(struct timeval)]; ! 149: while ((ch = getopt(argc, argv, "Rc:dfh:i:l:np:qrs:v")) != EOF) ! 150: switch(ch) { ! 151: case 'c': ! 152: npackets = atoi(optarg); ! 153: if (npackets <= 0) { ! 154: (void)fprintf(stderr, ! 155: "ping: bad number of packets to transmit.\n"); ! 156: exit(1); ! 157: } ! 158: break; ! 159: case 'd': ! 160: options |= F_SO_DEBUG; ! 161: break; ! 162: case 'f': ! 163: if (getuid()) { ! 164: (void)fprintf(stderr, ! 165: "ping: you must be root to use the -f option.\n"); ! 166: exit(1); ! 167: } ! 168: options |= F_FLOOD; ! 169: setbuf(stdout, (char *)NULL); ! 170: break; ! 171: case 'i': /* wait between sending packets */ ! 172: interval = atoi(optarg); ! 173: if (interval <= 0) { ! 174: (void)fprintf(stderr, ! 175: "ping: bad timing interval.\n"); ! 176: exit(1); ! 177: } ! 178: options |= F_INTERVAL; ! 179: break; ! 180: case 'l': ! 181: preload = atoi(optarg); ! 182: if (preload < 0) { ! 183: (void)fprintf(stderr, ! 184: "ping: bad preload value.\n"); ! 185: exit(1); ! 186: } ! 187: break; ! 188: case 'n': ! 189: options |= F_NUMERIC; ! 190: break; ! 191: case 'p': /* fill buffer with user pattern */ ! 192: options |= F_PINGFILLED; ! 193: fill((char *)datap, optarg); ! 194: break; ! 195: case 'q': ! 196: options |= F_QUIET; ! 197: break; ! 198: case 'R': ! 199: options |= F_RROUTE; ! 200: break; ! 201: case 'r': ! 202: options |= F_SO_DONTROUTE; ! 203: break; ! 204: case 's': /* size of packet to send */ ! 205: datalen = atoi(optarg); ! 206: if (datalen > MAXPACKET) { ! 207: (void)fprintf(stderr, ! 208: "ping: packet size too large.\n"); ! 209: exit(1); ! 210: } ! 211: if (datalen <= 0) { ! 212: (void)fprintf(stderr, ! 213: "ping: illegal packet size.\n"); ! 214: exit(1); ! 215: } ! 216: break; ! 217: case 'v': ! 218: options |= F_VERBOSE; ! 219: break; ! 220: default: ! 221: usage(); ! 222: } ! 223: argc -= optind; ! 224: argv += optind; ! 225: ! 226: if (argc != 1) ! 227: usage(); ! 228: target = *argv; ! 229: ! 230: bzero((char *)&whereto, sizeof(struct sockaddr)); ! 231: to = (struct sockaddr_in *)&whereto; ! 232: to->sin_family = AF_INET; ! 233: to->sin_addr.s_addr = inet_addr(target); ! 234: if (to->sin_addr.s_addr != (u_int)-1) ! 235: hostname = target; ! 236: else { ! 237: hp = gethostbyname(target); ! 238: if (!hp) { ! 239: (void)fprintf(stderr, ! 240: "ping: unknown host %s\n", target); ! 241: exit(1); ! 242: } ! 243: to->sin_family = hp->h_addrtype; ! 244: bcopy(hp->h_addr, (caddr_t)&to->sin_addr, hp->h_length); ! 245: (void)strncpy(hnamebuf, hp->h_name, sizeof(hnamebuf) - 1); ! 246: hostname = hnamebuf; ! 247: } ! 248: ! 249: if (options & F_FLOOD && options & F_INTERVAL) { ! 250: (void)fprintf(stderr, ! 251: "ping: -f and -i incompatible options.\n"); ! 252: exit(1); ! 253: } ! 254: ! 255: if (datalen >= sizeof(struct timeval)) /* can we time transfer */ ! 256: timing = 1; ! 257: packlen = datalen + MAXIPLEN + MAXICMPLEN; ! 258: if (!(packet = (u_char *)malloc((u_int)packlen))) { ! 259: (void)fprintf(stderr, "ping: out of memory.\n"); ! 260: exit(1); ! 261: } ! 262: if (!(options & F_PINGFILLED)) ! 263: for (i = 8; i < datalen; ++i) ! 264: *datap++ = i; ! 265: ! 266: ident = getpid() & 0xFFFF; ! 267: ! 268: if (!(proto = getprotobyname("icmp"))) { ! 269: (void)fprintf(stderr, "ping: unknown protocol icmp.\n"); ! 270: exit(1); ! 271: } ! 272: if ((s = socket(AF_INET, SOCK_RAW, proto->p_proto)) < 0) { ! 273: perror("ping: socket"); ! 274: exit(1); ! 275: } ! 276: hold = 1; ! 277: if (options & F_SO_DEBUG) ! 278: (void)setsockopt(s, SOL_SOCKET, SO_DEBUG, (char *)&hold, ! 279: sizeof(hold)); ! 280: if (options & F_SO_DONTROUTE) ! 281: (void)setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)&hold, ! 282: sizeof(hold)); ! 283: ! 284: /* record route option */ ! 285: if (options & F_RROUTE) { ! 286: #ifdef IP_OPTIONS ! 287: rspace[IPOPT_OPTVAL] = IPOPT_RR; ! 288: rspace[IPOPT_OLEN] = sizeof(rspace)-1; ! 289: rspace[IPOPT_OFFSET] = IPOPT_MINOFF; ! 290: if (setsockopt(s, IPPROTO_IP, IP_OPTIONS, rspace, ! 291: sizeof(rspace)) < 0) { ! 292: perror("ping: record route"); ! 293: exit(1); ! 294: } ! 295: #else ! 296: (void)fprintf(stderr, ! 297: "ping: record route not available in this implementation.\n"); ! 298: exit(1); ! 299: #endif /* IP_OPTIONS */ ! 300: } ! 301: ! 302: /* ! 303: * When pinging the broadcast address, you can get a lot of answers. ! 304: * Doing something so evil is useful if you are trying to stress the ! 305: * ethernet, or just want to fill the arp cache to get some stuff for ! 306: * /etc/ethers. ! 307: */ ! 308: hold = 48 * 1024; ! 309: (void)setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&hold, ! 310: sizeof(hold)); ! 311: ! 312: if (to->sin_family == AF_INET) ! 313: (void)printf("PING %s (%s): %d data bytes\n", hostname, ! 314: inet_ntoa(*(struct in_addr *)&to->sin_addr.s_addr), ! 315: datalen); ! 316: else ! 317: (void)printf("PING %s: %d data bytes\n", hostname, datalen); ! 318: ! 319: (void)signal(SIGINT, finish); ! 320: (void)signal(SIGALRM, catcher); ! 321: ! 322: while (preload--) /* fire off them quickies */ ! 323: pinger(); ! 324: ! 325: if ((options & F_FLOOD) == 0) ! 326: catcher(); /* start things going */ ! 327: ! 328: for (;;) { ! 329: struct sockaddr_in from; ! 330: register int cc; ! 331: int fromlen; ! 332: ! 333: if (options & F_FLOOD) { ! 334: pinger(); ! 335: timeout.tv_sec = 0; ! 336: timeout.tv_usec = 10000; ! 337: fdmask = 1 << s; ! 338: if (select(s + 1, (fd_set *)&fdmask, (fd_set *)NULL, ! 339: (fd_set *)NULL, &timeout) < 1) ! 340: continue; ! 341: } ! 342: fromlen = sizeof(from); ! 343: if ((cc = recvfrom(s, (char *)packet, packlen, 0, ! 344: (struct sockaddr *)&from, &fromlen)) < 0) { ! 345: if (errno == EINTR) ! 346: continue; ! 347: perror("ping: recvfrom"); ! 348: continue; ! 349: } ! 350: pr_pack((char *)packet, cc, &from); ! 351: if (npackets && nreceived >= npackets) ! 352: break; ! 353: } ! 354: finish(); ! 355: /* NOTREACHED */ ! 356: } ! 357: ! 358: /* ! 359: * catcher -- ! 360: * This routine causes another PING to be transmitted, and then ! 361: * schedules another SIGALRM for 1 second from now. ! 362: * ! 363: * bug -- ! 364: * Our sense of time will slowly skew (i.e., packets will not be ! 365: * launched exactly at 1-second intervals). This does not affect the ! 366: * quality of the delay and loss statistics. ! 367: */ ! 368: catcher() ! 369: { ! 370: int waittime; ! 371: ! 372: pinger(); ! 373: (void)signal(SIGALRM, catcher); ! 374: if (!npackets || ntransmitted < npackets) ! 375: alarm((u_int)interval); ! 376: else { ! 377: if (nreceived) { ! 378: waittime = 2 * tmax / 1000; ! 379: if (!waittime) ! 380: waittime = 1; ! 381: } else ! 382: waittime = MAXWAIT; ! 383: (void)signal(SIGALRM, finish); ! 384: (void)alarm((u_int)waittime); ! 385: } ! 386: } ! 387: ! 388: /* ! 389: * pinger -- ! 390: * Compose and transmit an ICMP ECHO REQUEST packet. The IP packet ! 391: * will be added on by the kernel. The ID field is our UNIX process ID, ! 392: * and the sequence number is an ascending integer. The first 8 bytes ! 393: * of the data portion are used to hold a UNIX "timeval" struct in VAX ! 394: * byte-order, to compute the round-trip time. ! 395: */ ! 396: pinger() ! 397: { ! 398: register struct icmp *icp; ! 399: register int cc; ! 400: int i; ! 401: ! 402: icp = (struct icmp *)outpack; ! 403: icp->icmp_type = ICMP_ECHO; ! 404: icp->icmp_code = 0; ! 405: icp->icmp_cksum = 0; ! 406: icp->icmp_seq = ntransmitted++; ! 407: icp->icmp_id = ident; /* ID */ ! 408: ! 409: CLR(icp->icmp_seq % mx_dup_ck); ! 410: ! 411: if (timing) ! 412: (void)gettimeofday((struct timeval *)&outpack[8], ! 413: (struct timezone *)NULL); ! 414: ! 415: cc = datalen + 8; /* skips ICMP portion */ ! 416: ! 417: /* compute ICMP checksum here */ ! 418: icp->icmp_cksum = in_cksum((u_short *)icp, cc); ! 419: ! 420: i = sendto(s, (char *)outpack, cc, 0, &whereto, ! 421: sizeof(struct sockaddr)); ! 422: ! 423: if (i < 0 || i != cc) { ! 424: if (i < 0) ! 425: perror("ping: sendto"); ! 426: (void)printf("ping: wrote %s %d chars, ret=%d\n", ! 427: hostname, cc, i); ! 428: } ! 429: if (options & F_FLOOD) ! 430: (void)write(STDOUT_FILENO, &DOT, 1); ! 431: } ! 432: ! 433: /* ! 434: * pr_pack -- ! 435: * Print out the packet, if it came from us. This logic is necessary ! 436: * because ALL readers of the ICMP socket get a copy of ALL ICMP packets ! 437: * which arrive ('tis only fair). This permits multiple copies of this ! 438: * program to be run without having intermingled output (or statistics!). ! 439: */ ! 440: pr_pack(buf, cc, from) ! 441: char *buf; ! 442: int cc; ! 443: struct sockaddr_in *from; ! 444: { ! 445: register struct icmp *icp; ! 446: register u_long l; ! 447: register int i, j; ! 448: register u_char *cp,*dp; ! 449: static int old_rrlen; ! 450: static char old_rr[MAX_IPOPTLEN]; ! 451: struct ip *ip; ! 452: struct timeval tv, *tp; ! 453: long triptime; ! 454: int hlen, dupflag; ! 455: ! 456: (void)gettimeofday(&tv, (struct timezone *)NULL); ! 457: ! 458: /* Check the IP header */ ! 459: ip = (struct ip *)buf; ! 460: hlen = ip->ip_hl << 2; ! 461: if (cc < hlen + ICMP_MINLEN) { ! 462: if (options & F_VERBOSE) ! 463: (void)fprintf(stderr, ! 464: "ping: packet too short (%d bytes) from %s\n", cc, ! 465: inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr)); ! 466: return; ! 467: } ! 468: ! 469: /* Now the ICMP part */ ! 470: cc -= hlen; ! 471: icp = (struct icmp *)(buf + hlen); ! 472: if (icp->icmp_type == ICMP_ECHOREPLY) { ! 473: if (icp->icmp_id != ident) ! 474: return; /* 'Twas not our ECHO */ ! 475: ++nreceived; ! 476: if (timing) { ! 477: #ifndef icmp_data ! 478: tp = (struct timeval *)&icp->icmp_ip; ! 479: #else ! 480: tp = (struct timeval *)icp->icmp_data; ! 481: #endif ! 482: tvsub(&tv, tp); ! 483: triptime = tv.tv_sec * 1000 + (tv.tv_usec / 1000); ! 484: tsum += triptime; ! 485: if (triptime < tmin) ! 486: tmin = triptime; ! 487: if (triptime > tmax) ! 488: tmax = triptime; ! 489: } ! 490: ! 491: if (TST(icp->icmp_seq % mx_dup_ck)) { ! 492: ++nrepeats; ! 493: --nreceived; ! 494: dupflag = 1; ! 495: } else { ! 496: SET(icp->icmp_seq % mx_dup_ck); ! 497: dupflag = 0; ! 498: } ! 499: ! 500: if (options & F_QUIET) ! 501: return; ! 502: ! 503: if (options & F_FLOOD) ! 504: (void)write(STDOUT_FILENO, &BSPACE, 1); ! 505: else { ! 506: (void)printf("%d bytes from %s: icmp_seq=%u", cc, ! 507: inet_ntoa(*(struct in_addr *)&from->sin_addr.s_addr), ! 508: icp->icmp_seq); ! 509: (void)printf(" ttl=%d", ip->ip_ttl); ! 510: if (timing) ! 511: (void)printf(" time=%ld ms", triptime); ! 512: if (dupflag) ! 513: (void)printf(" (DUP!)"); ! 514: /* check the data */ ! 515: cp = (u_char*)&icp->icmp_data[8]; ! 516: dp = &outpack[8 + sizeof(struct timeval)]; ! 517: for (i = 8; i < datalen; ++i, ++cp, ++dp) { ! 518: if (*cp != *dp) { ! 519: (void)printf("\nwrong data byte #%d should be 0x%x but was 0x%x", ! 520: i, *dp, *cp); ! 521: cp = (u_char*)&icp->icmp_data[0]; ! 522: for (i = 8; i < datalen; ++i, ++cp) { ! 523: if ((i % 32) == 8) ! 524: (void)printf("\n\t"); ! 525: (void)printf("%x ", *cp); ! 526: } ! 527: break; ! 528: } ! 529: } ! 530: } ! 531: } else { ! 532: /* We've got something other than an ECHOREPLY */ ! 533: if (!(options & F_VERBOSE)) ! 534: return; ! 535: (void)printf("%d bytes from %s: ", cc, ! 536: pr_addr(from->sin_addr.s_addr)); ! 537: pr_icmph(icp); ! 538: } ! 539: ! 540: /* Display any IP options */ ! 541: cp = (u_char *)buf + sizeof(struct ip); ! 542: ! 543: /* ANSI C will force hlen to unsigned! */ ! 544: for (; hlen > sizeof(struct ip); --hlen, ++cp) ! 545: switch (*cp) { ! 546: case IPOPT_EOL: ! 547: hlen = 0; ! 548: break; ! 549: case IPOPT_LSRR: ! 550: (void)printf("\nLSRR: "); ! 551: hlen -= 2; ! 552: j = *++cp; ! 553: ++cp; ! 554: if (j > IPOPT_MINOFF) ! 555: for (;;) { ! 556: l = *++cp; ! 557: l = (l<<8) + *++cp; ! 558: l = (l<<8) + *++cp; ! 559: l = (l<<8) + *++cp; ! 560: if (l == 0) ! 561: (void)printf("\t0.0.0.0"); ! 562: else ! 563: (void)printf("\t%s", pr_addr(ntohl(l))); ! 564: hlen -= 4; ! 565: j -= 4; ! 566: if (j <= IPOPT_MINOFF) ! 567: break; ! 568: (void)putchar('\n'); ! 569: } ! 570: break; ! 571: case IPOPT_RR: ! 572: j = *++cp; /* get length */ ! 573: i = *++cp; /* and pointer */ ! 574: hlen -= 2; ! 575: if (i > j) ! 576: i = j; ! 577: i -= IPOPT_MINOFF; ! 578: if (i <= 0) ! 579: continue; ! 580: if (i == old_rrlen ! 581: && cp == (u_char *)buf + sizeof(struct ip) + 2 ! 582: && !bcmp((char *)cp, old_rr, i) ! 583: && !(options & F_FLOOD)) { ! 584: (void)printf("\t(same route)"); ! 585: i = ((i + 3) / 4) * 4; ! 586: hlen -= i; ! 587: cp += i; ! 588: break; ! 589: } ! 590: old_rrlen = i; ! 591: bcopy((char *)cp, old_rr, i); ! 592: (void)printf("\nRR: "); ! 593: for (;;) { ! 594: l = *++cp; ! 595: l = (l<<8) + *++cp; ! 596: l = (l<<8) + *++cp; ! 597: l = (l<<8) + *++cp; ! 598: if (l == 0) ! 599: (void)printf("\t0.0.0.0"); ! 600: else ! 601: (void)printf("\t%s", pr_addr(ntohl(l))); ! 602: hlen -= 4; ! 603: i -= 4; ! 604: if (i <= 0) ! 605: break; ! 606: (void)putchar('\n'); ! 607: } ! 608: break; ! 609: case IPOPT_NOP: ! 610: (void)printf("\nNOP"); ! 611: break; ! 612: default: ! 613: (void)printf("\nunknown option %x", *cp); ! 614: break; ! 615: } ! 616: if (!(options & F_FLOOD)) { ! 617: (void)putchar('\n'); ! 618: (void)fflush(stdout); ! 619: } ! 620: } ! 621: ! 622: /* ! 623: * in_cksum -- ! 624: * Checksum routine for Internet Protocol family headers (C Version) ! 625: */ ! 626: in_cksum(addr, len) ! 627: u_short *addr; ! 628: int len; ! 629: { ! 630: register int nleft = len; ! 631: register u_short *w = addr; ! 632: register int sum = 0; ! 633: u_short answer = 0; ! 634: ! 635: /* ! 636: * Our algorithm is simple, using a 32 bit accumulator (sum), we add ! 637: * sequential 16 bit words to it, and at the end, fold back all the ! 638: * carry bits from the top 16 bits into the lower 16 bits. ! 639: */ ! 640: while (nleft > 1) { ! 641: sum += *w++; ! 642: nleft -= 2; ! 643: } ! 644: ! 645: /* mop up an odd byte, if necessary */ ! 646: if (nleft == 1) { ! 647: *(u_char *)(&answer) = *(u_char *)w ; ! 648: sum += answer; ! 649: } ! 650: ! 651: /* add back carry outs from top 16 bits to low 16 bits */ ! 652: sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */ ! 653: sum += (sum >> 16); /* add carry */ ! 654: answer = ~sum; /* truncate to 16 bits */ ! 655: return(answer); ! 656: } ! 657: ! 658: /* ! 659: * tvsub -- ! 660: * Subtract 2 timeval structs: out = out - in. Out is assumed to ! 661: * be >= in. ! 662: */ ! 663: tvsub(out, in) ! 664: register struct timeval *out, *in; ! 665: { ! 666: if ((out->tv_usec -= in->tv_usec) < 0) { ! 667: --out->tv_sec; ! 668: out->tv_usec += 1000000; ! 669: } ! 670: out->tv_sec -= in->tv_sec; ! 671: } ! 672: ! 673: /* ! 674: * finish -- ! 675: * Print out statistics, and give up. ! 676: */ ! 677: finish() ! 678: { ! 679: (void)signal(SIGINT, SIG_IGN); ! 680: (void)putchar('\n'); ! 681: (void)fflush(stdout); ! 682: (void)printf("--- %s ping statistics ---\n", hostname); ! 683: (void)printf("%ld packets transmitted, ", ntransmitted); ! 684: (void)printf("%ld packets received, ", nreceived); ! 685: if (nrepeats) ! 686: (void)printf("+%ld duplicates, ", nrepeats); ! 687: if (ntransmitted) ! 688: if (nreceived > ntransmitted) ! 689: (void)printf("-- somebody's printing up packets!"); ! 690: else ! 691: (void)printf("%d%% packet loss", ! 692: (int) (((ntransmitted - nreceived) * 100) / ! 693: ntransmitted)); ! 694: (void)putchar('\n'); ! 695: if (nreceived && timing) ! 696: (void)printf("round-trip min/avg/max = %ld/%lu/%ld ms\n", ! 697: tmin, tsum / (nreceived + nrepeats), tmax); ! 698: exit(0); ! 699: } ! 700: ! 701: #ifdef notdef ! 702: static char *ttab[] = { ! 703: "Echo Reply", /* ip + seq + udata */ ! 704: "Dest Unreachable", /* net, host, proto, port, frag, sr + IP */ ! 705: "Source Quench", /* IP */ ! 706: "Redirect", /* redirect type, gateway, + IP */ ! 707: "Echo", ! 708: "Time Exceeded", /* transit, frag reassem + IP */ ! 709: "Parameter Problem", /* pointer + IP */ ! 710: "Timestamp", /* id + seq + three timestamps */ ! 711: "Timestamp Reply", /* " */ ! 712: "Info Request", /* id + sq */ ! 713: "Info Reply" /* " */ ! 714: }; ! 715: #endif ! 716: ! 717: /* ! 718: * pr_icmph -- ! 719: * Print a descriptive string about an ICMP header. ! 720: */ ! 721: pr_icmph(icp) ! 722: struct icmp *icp; ! 723: { ! 724: switch(icp->icmp_type) { ! 725: case ICMP_ECHOREPLY: ! 726: (void)printf("Echo Reply\n"); ! 727: /* XXX ID + Seq + Data */ ! 728: break; ! 729: case ICMP_UNREACH: ! 730: switch(icp->icmp_code) { ! 731: case ICMP_UNREACH_NET: ! 732: (void)printf("Destination Net Unreachable\n"); ! 733: break; ! 734: case ICMP_UNREACH_HOST: ! 735: (void)printf("Destination Host Unreachable\n"); ! 736: break; ! 737: case ICMP_UNREACH_PROTOCOL: ! 738: (void)printf("Destination Protocol Unreachable\n"); ! 739: break; ! 740: case ICMP_UNREACH_PORT: ! 741: (void)printf("Destination Port Unreachable\n"); ! 742: break; ! 743: case ICMP_UNREACH_NEEDFRAG: ! 744: (void)printf("frag needed and DF set\n"); ! 745: break; ! 746: case ICMP_UNREACH_SRCFAIL: ! 747: (void)printf("Source Route Failed\n"); ! 748: break; ! 749: default: ! 750: (void)printf("Dest Unreachable, Bad Code: %d\n", ! 751: icp->icmp_code); ! 752: break; ! 753: } ! 754: /* Print returned IP header information */ ! 755: #ifndef icmp_data ! 756: pr_retip(&icp->icmp_ip); ! 757: #else ! 758: pr_retip((struct ip *)icp->icmp_data); ! 759: #endif ! 760: break; ! 761: case ICMP_SOURCEQUENCH: ! 762: (void)printf("Source Quench\n"); ! 763: #ifndef icmp_data ! 764: pr_retip(&icp->icmp_ip); ! 765: #else ! 766: pr_retip((struct ip *)icp->icmp_data); ! 767: #endif ! 768: break; ! 769: case ICMP_REDIRECT: ! 770: switch(icp->icmp_code) { ! 771: case ICMP_REDIRECT_NET: ! 772: (void)printf("Redirect Network"); ! 773: break; ! 774: case ICMP_REDIRECT_HOST: ! 775: (void)printf("Redirect Host"); ! 776: break; ! 777: case ICMP_REDIRECT_TOSNET: ! 778: (void)printf("Redirect Type of Service and Network"); ! 779: break; ! 780: case ICMP_REDIRECT_TOSHOST: ! 781: (void)printf("Redirect Type of Service and Host"); ! 782: break; ! 783: default: ! 784: (void)printf("Redirect, Bad Code: %d", icp->icmp_code); ! 785: break; ! 786: } ! 787: (void)printf("(New addr: 0x%08lx)\n", icp->icmp_gwaddr.s_addr); ! 788: #ifndef icmp_data ! 789: pr_retip(&icp->icmp_ip); ! 790: #else ! 791: pr_retip((struct ip *)icp->icmp_data); ! 792: #endif ! 793: break; ! 794: case ICMP_ECHO: ! 795: (void)printf("Echo Request\n"); ! 796: /* XXX ID + Seq + Data */ ! 797: break; ! 798: case ICMP_TIMXCEED: ! 799: switch(icp->icmp_code) { ! 800: case ICMP_TIMXCEED_INTRANS: ! 801: (void)printf("Time to live exceeded\n"); ! 802: break; ! 803: case ICMP_TIMXCEED_REASS: ! 804: (void)printf("Frag reassembly time exceeded\n"); ! 805: break; ! 806: default: ! 807: (void)printf("Time exceeded, Bad Code: %d\n", ! 808: icp->icmp_code); ! 809: break; ! 810: } ! 811: #ifndef icmp_data ! 812: pr_retip(&icp->icmp_ip); ! 813: #else ! 814: pr_retip((struct ip *)icp->icmp_data); ! 815: #endif ! 816: break; ! 817: case ICMP_PARAMPROB: ! 818: (void)printf("Parameter problem: pointer = 0x%02x\n", ! 819: icp->icmp_hun.ih_pptr); ! 820: #ifndef icmp_data ! 821: pr_retip(&icp->icmp_ip); ! 822: #else ! 823: pr_retip((struct ip *)icp->icmp_data); ! 824: #endif ! 825: break; ! 826: case ICMP_TSTAMP: ! 827: (void)printf("Timestamp\n"); ! 828: /* XXX ID + Seq + 3 timestamps */ ! 829: break; ! 830: case ICMP_TSTAMPREPLY: ! 831: (void)printf("Timestamp Reply\n"); ! 832: /* XXX ID + Seq + 3 timestamps */ ! 833: break; ! 834: case ICMP_IREQ: ! 835: (void)printf("Information Request\n"); ! 836: /* XXX ID + Seq */ ! 837: break; ! 838: case ICMP_IREQREPLY: ! 839: (void)printf("Information Reply\n"); ! 840: /* XXX ID + Seq */ ! 841: break; ! 842: #ifdef ICMP_MASKREQ ! 843: case ICMP_MASKREQ: ! 844: (void)printf("Address Mask Request\n"); ! 845: break; ! 846: #endif ! 847: #ifdef ICMP_MASKREPLY ! 848: case ICMP_MASKREPLY: ! 849: (void)printf("Address Mask Reply\n"); ! 850: break; ! 851: #endif ! 852: default: ! 853: (void)printf("Bad ICMP type: %d\n", icp->icmp_type); ! 854: } ! 855: } ! 856: ! 857: /* ! 858: * pr_iph -- ! 859: * Print an IP header with options. ! 860: */ ! 861: pr_iph(ip) ! 862: struct ip *ip; ! 863: { ! 864: int hlen; ! 865: u_char *cp; ! 866: ! 867: hlen = ip->ip_hl << 2; ! 868: cp = (u_char *)ip + 20; /* point to options */ ! 869: ! 870: (void)printf("Vr HL TOS Len ID Flg off TTL Pro cks Src Dst Data\n"); ! 871: (void)printf(" %1x %1x %02x %04x %04x", ! 872: ip->ip_v, ip->ip_hl, ip->ip_tos, ip->ip_len, ip->ip_id); ! 873: (void)printf(" %1x %04x", ((ip->ip_off) & 0xe000) >> 13, ! 874: (ip->ip_off) & 0x1fff); ! 875: (void)printf(" %02x %02x %04x", ip->ip_ttl, ip->ip_p, ip->ip_sum); ! 876: (void)printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_src.s_addr)); ! 877: (void)printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->ip_dst.s_addr)); ! 878: /* dump and option bytes */ ! 879: while (hlen-- > 20) { ! 880: (void)printf("%02x", *cp++); ! 881: } ! 882: (void)putchar('\n'); ! 883: } ! 884: ! 885: /* ! 886: * pr_addr -- ! 887: * Return an ascii host address as a dotted quad and optionally with ! 888: * a hostname. ! 889: */ ! 890: char * ! 891: pr_addr(l) ! 892: u_long l; ! 893: { ! 894: struct hostent *hp; ! 895: static char buf[80]; ! 896: ! 897: if ((options & F_NUMERIC) || ! 898: !(hp = gethostbyaddr((char *)&l, 4, AF_INET))) ! 899: (void)sprintf(buf, "%s", inet_ntoa(*(struct in_addr *)&l)); ! 900: else ! 901: (void)sprintf(buf, "%s (%s)", hp->h_name, ! 902: inet_ntoa(*(struct in_addr *)&l)); ! 903: return(buf); ! 904: } ! 905: ! 906: /* ! 907: * pr_retip -- ! 908: * Dump some info on a returned (via ICMP) IP packet. ! 909: */ ! 910: pr_retip(ip) ! 911: struct ip *ip; ! 912: { ! 913: int hlen; ! 914: u_char *cp; ! 915: ! 916: pr_iph(ip); ! 917: hlen = ip->ip_hl << 2; ! 918: cp = (u_char *)ip + hlen; ! 919: ! 920: if (ip->ip_p == 6) ! 921: (void)printf("TCP: from port %u, to port %u (decimal)\n", ! 922: (*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3))); ! 923: else if (ip->ip_p == 17) ! 924: (void)printf("UDP: from port %u, to port %u (decimal)\n", ! 925: (*cp * 256 + *(cp + 1)), (*(cp + 2) * 256 + *(cp + 3))); ! 926: } ! 927: ! 928: fill(bp, patp) ! 929: char *bp, *patp; ! 930: { ! 931: register int ii, jj, kk; ! 932: int pat[16]; ! 933: char *cp; ! 934: ! 935: for (cp = patp; *cp; cp++) ! 936: if (!isxdigit(*cp)) { ! 937: (void)fprintf(stderr, ! 938: "ping: patterns must be specified as hex digits.\n"); ! 939: exit(1); ! 940: } ! 941: ii = sscanf(patp, ! 942: "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x", ! 943: &pat[0], &pat[1], &pat[2], &pat[3], &pat[4], &pat[5], &pat[6], ! 944: &pat[7], &pat[8], &pat[9], &pat[10], &pat[11], &pat[12], ! 945: &pat[13], &pat[14], &pat[15]); ! 946: ! 947: if (ii > 0) ! 948: for (kk = 0; kk <= MAXPACKET - (8 + ii); kk += ii) ! 949: for (jj = 0; jj < ii; ++jj) ! 950: bp[jj + kk] = pat[jj]; ! 951: if (!(options & F_QUIET)) { ! 952: (void)printf("PATTERN: 0x"); ! 953: for (jj = 0; jj < ii; ++jj) ! 954: (void)printf("%02x", bp[jj] & 0xFF); ! 955: (void)printf("\n"); ! 956: } ! 957: } ! 958: ! 959: usage() ! 960: { ! 961: (void)fprintf(stderr, ! 962: "usage: ping [-Rdfnqrv] [-c count] [-i wait] [-l preload]\n\t[-p pattern] [-s packetsize] host\n"); ! 963: exit(1); ! 964: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.