Annotation of embedaddon/mtr/net.c, revision 1.1
1.1 ! misho 1: /*
! 2: mtr -- a network diagnostic tool
! 3: Copyright (C) 1997,1998 Matt Kimball
! 4:
! 5: This program is free software; you can redistribute it and/or modify
! 6: it under the terms of the GNU General Public License version 2 as
! 7: published by the Free Software Foundation.
! 8:
! 9: This program is distributed in the hope that it will be useful,
! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 12: GNU General Public License for more details.
! 13:
! 14: You should have received a copy of the GNU General Public License
! 15: along with this program; if not, write to the Free Software
! 16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
! 17: */
! 18:
! 19: #include <config.h>
! 20:
! 21: #if defined(HAVE_SYS_XTI_H)
! 22: #include <sys/xti.h>
! 23: #endif
! 24:
! 25: #include <sys/types.h>
! 26: #include <sys/time.h>
! 27: #include <sys/socket.h>
! 28: #include <sys/ioctl.h>
! 29: #include <sys/select.h>
! 30: #include <netinet/in.h>
! 31: #include <memory.h>
! 32: #include <unistd.h>
! 33: #ifdef HAVE_FCNTL_H
! 34: #include <fcntl.h>
! 35: #endif
! 36: #include <stdio.h>
! 37: #include <stdlib.h>
! 38: #include <math.h>
! 39: #include <errno.h>
! 40: #include <string.h>
! 41:
! 42: #include "mtr.h"
! 43: #include "net.h"
! 44: #include "display.h"
! 45: #include "dns.h"
! 46:
! 47: /* We can't rely on header files to provide this information, because
! 48: the fields have different names between, for instance, Linux and
! 49: Solaris */
! 50: struct ICMPHeader {
! 51: uint8 type;
! 52: uint8 code;
! 53: uint16 checksum;
! 54: uint16 id;
! 55: uint16 sequence;
! 56: };
! 57:
! 58: /* Structure of an UDP header. */
! 59: struct UDPHeader {
! 60: uint16 srcport;
! 61: uint16 dstport;
! 62: uint16 length;
! 63: uint16 checksum;
! 64: };
! 65:
! 66: /* Structure of an TCP header, as far as we need it. */
! 67: struct TCPHeader {
! 68: uint16 srcport;
! 69: uint16 dstport;
! 70: uint32 seq;
! 71: };
! 72:
! 73: /* Structure of an IPv4 UDP pseudoheader. */
! 74: struct UDPv4PHeader {
! 75: uint32 saddr;
! 76: uint32 daddr;
! 77: uint8 zero;
! 78: uint8 protocol;
! 79: uint16 len;
! 80: };
! 81:
! 82: /* Structure of an IP header. */
! 83: struct IPHeader {
! 84: uint8 version;
! 85: uint8 tos;
! 86: uint16 len;
! 87: uint16 id;
! 88: uint16 frag;
! 89: uint8 ttl;
! 90: uint8 protocol;
! 91: uint16 check;
! 92: uint32 saddr;
! 93: uint32 daddr;
! 94: };
! 95:
! 96:
! 97: #define ICMP_ECHO 8
! 98: #define ICMP_ECHOREPLY 0
! 99:
! 100: #define ICMP_TSTAMP 13
! 101: #define ICMP_TSTAMPREPLY 14
! 102:
! 103: #define ICMP_TIME_EXCEEDED 11
! 104: #define ICMP_UNREACHABLE 3
! 105:
! 106: #ifndef SOL_IP
! 107: #define SOL_IP 0
! 108: #endif
! 109:
! 110: struct nethost {
! 111: ip_t addr;
! 112: ip_t addrs[MAXPATH]; /* for multi paths byMin */
! 113: int xmit;
! 114: int returned;
! 115: int sent;
! 116: int up;
! 117: long long var;/* variance, could be overflowed */
! 118: int last;
! 119: int best;
! 120: int worst;
! 121: int avg; /* average: addByMin */
! 122: int gmean; /* geometirc mean: addByMin */
! 123: int jitter; /* current jitter, defined as t1-t0 addByMin */
! 124: /*int jbest;*/ /* min jitter, of cause it is 0, not needed */
! 125: int javg; /* avg jitter */
! 126: int jworst; /* max jitter */
! 127: int jinta; /* estimated variance,? rfc1889's "Interarrival Jitter" */
! 128: int transit;
! 129: int saved[SAVED_PINGS];
! 130: int saved_seq_offset;
! 131: struct mplslen mpls;
! 132: struct mplslen mplss[MAXPATH];
! 133: };
! 134:
! 135:
! 136: struct sequence {
! 137: int index;
! 138: int transit;
! 139: int saved_seq;
! 140: struct timeval time;
! 141: int socket;
! 142: };
! 143:
! 144:
! 145: /* Configuration parameter: How many queries to unknown hosts do we
! 146: send? (This limits the amount of traffic generated if a host is not
! 147: reachable) */
! 148: #define MAX_UNKNOWN_HOSTS 5
! 149:
! 150:
! 151: /* BSD-derived kernels use host byte order for the IP length and
! 152: offset fields when using raw sockets. We detect this automatically at
! 153: run-time and do the right thing. */
! 154: static int BSDfix = 0;
! 155:
! 156: static struct nethost host[MaxHost];
! 157: static struct sequence sequence[MaxSequence];
! 158: static struct timeval reset = { 0, 0 };
! 159:
! 160: int timestamp;
! 161: int sendsock4;
! 162: int sendsock4_icmp;
! 163: int sendsock4_udp;
! 164: int recvsock4;
! 165: int sendsock6;
! 166: int sendsock6_icmp;
! 167: int sendsock6_udp;
! 168: int recvsock6;
! 169: int sendsock;
! 170: int recvsock;
! 171:
! 172: #ifdef ENABLE_IPV6
! 173: struct sockaddr_storage sourcesockaddr_struct;
! 174: struct sockaddr_storage remotesockaddr_struct;
! 175: struct sockaddr_in6 * ssa6 = (struct sockaddr_in6 *) &sourcesockaddr_struct;
! 176: struct sockaddr_in6 * rsa6 = (struct sockaddr_in6 *) &remotesockaddr_struct;
! 177: #else
! 178: struct sockaddr_in sourcesockaddr_struct;
! 179: struct sockaddr_in remotesockaddr_struct;
! 180: #endif
! 181:
! 182: struct sockaddr * sourcesockaddr = (struct sockaddr *) &sourcesockaddr_struct;
! 183: struct sockaddr * remotesockaddr = (struct sockaddr *) &remotesockaddr_struct;
! 184: struct sockaddr_in * ssa4 = (struct sockaddr_in *) &sourcesockaddr_struct;
! 185: struct sockaddr_in * rsa4 = (struct sockaddr_in *) &remotesockaddr_struct;
! 186:
! 187: ip_t * sourceaddress;
! 188: ip_t * remoteaddress;
! 189:
! 190: /* XXX How do I code this to be IPV6 compatible??? */
! 191: #ifdef ENABLE_IPV6
! 192: char localaddr[INET6_ADDRSTRLEN];
! 193: #else
! 194: #ifndef INET_ADDRSTRLEN
! 195: #define INET_ADDRSTRLEN 16
! 196: #endif
! 197: char localaddr[INET_ADDRSTRLEN];
! 198: #endif
! 199:
! 200: static int batch_at = 0;
! 201: static int numhosts = 10;
! 202:
! 203: extern int fstTTL; /* initial hub(ttl) to ping byMin */
! 204: extern int maxTTL; /* last hub to ping byMin*/
! 205: extern int cpacketsize; /* packet size used by ping */
! 206: static int packetsize; /* packet size used by ping */
! 207: extern int bitpattern; /* packet bit pattern used by ping */
! 208: extern int tos; /* type of service set in ping packet*/
! 209: extern int af; /* address family of remote target */
! 210: extern int mtrtype; /* type of query packet used */
! 211: extern int remoteport; /* target port for TCP tracing */
! 212: extern int timeout; /* timeout for TCP connections */
! 213:
! 214: /* return the number of microseconds to wait before sending the next
! 215: ping */
! 216: int calc_deltatime (float waittime)
! 217: {
! 218: waittime /= numhosts;
! 219: return 1000000 * waittime;
! 220: }
! 221:
! 222:
! 223: /* This doesn't work for odd sz. I don't know enough about this to say
! 224: that this is wrong. It doesn't seem to cripple mtr though. -- REW */
! 225: int checksum(void *data, int sz)
! 226: {
! 227: unsigned short *ch;
! 228: unsigned int sum;
! 229:
! 230: sum = 0;
! 231: ch = data;
! 232: sz = sz / 2;
! 233: while (sz--) {
! 234: sum += *(ch++);
! 235: }
! 236:
! 237: sum = (sum >> 16) + (sum & 0xffff);
! 238:
! 239: return (~sum & 0xffff);
! 240: }
! 241:
! 242:
! 243: /* Prepend pseudoheader to the udp datagram and calculate checksum */
! 244: int udp_checksum(void *pheader, void *udata, int psize, int dsize)
! 245: {
! 246: unsigned int tsize = psize + dsize;
! 247: char csumpacket[tsize];
! 248: memset(csumpacket, (unsigned char) abs(bitpattern), abs(tsize));
! 249:
! 250: struct UDPv4PHeader *prepend = (struct UDPv4PHeader *) csumpacket;
! 251: struct UDPv4PHeader *udppheader = (struct UDPv4PHeader *) pheader;
! 252: prepend->saddr = udppheader->saddr;
! 253: prepend->daddr = udppheader->daddr;
! 254: prepend->zero = 0;
! 255: prepend->protocol = udppheader->protocol;
! 256: prepend->len = udppheader->len;
! 257:
! 258: struct UDPHeader *content = (struct UDPHeader *)(csumpacket + psize);
! 259: struct UDPHeader *udpdata = (struct UDPHeader *) udata;
! 260: content->srcport = udpdata->srcport;
! 261: content->dstport = udpdata->dstport;
! 262: content->length = udpdata->length;
! 263: content->checksum = udpdata->checksum;
! 264:
! 265: return checksum(csumpacket,tsize);
! 266: }
! 267:
! 268:
! 269: void save_sequence(int index, int seq)
! 270: {
! 271: sequence[seq].index = index;
! 272: sequence[seq].transit = 1;
! 273: sequence[seq].saved_seq = ++host[index].xmit;
! 274: memset(&sequence[seq].time, 0, sizeof(sequence[seq].time));
! 275:
! 276: host[index].transit = 1;
! 277: if (host[index].sent)
! 278: host[index].up = 0;
! 279: host[index].sent = 1;
! 280: net_save_xmit(index);
! 281: }
! 282:
! 283: int new_sequence(int index)
! 284: {
! 285: static int next_sequence = MinSequence;
! 286: int seq;
! 287:
! 288: seq = next_sequence++;
! 289: if (next_sequence >= MaxSequence)
! 290: next_sequence = MinSequence;
! 291:
! 292: save_sequence(index, seq);
! 293:
! 294: return seq;
! 295: }
! 296:
! 297: /* Attempt to connect to a TCP port with a TTL */
! 298: void net_send_tcp(int index)
! 299: {
! 300: int ttl, s;
! 301: int opt = 1;
! 302: int port;
! 303: struct sockaddr_storage local;
! 304: struct sockaddr_storage remote;
! 305: struct sockaddr_in *local4 = (struct sockaddr_in *) &local;
! 306: struct sockaddr_in6 *local6 = (struct sockaddr_in6 *) &local;
! 307: struct sockaddr_in *remote4 = (struct sockaddr_in *) &remote;
! 308: struct sockaddr_in6 *remote6 = (struct sockaddr_in6 *) &remote;
! 309: socklen_t len;
! 310:
! 311: ttl = index + 1;
! 312:
! 313: s = socket(af, SOCK_STREAM, 0);
! 314: if (s < 0) {
! 315: display_clear();
! 316: perror("socket()");
! 317: exit(EXIT_FAILURE);
! 318: }
! 319:
! 320: memset(&local, 0, sizeof (local));
! 321: memset(&remote, 0, sizeof (remote));
! 322: local.ss_family = af;
! 323: remote.ss_family = af;
! 324:
! 325: switch (af) {
! 326: case AF_INET:
! 327: addrcpy((void *) &local4->sin_addr, (void *) &ssa4->sin_addr, af);
! 328: addrcpy((void *) &remote4->sin_addr, (void *) remoteaddress, af);
! 329: remote4->sin_port = htons(remoteport);
! 330: break;
! 331: #ifdef ENABLE_IPV6
! 332: case AF_INET6:
! 333: addrcpy((void *) &local6->sin6_addr, (void *) &ssa6->sin6_addr, af);
! 334: addrcpy((void *) &remote6->sin6_addr, (void *) remoteaddress, af);
! 335: remote6->sin6_port = htons(remoteport);
! 336: break;
! 337: #endif
! 338: }
! 339:
! 340: if (bind(s, (struct sockaddr *) &local, sizeof (local))) {
! 341: display_clear();
! 342: perror("bind()");
! 343: exit(EXIT_FAILURE);
! 344: }
! 345:
! 346: len = sizeof (local);
! 347: if (getsockname(s, (struct sockaddr *) &local, &len)) {
! 348: display_clear();
! 349: perror("getsockname()");
! 350: exit(EXIT_FAILURE);
! 351: }
! 352:
! 353: opt = 1;
! 354: if (ioctl(s, FIONBIO, &opt)) {
! 355: display_clear();
! 356: perror("ioctl FIONBIO");
! 357: exit(EXIT_FAILURE);
! 358: }
! 359:
! 360: switch (af) {
! 361: case AF_INET:
! 362: if (setsockopt(s, IPPROTO_IP, IP_TTL, &ttl, sizeof (ttl))) {
! 363: display_clear();
! 364: perror("setsockopt IP_TTL");
! 365: exit(EXIT_FAILURE);
! 366: }
! 367: if (setsockopt(s, IPPROTO_IP, IP_TOS, &tos, sizeof (tos))) {
! 368: display_clear();
! 369: perror("setsockopt IP_TOS");
! 370: exit(EXIT_FAILURE);
! 371: }
! 372: break;
! 373: #ifdef ENABLE_IPV6
! 374: case AF_INET6:
! 375: if (setsockopt(s, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof (ttl))) {
! 376: display_clear();
! 377: perror("setsockopt IP_TTL");
! 378: exit(EXIT_FAILURE);
! 379: }
! 380: break;
! 381: #endif
! 382: }
! 383:
! 384: switch (local.ss_family) {
! 385: case AF_INET:
! 386: port = ntohs(local4->sin_port);
! 387: break;
! 388: #ifdef ENABLE_IPV6
! 389: case AF_INET6:
! 390: port = ntohs(local6->sin6_port);
! 391: break;
! 392: #endif
! 393: default:
! 394: display_clear();
! 395: perror("unknown AF?");
! 396: exit(EXIT_FAILURE);
! 397: }
! 398:
! 399: save_sequence(index, port);
! 400: gettimeofday(&sequence[port].time, NULL);
! 401: sequence[port].socket = s;
! 402:
! 403: connect(s, (struct sockaddr *) &remote, sizeof (remote));
! 404: }
! 405:
! 406: /* Attempt to find the host at a particular number of hops away */
! 407: void net_send_query(int index)
! 408: {
! 409: if (mtrtype == IPPROTO_TCP) {
! 410: net_send_tcp(index);
! 411: return;
! 412: }
! 413:
! 414: /*ok char packet[sizeof(struct IPHeader) + sizeof(struct ICMPHeader)];*/
! 415: char packet[MAXPACKET];
! 416: struct IPHeader *ip = (struct IPHeader *) packet;
! 417: struct ICMPHeader *icmp = NULL;
! 418: struct UDPHeader *udp = NULL;
! 419: struct UDPv4PHeader *udpp = NULL;
! 420: uint16 mypid;
! 421:
! 422: /*ok int packetsize = sizeof(struct IPHeader) + sizeof(struct ICMPHeader) + datasize;*/
! 423: int rv;
! 424: static int first=1;
! 425: int ttl, iphsize = 0, echotype = 0, salen = 0;
! 426:
! 427: ttl = index + 1;
! 428:
! 429: #ifdef ENABLE_IPV6
! 430: /* offset for ipv6 checksum calculation */
! 431: int offset = 6;
! 432: #endif
! 433:
! 434: if ( packetsize < MINPACKET ) packetsize = MINPACKET;
! 435: if ( packetsize > MAXPACKET ) packetsize = MAXPACKET;
! 436:
! 437: memset(packet, (unsigned char) abs(bitpattern), abs(packetsize));
! 438:
! 439: switch ( af ) {
! 440: case AF_INET:
! 441: #if !defined(IP_HDRINCL) && defined(IP_TOS) && defined(IP_TTL)
! 442: iphsize = 0;
! 443: if ( setsockopt( sendsock, IPPROTO_IP, IP_TOS, &tos, sizeof tos ) ) {
! 444: perror( "setsockopt IP_TOS" );
! 445: exit( EXIT_FAILURE );
! 446: }
! 447: if ( setsockopt( sendsock, IPPROTO_IP, IP_TTL, &ttl, sizeof ttl ) ) {
! 448: perror( "setsockopt IP_TTL" );
! 449: exit( EXIT_FAILURE );
! 450: }
! 451: #else
! 452: iphsize = sizeof (struct IPHeader);
! 453:
! 454: ip->version = 0x45;
! 455: ip->tos = tos;
! 456: ip->len = BSDfix ? abs(packetsize): htons (abs(packetsize));
! 457: ip->id = 0;
! 458: ip->frag = 0; /* 1, if want to find mtu size? Min */
! 459: ip->ttl = ttl;
! 460: ip->protocol = mtrtype;
! 461: ip->check = 0;
! 462:
! 463: /* BSD needs the source address here, Linux & others do not... */
! 464: addrcpy( (void *) &(ip->saddr), (void *) &(ssa4->sin_addr), AF_INET );
! 465: addrcpy( (void *) &(ip->daddr), (void *) remoteaddress, AF_INET );
! 466: #endif
! 467: echotype = ICMP_ECHO;
! 468: salen = sizeof (struct sockaddr_in);
! 469: break;
! 470: #ifdef ENABLE_IPV6
! 471: case AF_INET6:
! 472: iphsize = 0;
! 473: if ( setsockopt( sendsock, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
! 474: &ttl, sizeof ttl ) ) {
! 475: perror( "setsockopt IPV6_UNICAST_HOPS" );
! 476: exit( EXIT_FAILURE);
! 477: }
! 478: echotype = ICMP6_ECHO_REQUEST;
! 479: salen = sizeof (struct sockaddr_in6);
! 480: break;
! 481: #endif
! 482: }
! 483:
! 484: switch ( mtrtype ) {
! 485: case IPPROTO_ICMP:
! 486: icmp = (struct ICMPHeader *)(packet + iphsize);
! 487: icmp->type = echotype;
! 488: icmp->code = 0;
! 489: icmp->checksum = 0;
! 490: icmp->id = getpid();
! 491: icmp->sequence = new_sequence(index);
! 492: icmp->checksum = checksum(icmp, abs(packetsize) - iphsize);
! 493:
! 494: gettimeofday(&sequence[icmp->sequence].time, NULL);
! 495: break;
! 496:
! 497: case IPPROTO_UDP:
! 498: udp = (struct UDPHeader *)(packet + iphsize);
! 499: udp->checksum = 0;
! 500: mypid = (uint16)getpid();
! 501: if (mypid < MinPort)
! 502: mypid += MinPort;
! 503:
! 504: udp->srcport = htons(mypid);
! 505: udp->length = abs(packetsize) - iphsize;
! 506: if(!BSDfix)
! 507: udp->length = htons(udp->length);
! 508:
! 509: udp->dstport = new_sequence(index);
! 510: gettimeofday(&sequence[udp->dstport].time, NULL);
! 511: udp->dstport = htons(udp->dstport);
! 512: break;
! 513: }
! 514:
! 515: switch ( af ) {
! 516: case AF_INET:
! 517: switch ( mtrtype ) {
! 518: case IPPROTO_UDP:
! 519: /* checksum is not mandatory. only calculate if we know ip->saddr */
! 520: if (ip->saddr) {
! 521: udpp = (struct UDPv4PHeader *)(malloc(sizeof(struct UDPv4PHeader)));
! 522: udpp->saddr = ip->saddr;
! 523: udpp->daddr = ip->daddr;
! 524: udpp->protocol = ip->protocol;
! 525: udpp->len = udp->length;
! 526: udp->checksum = udp_checksum(udpp, udp, sizeof(struct UDPv4PHeader), abs(packetsize) - iphsize);
! 527: }
! 528: break;
! 529: }
! 530:
! 531: ip->check = checksum(packet, abs(packetsize));
! 532: break;
! 533: #ifdef ENABLE_IPV6
! 534: case AF_INET6:
! 535: switch ( mtrtype ) {
! 536: case IPPROTO_UDP:
! 537: /* kernel checksum calculation */
! 538: if ( setsockopt(sendsock, IPPROTO_IPV6, IPV6_CHECKSUM, &offset, sizeof(offset)) ) {
! 539: perror( "setsockopt IPV6_CHECKSUM" );
! 540: exit( EXIT_FAILURE);
! 541: }
! 542: break;
! 543: }
! 544: break;
! 545: #endif
! 546: }
! 547:
! 548: rv = sendto(sendsock, packet, abs(packetsize), 0,
! 549: remotesockaddr, salen);
! 550: if (first && (rv < 0) && ((errno == EINVAL) || (errno == EMSGSIZE))) {
! 551: /* Try the first packet again using host byte order. */
! 552: ip->len = abs (packetsize);
! 553: rv = sendto(sendsock, packet, abs(packetsize), 0,
! 554: remotesockaddr, salen);
! 555: if (rv >= 0) {
! 556: BSDfix = 1;
! 557: }
! 558: }
! 559: first = 0;
! 560: }
! 561:
! 562:
! 563: /* We got a return on something we sent out. Record the address and
! 564: time. */
! 565: void net_process_ping(int seq, struct mplslen mpls, void * addr, struct timeval now)
! 566: {
! 567: int index;
! 568: int totusec;
! 569: int oldavg; /* usedByMin */
! 570: int oldjavg; /* usedByMin */
! 571: int i; /* usedByMin */
! 572: #ifdef ENABLE_IPV6
! 573: char addrcopy[sizeof(struct in6_addr)];
! 574: #else
! 575: char addrcopy[sizeof(struct in_addr)];
! 576: #endif
! 577:
! 578: /* Copy the from address ASAP because it can be overwritten */
! 579: addrcpy( (void *) &addrcopy, addr, af );
! 580:
! 581: if (seq < 0 || seq >= MaxSequence)
! 582: return;
! 583:
! 584: if (!sequence[seq].transit)
! 585: return;
! 586: sequence[seq].transit = 0;
! 587:
! 588: if (sequence[seq].socket > 0) {
! 589: close(sequence[seq].socket);
! 590: sequence[seq].socket = 0;
! 591: }
! 592:
! 593: index = sequence[seq].index;
! 594:
! 595: totusec = (now.tv_sec - sequence[seq].time.tv_sec ) * 1000000 +
! 596: (now.tv_usec - sequence[seq].time.tv_usec);
! 597: /* impossible? if( totusec < 0 ) totusec = 0 */;
! 598:
! 599: if ( addrcmp( (void *) &(host[index].addr),
! 600: (void *) &unspec_addr, af ) == 0 ) {
! 601: /* should be out of if as addr can change */
! 602: addrcpy( (void *) &(host[index].addr), addrcopy, af );
! 603: host[index].mpls = mpls;
! 604: display_rawhost(index, (void *) &(host[index].addr));
! 605:
! 606: /* multi paths */
! 607: addrcpy( (void *) &(host[index].addrs[0]), addrcopy, af );
! 608: host[index].mplss[0] = mpls;
! 609: } else {
! 610: for( i=0; i<MAXPATH; ) {
! 611: if( addrcmp( (void *) &(host[index].addrs[i]), (void *) &addrcopy,
! 612: af ) == 0 ||
! 613: addrcmp( (void *) &(host[index].addrs[i]),
! 614: (void *) &unspec_addr, af ) == 0 ) break;
! 615: i++;
! 616: }
! 617: if( addrcmp( (void *) &(host[index].addrs[i]), addrcopy, af ) != 0 &&
! 618: i<MAXPATH ) {
! 619: addrcpy( (void *) &(host[index].addrs[i]), addrcopy, af );
! 620: host[index].mplss[i] = mpls;
! 621: display_rawhost(index, (void *) &(host[index].addrs[i]));
! 622: }
! 623: }
! 624:
! 625: host[index].jitter = totusec - host[index].last;
! 626: if (host[index].jitter < 0 ) host[index].jitter = - host[index].jitter;
! 627: host[index].last = totusec;
! 628:
! 629: if (host[index].returned < 1) {
! 630: host[index].best = host[index].worst = host[index].gmean = totusec;
! 631: host[index].avg = host[index].var = 0;
! 632:
! 633: host[index].jitter = host[index].jworst = host[index].jinta= 0;
! 634: }
! 635:
! 636: /* some time best can be too good to be true, experienced
! 637: * at least in linux 2.4.x.
! 638: * safe guard 1) best[index]>=best[index-1] if index>0
! 639: * 2) best >= average-20,000 usec (good number?)
! 640: if (index > 0) {
! 641: if (totusec < host[index].best &&
! 642: totusec>= host[index-1].best) host[index].best = totusec;
! 643: } else {
! 644: if(totusec < host[index].best) host[index].best = totusec;
! 645: }
! 646: */
! 647: if (totusec < host[index].best ) host[index].best = totusec;
! 648: if (totusec > host[index].worst) host[index].worst = totusec;
! 649:
! 650: if (host[index].jitter > host[index].jworst)
! 651: host[index].jworst = host[index].jitter;
! 652:
! 653: host[index].returned++;
! 654: oldavg = host[index].avg;
! 655: host[index].avg += (totusec - oldavg +.0) / host[index].returned;
! 656: host[index].var += (totusec - oldavg +.0) * (totusec - host[index].avg) / 1000000;
! 657:
! 658: oldjavg = host[index].javg;
! 659: host[index].javg += (host[index].jitter - oldjavg) / host[index].returned;
! 660: /* below algorithm is from rfc1889, A.8 */
! 661: host[index].jinta += host[index].jitter - ((host[index].jinta + 8) >> 4);
! 662:
! 663: if ( host[index].returned > 1 )
! 664: host[index].gmean = pow( (double) host[index].gmean, (host[index].returned-1.0)/host[index].returned )
! 665: * pow( (double) totusec, 1.0/host[index].returned );
! 666: host[index].sent = 0;
! 667: host[index].up = 1;
! 668: host[index].transit = 0;
! 669:
! 670: net_save_return(index, sequence[seq].saved_seq, totusec);
! 671: display_rawping(index, totusec);
! 672: }
! 673:
! 674:
! 675: /* We know a packet has come in, because the main select loop has called us,
! 676: now we just need to read it, see if it is for us, and if it is a reply
! 677: to something we sent, then call net_process_ping() */
! 678: void net_process_return(void)
! 679: {
! 680: char packet[MAXPACKET];
! 681: #ifdef ENABLE_IPV6
! 682: struct sockaddr_storage fromsockaddr_struct;
! 683: struct sockaddr_in6 * fsa6 = (struct sockaddr_in6 *) &fromsockaddr_struct;
! 684: #else
! 685: struct sockaddr_in fromsockaddr_struct;
! 686: #endif
! 687: struct sockaddr * fromsockaddr = (struct sockaddr *) &fromsockaddr_struct;
! 688: struct sockaddr_in * fsa4 = (struct sockaddr_in *) &fromsockaddr_struct;
! 689: socklen_t fromsockaddrsize;
! 690: int num;
! 691: struct ICMPHeader *header = NULL;
! 692: struct UDPHeader *udpheader = NULL;
! 693: struct TCPHeader *tcpheader = NULL;
! 694: struct timeval now;
! 695: ip_t * fromaddress = NULL;
! 696: int echoreplytype = 0, timeexceededtype = 0, unreachabletype = 0;
! 697: int sequence = 0;
! 698:
! 699: /* MPLS decoding */
! 700: struct mplslen mpls;
! 701: mpls.labels = 0;
! 702:
! 703: gettimeofday(&now, NULL);
! 704: switch ( af ) {
! 705: case AF_INET:
! 706: fromsockaddrsize = sizeof (struct sockaddr_in);
! 707: fromaddress = (ip_t *) &(fsa4->sin_addr);
! 708: echoreplytype = ICMP_ECHOREPLY;
! 709: timeexceededtype = ICMP_TIME_EXCEEDED;
! 710: unreachabletype = ICMP_UNREACHABLE;
! 711: break;
! 712: #ifdef ENABLE_IPV6
! 713: case AF_INET6:
! 714: fromsockaddrsize = sizeof (struct sockaddr_in6);
! 715: fromaddress = (ip_t *) &(fsa6->sin6_addr);
! 716: echoreplytype = ICMP6_ECHO_REPLY;
! 717: timeexceededtype = ICMP6_TIME_EXCEEDED;
! 718: unreachabletype = ICMP6_DST_UNREACH;
! 719: break;
! 720: #endif
! 721: }
! 722:
! 723: num = recvfrom(recvsock, packet, MAXPACKET, 0,
! 724: fromsockaddr, &fromsockaddrsize);
! 725:
! 726: switch ( af ) {
! 727: case AF_INET:
! 728: if((size_t) num < sizeof(struct IPHeader) + sizeof(struct ICMPHeader))
! 729: return;
! 730: header = (struct ICMPHeader *)(packet + sizeof(struct IPHeader));
! 731: break;
! 732: #ifdef ENABLE_IPV6
! 733: case AF_INET6:
! 734: if(num < sizeof(struct ICMPHeader))
! 735: return;
! 736:
! 737: header = (struct ICMPHeader *) packet;
! 738: break;
! 739: #endif
! 740: }
! 741:
! 742: switch ( mtrtype ) {
! 743: case IPPROTO_ICMP:
! 744: if (header->type == echoreplytype) {
! 745: if(header->id != (uint16)getpid())
! 746: return;
! 747:
! 748: sequence = header->sequence;
! 749: } else if (header->type == timeexceededtype) {
! 750: switch ( af ) {
! 751: case AF_INET:
! 752:
! 753: if ((size_t) num < sizeof(struct IPHeader) +
! 754: sizeof(struct ICMPHeader) +
! 755: sizeof (struct IPHeader) +
! 756: sizeof (struct ICMPHeader))
! 757: return;
! 758: header = (struct ICMPHeader *)(packet + sizeof (struct IPHeader) +
! 759: sizeof (struct ICMPHeader) +
! 760: sizeof (struct IPHeader));
! 761:
! 762: if(num > 160)
! 763: decodempls(num, packet, &mpls, 156);
! 764:
! 765: break;
! 766: #ifdef ENABLE_IPV6
! 767: case AF_INET6:
! 768: if ( num < sizeof (struct ICMPHeader) +
! 769: sizeof (struct ip6_hdr) + sizeof (struct ICMPHeader) )
! 770: return;
! 771: header = (struct ICMPHeader *) ( packet +
! 772: sizeof (struct ICMPHeader) +
! 773: sizeof (struct ip6_hdr) );
! 774:
! 775: if(num > 140)
! 776: decodempls(num, packet, &mpls, 136);
! 777:
! 778: break;
! 779: #endif
! 780: }
! 781:
! 782: if (header->id != (uint16)getpid())
! 783: return;
! 784:
! 785: sequence = header->sequence;
! 786: }
! 787: break;
! 788:
! 789: case IPPROTO_UDP:
! 790: if (header->type == timeexceededtype || header->type == unreachabletype) {
! 791: switch ( af ) {
! 792: case AF_INET:
! 793:
! 794: if ((size_t) num < sizeof(struct IPHeader) +
! 795: sizeof(struct ICMPHeader) +
! 796: sizeof (struct IPHeader) +
! 797: sizeof (struct UDPHeader))
! 798: return;
! 799: udpheader = (struct UDPHeader *)(packet + sizeof (struct IPHeader) +
! 800: sizeof (struct ICMPHeader) +
! 801: sizeof (struct IPHeader));
! 802:
! 803: if(num > 160)
! 804: decodempls(num, packet, &mpls, 156);
! 805:
! 806: break;
! 807: #ifdef ENABLE_IPV6
! 808: case AF_INET6:
! 809: if ( num < sizeof (struct ICMPHeader) +
! 810: sizeof (struct ip6_hdr) + sizeof (struct UDPHeader) )
! 811: return;
! 812: udpheader = (struct UDPHeader *) ( packet +
! 813: sizeof (struct ICMPHeader) +
! 814: sizeof (struct ip6_hdr) );
! 815:
! 816: if(num > 140)
! 817: decodempls(num, packet, &mpls, 136);
! 818:
! 819: break;
! 820: #endif
! 821: }
! 822: sequence = ntohs(udpheader->dstport);
! 823: }
! 824: break;
! 825:
! 826: case IPPROTO_TCP:
! 827: if (header->type == timeexceededtype || header->type == unreachabletype) {
! 828: switch ( af ) {
! 829: case AF_INET:
! 830:
! 831: if ((size_t) num < sizeof(struct IPHeader) +
! 832: sizeof(struct ICMPHeader) +
! 833: sizeof (struct IPHeader) +
! 834: sizeof (struct TCPHeader))
! 835: return;
! 836: tcpheader = (struct TCPHeader *)(packet + sizeof (struct IPHeader) +
! 837: sizeof (struct ICMPHeader) +
! 838: sizeof (struct IPHeader));
! 839:
! 840: if(num > 160)
! 841: decodempls(num, packet, &mpls, 156);
! 842:
! 843: break;
! 844: #ifdef ENABLE_IPV6
! 845: case AF_INET6:
! 846: if ( num < sizeof (struct ICMPHeader) +
! 847: sizeof (struct ip6_hdr) + sizeof (struct TCPHeader) )
! 848: return;
! 849: tcpheader = (struct TCPHeader *) ( packet +
! 850: sizeof (struct ICMPHeader) +
! 851: sizeof (struct ip6_hdr) );
! 852:
! 853: if(num > 140)
! 854: decodempls(num, packet, &mpls, 136);
! 855:
! 856: break;
! 857: #endif
! 858: }
! 859: sequence = ntohs(tcpheader->srcport);
! 860: }
! 861: break;
! 862: }
! 863:
! 864: if (sequence)
! 865: net_process_ping (sequence, mpls, (void *) fromaddress, now);
! 866: }
! 867:
! 868:
! 869: ip_t *net_addr(int at)
! 870: {
! 871: return (ip_t *)&(host[at].addr);
! 872: }
! 873:
! 874:
! 875: ip_t *net_addrs(int at, int i)
! 876: {
! 877: return (ip_t *)&(host[at].addrs[i]);
! 878: }
! 879:
! 880: void *net_mpls(int at)
! 881: {
! 882: return (struct mplslen *)&(host[at].mplss);
! 883: }
! 884:
! 885: void *net_mplss(int at, int i)
! 886: {
! 887: return (struct mplslen *)&(host[at].mplss[i]);
! 888: }
! 889:
! 890: int net_loss(int at)
! 891: {
! 892: if ((host[at].xmit - host[at].transit) == 0)
! 893: return 0;
! 894: /* times extra 1000 */
! 895: return 1000*(100 - (100.0 * host[at].returned / (host[at].xmit - host[at].transit)) );
! 896: }
! 897:
! 898:
! 899: int net_drop(int at)
! 900: {
! 901: return (host[at].xmit - host[at].transit) - host[at].returned;
! 902: }
! 903:
! 904:
! 905: int net_last(int at)
! 906: {
! 907: return (host[at].last);
! 908: }
! 909:
! 910:
! 911: int net_best(int at)
! 912: {
! 913: return (host[at].best);
! 914: }
! 915:
! 916:
! 917: int net_worst(int at)
! 918: {
! 919: return (host[at].worst);
! 920: }
! 921:
! 922:
! 923: int net_avg(int at)
! 924: {
! 925: return (host[at].avg);
! 926: }
! 927:
! 928:
! 929: int net_gmean(int at)
! 930: {
! 931: return (host[at].gmean);
! 932: }
! 933:
! 934:
! 935: int net_stdev(int at)
! 936: {
! 937: if( host[at].returned > 1 ) {
! 938: return ( 1000.0 * sqrt( host[at].var/(host[at].returned -1.0) ) );
! 939: } else {
! 940: return( 0 );
! 941: }
! 942: }
! 943:
! 944:
! 945: int net_jitter(int at)
! 946: {
! 947: return (host[at].jitter);
! 948: }
! 949:
! 950:
! 951: int net_jworst(int at)
! 952: {
! 953: return (host[at].jworst);
! 954: }
! 955:
! 956:
! 957: int net_javg(int at)
! 958: {
! 959: return (host[at].javg);
! 960: }
! 961:
! 962:
! 963: int net_jinta(int at)
! 964: {
! 965: return (host[at].jinta);
! 966: }
! 967:
! 968:
! 969: int net_max(void)
! 970: {
! 971: int at;
! 972: int max;
! 973:
! 974: max = 0;
! 975: /* for(at = 0; at < MaxHost-2; at++) { */
! 976: for(at = 0; at < maxTTL-1; at++) {
! 977: if ( addrcmp( (void *) &(host[at].addr),
! 978: (void *) remoteaddress, af ) == 0 ) {
! 979: return at + 1;
! 980: } else if ( addrcmp( (void *) &(host[at].addr),
! 981: (void *) &unspec_addr, af ) != 0 ) {
! 982: max = at + 2;
! 983: }
! 984: }
! 985:
! 986: return max;
! 987: }
! 988:
! 989:
! 990: int net_min (void)
! 991: {
! 992: return ( fstTTL - 1 );
! 993: }
! 994:
! 995:
! 996: int net_returned(int at)
! 997: {
! 998: return host[at].returned;
! 999: }
! 1000:
! 1001:
! 1002: int net_xmit(int at)
! 1003: {
! 1004: return host[at].xmit;
! 1005: }
! 1006:
! 1007:
! 1008: int net_transit(int at)
! 1009: {
! 1010: return host[at].transit;
! 1011: }
! 1012:
! 1013:
! 1014: int net_up(int at)
! 1015: {
! 1016: return host[at].up;
! 1017: }
! 1018:
! 1019:
! 1020: char * net_localaddr (void)
! 1021: {
! 1022: return localaddr;
! 1023: }
! 1024:
! 1025:
! 1026: void net_end_transit(void)
! 1027: {
! 1028: int at;
! 1029:
! 1030: for(at = 0; at < MaxHost; at++) {
! 1031: host[at].transit = 0;
! 1032: }
! 1033: }
! 1034:
! 1035: int net_send_batch(void)
! 1036: {
! 1037: int n_unknown=0, i;
! 1038:
! 1039: /* randomized packet size and/or bit pattern if packetsize<0 and/or
! 1040: bitpattern<0. abs(packetsize) and/or abs(bitpattern) will be used
! 1041: */
! 1042: if( batch_at < fstTTL ) {
! 1043: if( cpacketsize < 0 ) {
! 1044: /* Someone used a formula here that tried to correct for the
! 1045: "end-error" in "rand()". By "end-error" I mean that if you
! 1046: have a range for "rand()" that runs to 32768, and the
! 1047: destination range is 10000, you end up with 4 out of 32768
! 1048: 0-2768's and only 3 out of 32768 for results 2769 .. 9999.
! 1049: As our detination range (in the example 10000) is much
! 1050: smaller (reasonable packet sizes), and our rand() range much
! 1051: larger, this effect is insignificant. Oh! That other formula
! 1052: didn't work. */
! 1053: packetsize = MINPACKET + rand () % (-cpacketsize - MINPACKET);
! 1054: } else {
! 1055: packetsize = cpacketsize;
! 1056: }
! 1057: if( bitpattern < 0 ) {
! 1058: bitpattern = - (int)(256 + 255*(rand()/(RAND_MAX+0.1)));
! 1059: }
! 1060: }
! 1061:
! 1062: /* printf ("cpacketsize = %d, packetsize = %d\n", cpacketsize, packetsize); */
! 1063:
! 1064: net_send_query(batch_at);
! 1065:
! 1066: for (i=fstTTL-1;i<batch_at;i++) {
! 1067: if ( addrcmp( (void *) &(host[i].addr), (void *) &unspec_addr, af ) == 0 )
! 1068: n_unknown++;
! 1069:
! 1070: /* The second condition in the next "if" statement was added in mtr-0.56,
! 1071: but I don't remember why. It makes mtr stop skipping sections of unknown
! 1072: hosts. Removed in 0.65.
! 1073: If the line proves neccesary, it should at least NOT trigger that line
! 1074: when host[i].addr == 0 */
! 1075: if ( ( addrcmp( (void *) &(host[i].addr),
! 1076: (void *) remoteaddress, af ) == 0 )
! 1077: /* || (host[i].addr == host[batch_at].addr) */)
! 1078: n_unknown = MaxHost; /* Make sure we drop into "we should restart" */
! 1079: }
! 1080:
! 1081: if ( /* success in reaching target */
! 1082: ( addrcmp( (void *) &(host[batch_at].addr),
! 1083: (void *) remoteaddress, af ) == 0 ) ||
! 1084: /* fail in consecuitive MAX_UNKNOWN_HOSTS (firewall?) */
! 1085: (n_unknown > MAX_UNKNOWN_HOSTS) ||
! 1086: /* or reach limit */
! 1087: (batch_at >= maxTTL-1)) {
! 1088: numhosts = batch_at+1;
! 1089: batch_at = fstTTL - 1;
! 1090: return 1;
! 1091: }
! 1092:
! 1093: batch_at++;
! 1094: return 0;
! 1095: }
! 1096:
! 1097:
! 1098: static void set_fd_flags(int fd)
! 1099: {
! 1100: #if defined(HAVE_FCNTL) && defined(FD_CLOEXEC)
! 1101: int oldflags;
! 1102:
! 1103: if (fd < 0) return;
! 1104:
! 1105: oldflags = fcntl(fd, F_GETFD);
! 1106: if (oldflags == -1) {
! 1107: perror("Couldn't get fd's flags");
! 1108: return;
! 1109: }
! 1110: if (fcntl(fd, F_SETFD, oldflags | FD_CLOEXEC))
! 1111: perror("Couldn't set fd's flags");
! 1112: #endif
! 1113: }
! 1114:
! 1115: int net_preopen(void)
! 1116: {
! 1117: int trueopt = 1;
! 1118:
! 1119: #if !defined(IP_HDRINCL) && defined(IP_TOS) && defined(IP_TTL)
! 1120: sendsock4_icmp = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
! 1121: sendsock4_udp = socket(AF_INET, SOCK_RAW, IPPROTO_UDP);
! 1122: #else
! 1123: sendsock4 = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
! 1124: #endif
! 1125: if (sendsock4 < 0)
! 1126: return -1;
! 1127: #ifdef ENABLE_IPV6
! 1128: sendsock6_icmp = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
! 1129: sendsock6_udp = socket(AF_INET6, SOCK_RAW, IPPROTO_UDP);
! 1130: #endif
! 1131:
! 1132: #ifdef IP_HDRINCL
! 1133: /* FreeBSD wants this to avoid sending out packets with protocol type RAW
! 1134: to the network. */
! 1135: if (setsockopt(sendsock4, SOL_IP, IP_HDRINCL, &trueopt, sizeof(trueopt))) {
! 1136: perror("setsockopt(IP_HDRINCL,1)");
! 1137: return -1;
! 1138: }
! 1139: #endif /* IP_HDRINCL */
! 1140:
! 1141: recvsock4 = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
! 1142: if (recvsock4 < 0)
! 1143: return -1;
! 1144: set_fd_flags(recvsock4);
! 1145: #ifdef ENABLE_IPV6
! 1146: recvsock6 = socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
! 1147: if (recvsock6 >= 0)
! 1148: set_fd_flags(recvsock6);
! 1149: #endif
! 1150:
! 1151: return 0;
! 1152: }
! 1153:
! 1154:
! 1155: int net_selectsocket(void)
! 1156: {
! 1157: #if !defined(IP_HDRINCL) && defined(IP_TOS) && defined(IP_TTL)
! 1158: switch ( mtrtype ) {
! 1159: case IPPROTO_ICMP:
! 1160: sendsock4 = sendsock4_icmp;
! 1161: break;
! 1162: case IPPROTO_UDP:
! 1163: sendsock4 = sendsock4_udp;
! 1164: break;
! 1165: }
! 1166: #endif
! 1167: if (sendsock4 < 0)
! 1168: return -1;
! 1169: #ifdef ENABLE_IPV6
! 1170: switch ( mtrtype ) {
! 1171: case IPPROTO_ICMP:
! 1172: sendsock6 = sendsock6_icmp;
! 1173: break;
! 1174: case IPPROTO_UDP:
! 1175: sendsock6 = sendsock6_udp;
! 1176: break;
! 1177: }
! 1178: if ((sendsock6 < 0) && (sendsock4 < 0))
! 1179: return -1;
! 1180: #endif
! 1181:
! 1182: return 0;
! 1183: }
! 1184:
! 1185:
! 1186: int net_open(struct hostent * host)
! 1187: {
! 1188: #ifdef ENABLE_IPV6
! 1189: struct sockaddr_storage name_struct;
! 1190: #else
! 1191: struct sockaddr_in name_struct;
! 1192: #endif
! 1193: struct sockaddr * name = (struct sockaddr *) &name_struct;
! 1194: socklen_t len;
! 1195:
! 1196: net_reset();
! 1197:
! 1198: remotesockaddr->sa_family = host->h_addrtype;
! 1199:
! 1200: switch ( host->h_addrtype ) {
! 1201: case AF_INET:
! 1202: sendsock = sendsock4;
! 1203: recvsock = recvsock4;
! 1204: addrcpy( (void *) &(rsa4->sin_addr), host->h_addr, AF_INET );
! 1205: sourceaddress = (ip_t *) &(ssa4->sin_addr);
! 1206: remoteaddress = (ip_t *) &(rsa4->sin_addr);
! 1207: break;
! 1208: #ifdef ENABLE_IPV6
! 1209: case AF_INET6:
! 1210: if (sendsock6 < 0 || recvsock6 < 0) {
! 1211: fprintf( stderr, "Could not open IPv6 socket\n" );
! 1212: exit( EXIT_FAILURE );
! 1213: }
! 1214: sendsock = sendsock6;
! 1215: recvsock = recvsock6;
! 1216: addrcpy( (void *) &(rsa6->sin6_addr), host->h_addr, AF_INET6 );
! 1217: sourceaddress = (ip_t *) &(ssa6->sin6_addr);
! 1218: remoteaddress = (ip_t *) &(rsa6->sin6_addr);
! 1219: break;
! 1220: #endif
! 1221: default:
! 1222: fprintf( stderr, "net_open bad address type\n" );
! 1223: exit( EXIT_FAILURE );
! 1224: }
! 1225:
! 1226: len = sizeof name_struct;
! 1227: getsockname (recvsock, name, &len);
! 1228: sockaddrtop( name, localaddr, sizeof localaddr );
! 1229: #if 0
! 1230: printf ("got localaddr: %s\n", localaddr);
! 1231: #endif
! 1232:
! 1233: return 0;
! 1234: }
! 1235:
! 1236:
! 1237: void net_reopen(struct hostent * addr)
! 1238: {
! 1239: int at;
! 1240:
! 1241: for(at = 0; at < MaxHost; at++) {
! 1242: memset(&host[at], 0, sizeof(host[at]));
! 1243: }
! 1244:
! 1245: remotesockaddr->sa_family = addr->h_addrtype;
! 1246: addrcpy( (void *) remoteaddress, addr->h_addr, addr->h_addrtype );
! 1247:
! 1248: switch ( addr->h_addrtype ) {
! 1249: case AF_INET:
! 1250: addrcpy( (void *) &(rsa4->sin_addr), addr->h_addr, AF_INET );
! 1251: break;
! 1252: #ifdef ENABLE_IPV6
! 1253: case AF_INET6:
! 1254: addrcpy( (void *) &(rsa6->sin6_addr), addr->h_addr, AF_INET6 );
! 1255: break;
! 1256: #endif
! 1257: default:
! 1258: fprintf( stderr, "net_reopen bad address type\n" );
! 1259: exit( EXIT_FAILURE );
! 1260: }
! 1261:
! 1262: net_reset ();
! 1263: net_send_batch();
! 1264: }
! 1265:
! 1266:
! 1267: void net_reset(void)
! 1268: {
! 1269: int at;
! 1270: int i;
! 1271:
! 1272: batch_at = fstTTL - 1; /* above replacedByMin */
! 1273: numhosts = 10;
! 1274:
! 1275: for (at = 0; at < MaxHost; at++) {
! 1276: host[at].xmit = 0;
! 1277: host[at].transit = 0;
! 1278: host[at].returned = 0;
! 1279: host[at].sent = 0;
! 1280: host[at].up = 0;
! 1281: host[at].last = 0;
! 1282: host[at].avg = 0;
! 1283: host[at].best = 0;
! 1284: host[at].worst = 0;
! 1285: host[at].gmean = 0;
! 1286: host[at].var = 0;
! 1287: host[at].jitter = 0;
! 1288: host[at].javg = 0;
! 1289: host[at].jworst = 0;
! 1290: host[at].jinta = 0;
! 1291: for (i=0; i<SAVED_PINGS; i++) {
! 1292: host[at].saved[i] = -2; /* unsent */
! 1293: }
! 1294: host[at].saved_seq_offset = -SAVED_PINGS+2;
! 1295: }
! 1296:
! 1297: for (at = 0; at < MaxSequence; at++) {
! 1298: sequence[at].transit = 0;
! 1299: if (sequence[at].socket > 0) {
! 1300: close(sequence[at].socket);
! 1301: sequence[at].socket = 0;
! 1302: }
! 1303: }
! 1304:
! 1305: gettimeofday(&reset, NULL);
! 1306: }
! 1307:
! 1308:
! 1309: int net_set_interfaceaddress (char *InterfaceAddress)
! 1310: {
! 1311: int len = 0;
! 1312:
! 1313: if (!InterfaceAddress) return 0;
! 1314:
! 1315: sourcesockaddr->sa_family = af;
! 1316: switch ( af ) {
! 1317: case AF_INET:
! 1318: ssa4->sin_port = 0;
! 1319: if ( inet_aton( InterfaceAddress, &(ssa4->sin_addr) ) < 1 ) {
! 1320: fprintf( stderr, "mtr: bad interface address: %s\n", InterfaceAddress );
! 1321: return( 1 );
! 1322: }
! 1323: len = sizeof (struct sockaddr);
! 1324: break;
! 1325: #ifdef ENABLE_IPV6
! 1326: case AF_INET6:
! 1327: ssa6->sin6_port = 0;
! 1328: if ( inet_pton( af, InterfaceAddress, &(ssa6->sin6_addr) ) < 1 ) {
! 1329: fprintf( stderr, "mtr: bad interface address: %s\n", InterfaceAddress );
! 1330: return( 1 );
! 1331: }
! 1332: len = sizeof (struct sockaddr_in6);
! 1333: break;
! 1334: #endif
! 1335: }
! 1336:
! 1337: if ( bind( sendsock, sourcesockaddr, len ) == -1 ) {
! 1338: perror("mtr: failed to bind to interface");
! 1339: return( 1 );
! 1340: }
! 1341: return 0;
! 1342: }
! 1343:
! 1344:
! 1345:
! 1346: void net_close(void)
! 1347: {
! 1348: if (sendsock4 >= 0) {
! 1349: close(sendsock4_icmp);
! 1350: close(sendsock4_udp);
! 1351: }
! 1352: if (recvsock4 >= 0) close(recvsock4);
! 1353: if (sendsock6 >= 0) {
! 1354: close(sendsock6_icmp);
! 1355: close(sendsock6_udp);
! 1356: }
! 1357: if (recvsock6 >= 0) close(recvsock6);
! 1358: }
! 1359:
! 1360:
! 1361: int net_waitfd(void)
! 1362: {
! 1363: return recvsock;
! 1364: }
! 1365:
! 1366:
! 1367: int* net_saved_pings(int at)
! 1368: {
! 1369: return host[at].saved;
! 1370: }
! 1371:
! 1372:
! 1373: void net_save_increment(void)
! 1374: {
! 1375: int at;
! 1376: for (at = 0; at < MaxHost; at++) {
! 1377: memmove(host[at].saved, host[at].saved+1, (SAVED_PINGS-1)*sizeof(int));
! 1378: host[at].saved[SAVED_PINGS-1] = -2;
! 1379: host[at].saved_seq_offset += 1;
! 1380: }
! 1381: }
! 1382:
! 1383:
! 1384: void net_save_xmit(int at)
! 1385: {
! 1386: if (host[at].saved[SAVED_PINGS-1] != -2)
! 1387: net_save_increment();
! 1388: host[at].saved[SAVED_PINGS-1] = -1;
! 1389: }
! 1390:
! 1391:
! 1392: void net_save_return(int at, int seq, int ms)
! 1393: {
! 1394: int idx;
! 1395: idx = seq - host[at].saved_seq_offset;
! 1396: if (idx < 0 || idx > SAVED_PINGS) {
! 1397: return;
! 1398: }
! 1399: host[at].saved[idx] = ms;
! 1400: }
! 1401:
! 1402: /* Similar to inet_ntop but uses a sockaddr as it's argument. */
! 1403: void sockaddrtop( struct sockaddr * saddr, char * strptr, size_t len ) {
! 1404: struct sockaddr_in * sa4;
! 1405: #ifdef ENABLE_IPV6
! 1406: struct sockaddr_in6 * sa6;
! 1407: #endif
! 1408:
! 1409: switch ( saddr->sa_family ) {
! 1410: case AF_INET:
! 1411: sa4 = (struct sockaddr_in *) saddr;
! 1412: strncpy( strptr, inet_ntoa( sa4->sin_addr ), len - 1 );
! 1413: strptr[ len - 1 ] = '\0';
! 1414: return;
! 1415: #ifdef ENABLE_IPV6
! 1416: case AF_INET6:
! 1417: sa6 = (struct sockaddr_in6 *) saddr;
! 1418: inet_ntop( sa6->sin6_family, &(sa6->sin6_addr), strptr, len );
! 1419: return;
! 1420: #endif
! 1421: default:
! 1422: fprintf( stderr, "sockaddrtop unknown address type\n" );
! 1423: strptr[0] = '\0';
! 1424: return;
! 1425: }
! 1426: }
! 1427:
! 1428: /* Address comparison. */
! 1429: int addrcmp( char * a, char * b, int af ) {
! 1430: int rc = -1;
! 1431:
! 1432: switch ( af ) {
! 1433: case AF_INET:
! 1434: rc = memcmp( a, b, sizeof (struct in_addr) );
! 1435: break;
! 1436: #ifdef ENABLE_IPV6
! 1437: case AF_INET6:
! 1438: rc = memcmp( a, b, sizeof (struct in6_addr) );
! 1439: break;
! 1440: #endif
! 1441: }
! 1442:
! 1443: return rc;
! 1444: }
! 1445:
! 1446: /* Address copy. */
! 1447: void addrcpy( char * a, char * b, int af ) {
! 1448:
! 1449: switch ( af ) {
! 1450: case AF_INET:
! 1451: memcpy( a, b, sizeof (struct in_addr) );
! 1452: break;
! 1453: #ifdef ENABLE_IPV6
! 1454: case AF_INET6:
! 1455: memcpy( a, b, sizeof (struct in6_addr) );
! 1456: break;
! 1457: #endif
! 1458: }
! 1459: }
! 1460:
! 1461: /* Decode MPLS */
! 1462: void decodempls(int num, char *packet, struct mplslen *mpls, int offset) {
! 1463:
! 1464: int i;
! 1465: unsigned int ext_ver, ext_res, ext_chk, obj_hdr_len;
! 1466: u_char obj_hdr_class, obj_hdr_type;
! 1467:
! 1468: /* loosely derived from the traceroute-nanog.c
! 1469: * decoding by Jorge Boncompte */
! 1470: ext_ver = packet[offset]>>4;
! 1471: ext_res = (packet[offset]&15)+ packet[offset+1];
! 1472: ext_chk = ((unsigned int)packet[offset+2]<<8)+packet[offset+3];
! 1473:
! 1474: /* Check for ICMP extension header */
! 1475: if (ext_ver == 2 && ext_res == 0 && ext_chk != 0 && num >= (offset+6)) {
! 1476: obj_hdr_len = ((int)packet[offset+4]<<8)+packet[offset+5];
! 1477: obj_hdr_class = packet[offset+6];
! 1478: obj_hdr_type = packet[offset+7];
! 1479:
! 1480: /* make sure we have an MPLS extension */
! 1481: if (obj_hdr_len >= 8 && obj_hdr_class == 1 && obj_hdr_type == 1) {
! 1482: /* how many labels do we have? will be at least 1 */
! 1483: mpls->labels = (obj_hdr_len-4)/4;
! 1484:
! 1485: /* save all label objects */
! 1486: for(i=0; (i<mpls->labels) && (i < MAXLABELS) && (num >= (offset+8)+(i*4)); i++) {
! 1487:
! 1488: /* piece together the 20 byte label value */
! 1489: mpls->label[i] = ((unsigned long) (packet[(offset+8)+(i*4)] << 12 & 0xff000) +
! 1490: (unsigned int) (packet[(offset+9)+(i*4)] << 4 & 0xff0) +
! 1491: (packet[(offset+10)+(i*4)] >> 4 & 0xf));
! 1492: mpls->exp[i] = (packet[(offset+10)+(i*4)] >> 1) & 0x7;
! 1493: mpls->s[i] = (packet[(offset+10)+(i*4)] & 0x1); /* should be 1 if only one label */
! 1494: mpls->ttl[i] = packet[(offset+11)+(i*4)];
! 1495: }
! 1496: }
! 1497: }
! 1498: }
! 1499:
! 1500: /* Add open sockets to select() */
! 1501: void net_add_fds(fd_set *writefd, int *maxfd)
! 1502: {
! 1503: int at, fd;
! 1504: for (at = 0; at < MaxSequence; at++) {
! 1505: fd = sequence[at].socket;
! 1506: if (fd > 0) {
! 1507: FD_SET(fd, writefd);
! 1508: if (fd >= *maxfd)
! 1509: *maxfd = fd + 1;
! 1510: }
! 1511: }
! 1512: }
! 1513:
! 1514: /* check if we got connection or error on any fds */
! 1515: void net_process_fds(fd_set *writefd)
! 1516: {
! 1517: int at, fd, r;
! 1518: struct timeval now;
! 1519: uint64_t unow, utime;
! 1520:
! 1521: /* Can't do MPLS decoding */
! 1522: struct mplslen mpls;
! 1523: mpls.labels = 0;
! 1524:
! 1525: gettimeofday(&now, NULL);
! 1526: unow = now.tv_sec * 1000000L + now.tv_usec;
! 1527:
! 1528: for (at = 0; at < MaxSequence; at++) {
! 1529: fd = sequence[at].socket;
! 1530: if (fd > 0 && FD_ISSET(fd, writefd)) {
! 1531: r = write(fd, "G", 1);
! 1532: /* if write was successful, or connection refused we have
! 1533: * (probably) reached the remote address. Anything else happens to the
! 1534: * connection, we write it off to avoid leaking sockets */
! 1535: if (r == 1 || errno == ECONNREFUSED)
! 1536: net_process_ping(at, mpls, remoteaddress, now);
! 1537: else if (errno != EAGAIN) {
! 1538: close(fd);
! 1539: sequence[at].socket = 0;
! 1540: }
! 1541: }
! 1542: if (fd > 0) {
! 1543: utime = sequence[at].time.tv_sec * 1000000L + sequence[at].time.tv_usec;
! 1544: if (unow - utime > timeout) {
! 1545: close(fd);
! 1546: sequence[at].socket = 0;
! 1547: }
! 1548: }
! 1549: }
! 1550: }
! 1551:
! 1552: /* for GTK frontend */
! 1553: void net_harvest_fds(void)
! 1554: {
! 1555: fd_set writefd;
! 1556: int maxfd = 0;
! 1557: struct timeval tv;
! 1558:
! 1559: FD_ZERO(&writefd);
! 1560: tv.tv_sec = 0;
! 1561: tv.tv_usec = 0;
! 1562: net_add_fds(&writefd, &maxfd);
! 1563: select(maxfd, NULL, &writefd, NULL, &tv);
! 1564: net_process_fds(&writefd);
! 1565: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to net.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr