Annotation of embedaddon/mtr/packet/deconstruct_unix.c, revision 1.1
1.1 ! misho 1: /*
! 2: mtr -- a network diagnostic tool
! 3: Copyright (C) 2016 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 "deconstruct_unix.h"
! 20:
! 21: #include <stdio.h>
! 22: #include <stdlib.h>
! 23: #include <string.h>
! 24:
! 25: #include "protocols.h"
! 26:
! 27: #define MAX_MPLS_LABELS 8
! 28:
! 29: /*
! 30: Given an ICMP id + ICMP sequence, find the match probe we've
! 31: transmitted and if found, respond to the command which sent it
! 32: */
! 33: static
! 34: void find_and_receive_probe(
! 35: struct net_state_t *net_state,
! 36: const struct sockaddr_storage *remote_addr,
! 37: struct timeval *timestamp,
! 38: int icmp_type,
! 39: int protocol,
! 40: int icmp_id,
! 41: int icmp_sequence,
! 42: int mpls_count,
! 43: struct mpls_label_t *mpls)
! 44: {
! 45: struct probe_t *probe;
! 46:
! 47: probe = find_probe(net_state, protocol, icmp_id, icmp_sequence);
! 48: if (probe == NULL) {
! 49: return;
! 50: }
! 51:
! 52: receive_probe(net_state, probe, icmp_type,
! 53: remote_addr, timestamp, mpls_count, mpls);
! 54: }
! 55:
! 56: /*
! 57: Handle a UDP packet received embedded in an ICMP reply.
! 58: The sequence number identifying the probe might be in
! 59: the source port number, the destination port number, or
! 60: the checksum. We'll check all three.
! 61: */
! 62: static
! 63: void handle_inner_udp_packet(
! 64: struct net_state_t *net_state,
! 65: const struct sockaddr_storage *remote_addr,
! 66: int icmp_result,
! 67: const struct UDPHeader *udp,
! 68: int udp_length,
! 69: struct timeval *timestamp,
! 70: int mpls_count,
! 71: struct mpls_label_t *mpls)
! 72: {
! 73: struct probe_t *probe;
! 74:
! 75: probe = find_probe(net_state, IPPROTO_UDP, 0, udp->dstport);
! 76: if (probe == NULL) {
! 77: probe = find_probe(net_state, IPPROTO_UDP, 0, udp->srcport);
! 78: }
! 79: if (probe == NULL) {
! 80: probe = find_probe(net_state, IPPROTO_UDP, 0, udp->checksum);
! 81: }
! 82:
! 83: if (probe != NULL) {
! 84: receive_probe(net_state, probe, icmp_result,
! 85: remote_addr, timestamp, mpls_count, mpls);
! 86: }
! 87: }
! 88:
! 89: /*
! 90: We've received an ICMP message with an embedded IP packet.
! 91: We will try to determine which of our outgoing probes
! 92: corresponds to the embedded IP packet and record the response.
! 93: */
! 94: static
! 95: void handle_inner_ip4_packet(
! 96: struct net_state_t *net_state,
! 97: const struct sockaddr_storage *remote_addr,
! 98: int icmp_result,
! 99: const struct IPHeader *ip,
! 100: int packet_length,
! 101: struct timeval *timestamp,
! 102: int mpls_count,
! 103: struct mpls_label_t *mpls)
! 104: {
! 105: const int ip_icmp_size =
! 106: sizeof(struct IPHeader) + sizeof(struct ICMPHeader);
! 107: const int ip_udp_size =
! 108: sizeof(struct IPHeader) + sizeof(struct UDPHeader);
! 109: const int ip_tcp_size =
! 110: sizeof(struct IPHeader) + sizeof(struct TCPHeader);
! 111: const struct ICMPHeader *icmp;
! 112: const struct UDPHeader *udp;
! 113: const struct TCPHeader *tcp;
! 114: int udp_length;
! 115: #ifdef IPPROTO_SCTP
! 116: const int ip_sctp_size =
! 117: sizeof(struct IPHeader) + sizeof(struct SCTPHeader);
! 118: const struct SCTPHeader *sctp;
! 119: #endif
! 120:
! 121: if (ip->protocol == IPPROTO_ICMP) {
! 122: if (packet_length < ip_icmp_size) {
! 123: return;
! 124: }
! 125:
! 126: icmp = (struct ICMPHeader *) (ip + 1);
! 127:
! 128: find_and_receive_probe(net_state, remote_addr, timestamp,
! 129: icmp_result, IPPROTO_ICMP, icmp->id,
! 130: icmp->sequence, mpls_count, mpls);
! 131: } else if (ip->protocol == IPPROTO_UDP) {
! 132: if (packet_length < ip_udp_size) {
! 133: return;
! 134: }
! 135:
! 136: udp = (struct UDPHeader *) (ip + 1);
! 137: udp_length = packet_length - sizeof(struct IPHeader);
! 138:
! 139: handle_inner_udp_packet(net_state, remote_addr, icmp_result, udp,
! 140: udp_length, timestamp, mpls_count, mpls);
! 141: } else if (ip->protocol == IPPROTO_TCP) {
! 142: if (packet_length < ip_tcp_size) {
! 143: return;
! 144: }
! 145:
! 146: tcp = (struct TCPHeader *) (ip + 1);
! 147:
! 148: find_and_receive_probe(net_state, remote_addr, timestamp,
! 149: icmp_result, IPPROTO_TCP, 0, tcp->srcport,
! 150: mpls_count, mpls);
! 151: #ifdef IPPROTO_SCTP
! 152: } else if (ip->protocol == IPPROTO_SCTP) {
! 153: if (packet_length < ip_sctp_size) {
! 154: return;
! 155: }
! 156:
! 157: sctp = (struct SCTPHeader *) (ip + 1);
! 158:
! 159: find_and_receive_probe(net_state, remote_addr, timestamp,
! 160: icmp_result, IPPROTO_SCTP, 0, sctp->srcport,
! 161: mpls_count, mpls);
! 162: #endif
! 163: }
! 164: }
! 165:
! 166: /*
! 167: Examine the IPv6 header embedded in a returned ICMPv6 packet
! 168: in order to match it with a probe which we previously sent.
! 169: */
! 170: static
! 171: void handle_inner_ip6_packet(
! 172: struct net_state_t *net_state,
! 173: const struct sockaddr_storage *remote_addr,
! 174: int icmp_result,
! 175: const struct IP6Header *ip,
! 176: int packet_length,
! 177: struct timeval *timestamp,
! 178: int mpls_count,
! 179: struct mpls_label_t *mpls)
! 180: {
! 181: const int ip_icmp_size =
! 182: sizeof(struct IP6Header) + sizeof(struct ICMPHeader);
! 183: const int ip_udp_size =
! 184: sizeof(struct IP6Header) + sizeof(struct UDPHeader);
! 185: const int ip_tcp_size =
! 186: sizeof(struct IP6Header) + sizeof(struct TCPHeader);
! 187: const struct ICMPHeader *icmp;
! 188: const struct UDPHeader *udp;
! 189: const struct TCPHeader *tcp;
! 190: int udp_length;
! 191: #ifdef IPPROTO_SCTP
! 192: const int ip_sctp_size =
! 193: sizeof(struct IPHeader) + sizeof(struct SCTPHeader);
! 194: const struct SCTPHeader *sctp;
! 195: #endif
! 196:
! 197: if (ip->protocol == IPPROTO_ICMPV6) {
! 198: if (packet_length < ip_icmp_size) {
! 199: return;
! 200: }
! 201:
! 202: icmp = (struct ICMPHeader *) (ip + 1);
! 203:
! 204: find_and_receive_probe(net_state, remote_addr, timestamp,
! 205: icmp_result, IPPROTO_ICMP, icmp->id,
! 206: icmp->sequence, mpls_count, mpls);
! 207: } else if (ip->protocol == IPPROTO_UDP) {
! 208: if (packet_length < ip_udp_size) {
! 209: return;
! 210: }
! 211:
! 212: udp = (struct UDPHeader *) (ip + 1);
! 213: udp_length = packet_length - sizeof(struct IP6Header);
! 214:
! 215: handle_inner_udp_packet(net_state, remote_addr, icmp_result, udp,
! 216: udp_length, timestamp, mpls_count, mpls);
! 217: } else if (ip->protocol == IPPROTO_TCP) {
! 218: if (packet_length < ip_tcp_size) {
! 219: return;
! 220: }
! 221:
! 222: tcp = (struct TCPHeader *) (ip + 1);
! 223: find_and_receive_probe(net_state, remote_addr, timestamp,
! 224: icmp_result, IPPROTO_TCP, 0, tcp->srcport,
! 225: mpls_count, mpls);
! 226: #ifdef IPPROTO_SCTP
! 227: } else if (ip->protocol == IPPROTO_SCTP) {
! 228: if (packet_length < ip_sctp_size) {
! 229: return;
! 230: }
! 231:
! 232: sctp = (struct SCTPHeader *) (ip + 1);
! 233:
! 234: find_and_receive_probe(net_state, remote_addr, timestamp,
! 235: icmp_result, IPPROTO_SCTP, 0, sctp->srcport,
! 236: mpls_count, mpls);
! 237: #endif
! 238: }
! 239: }
! 240:
! 241: /* Convert an ICMP MPLS extension object into an mpls_label_t structure */
! 242: static
! 243: int decode_mpls_object(
! 244: struct ICMPExtensionObject *icmp_obj,
! 245: int obj_len,
! 246: struct mpls_label_t *mpls,
! 247: int mpls_count)
! 248: {
! 249: int label_bytes;
! 250: int labels_present;
! 251: int i;
! 252: struct ICMPExtMPLSLabel *ext_mpls;
! 253: struct ICMPExtMPLSLabel *ext_label;
! 254: struct mpls_label_t *label;
! 255:
! 256: label_bytes = obj_len - sizeof(struct ICMPExtensionObject);
! 257: labels_present = label_bytes / sizeof(struct ICMPExtMPLSLabel);
! 258:
! 259: ext_mpls = (struct ICMPExtMPLSLabel *) (icmp_obj + 1);
! 260: for (i = 0; i < mpls_count && i < labels_present; i++) {
! 261: ext_label = &ext_mpls[i];
! 262: label = &mpls[i];
! 263:
! 264: memset(label, 0, sizeof(struct mpls_label_t));
! 265:
! 266: label->label =
! 267: ext_label->label[0] << 12 |
! 268: ext_label->label[1] << 4 | ext_label->label[2] >> 4;
! 269: label->experimental_use = (ext_label->label[2] & 0x0E) >> 1;
! 270: label->bottom_of_stack = ext_label->label[2] & 0x01;
! 271: label->ttl = ext_label->ttl;
! 272: }
! 273:
! 274: return i;
! 275: }
! 276:
! 277: /* Extract MPLS labels from the ICMP extension header, if present */
! 278: static
! 279: int decode_mpls_labels(
! 280: const struct ICMPHeader *icmp,
! 281: int packet_length,
! 282: struct mpls_label_t *mpls,
! 283: int mpls_count)
! 284: {
! 285: const int icmp_orig_icmp_ext_size =
! 286: sizeof(struct ICMPHeader) + ICMP_ORIGINAL_DATAGRAM_MIN_SIZE +
! 287: sizeof(struct ICMPExtensionHeader);
! 288: char *inner_packet;
! 289: char *icmp_object_bytes;
! 290: struct ICMPExtensionHeader *icmp_ext;
! 291: struct ICMPExtensionObject *icmp_obj;
! 292: int remaining_size;
! 293: int obj_len;
! 294:
! 295: if (packet_length < icmp_orig_icmp_ext_size) {
! 296: return 0;
! 297: }
! 298:
! 299: inner_packet = (char *) (icmp + 1);
! 300: icmp_ext = (struct ICMPExtensionHeader *)
! 301: (inner_packet + ICMP_ORIGINAL_DATAGRAM_MIN_SIZE);
! 302:
! 303: if ((icmp_ext->version & 0xF0) != 0x20) {
! 304: return 0;
! 305: }
! 306:
! 307: remaining_size = packet_length - icmp_orig_icmp_ext_size;
! 308: icmp_object_bytes = (char *) (icmp_ext + 1);
! 309:
! 310: /*
! 311: Iterate through the chain of extension objects, looking for
! 312: an MPLS label extension.
! 313: */
! 314: while (remaining_size >= sizeof(struct ICMPExtensionObject)) {
! 315: icmp_obj = (struct ICMPExtensionObject *) icmp_object_bytes;
! 316: obj_len = ntohs(icmp_obj->len);
! 317:
! 318: if (obj_len > remaining_size) {
! 319: return 0;
! 320: }
! 321: if (obj_len < sizeof(struct ICMPExtensionObject)) {
! 322: return 0;
! 323: }
! 324:
! 325: if (icmp_obj->classnum == ICMP_EXT_MPLS_CLASSNUM &&
! 326: icmp_obj->ctype == ICMP_EXT_MPLS_CTYPE) {
! 327:
! 328: return decode_mpls_object(icmp_obj, obj_len, mpls, mpls_count);
! 329: }
! 330:
! 331: remaining_size -= obj_len;
! 332: icmp_object_bytes += obj_len;
! 333: }
! 334:
! 335: return 0;
! 336: }
! 337:
! 338: /*
! 339: Decode the ICMP header received and try to find a probe which it
! 340: is in response to.
! 341: */
! 342: static
! 343: void handle_received_icmp4_packet(
! 344: struct net_state_t *net_state,
! 345: const struct sockaddr_storage *remote_addr,
! 346: const struct ICMPHeader *icmp,
! 347: int packet_length,
! 348: struct timeval *timestamp)
! 349: {
! 350: const int icmp_ip_size =
! 351: sizeof(struct ICMPHeader) + sizeof(struct IPHeader);
! 352: const struct IPHeader *inner_ip;
! 353: int inner_size = packet_length - sizeof(struct ICMPHeader);
! 354: int mpls_count;
! 355: struct mpls_label_t mpls[MAX_MPLS_LABELS];
! 356:
! 357: mpls_count =
! 358: decode_mpls_labels(icmp, packet_length, mpls, MAX_MPLS_LABELS);
! 359:
! 360: /* If we get an echo reply, our probe reached the destination host */
! 361: if (icmp->type == ICMP_ECHOREPLY) {
! 362: find_and_receive_probe(net_state, remote_addr, timestamp,
! 363: ICMP_ECHOREPLY, IPPROTO_ICMP, icmp->id,
! 364: icmp->sequence, mpls_count, mpls);
! 365: }
! 366:
! 367: if (packet_length < icmp_ip_size) {
! 368: return;
! 369: }
! 370: inner_ip = (struct IPHeader *) (icmp + 1);
! 371:
! 372: /*
! 373: If we get a time exceeded, we got a response from an intermediate
! 374: host along the path to our destination.
! 375: */
! 376: if (icmp->type == ICMP_TIME_EXCEEDED) {
! 377: /*
! 378: The IP packet inside the ICMP response contains our original
! 379: IP header. That's where we can get our original ID and
! 380: sequence number.
! 381: */
! 382: handle_inner_ip4_packet(net_state, remote_addr,
! 383: ICMP_TIME_EXCEEDED, inner_ip, inner_size,
! 384: timestamp, mpls_count, mpls);
! 385: }
! 386:
! 387: if (icmp->type == ICMP_DEST_UNREACH) {
! 388: /*
! 389: We'll get a ICMP_PORT_UNREACH when a non-ICMP probe
! 390: reaches its final destination. (Assuming that port isn't
! 391: open on the destination host.)
! 392: */
! 393: if (icmp->code == ICMP_PORT_UNREACH) {
! 394: handle_inner_ip4_packet(net_state, remote_addr,
! 395: ICMP_ECHOREPLY, inner_ip, inner_size,
! 396: timestamp, mpls_count, mpls);
! 397: }
! 398: }
! 399: }
! 400:
! 401: /*
! 402: Decode the ICMPv6 header. The code duplication with ICMPv4 is
! 403: unfortunate, but small details in structure size and ICMP
! 404: constants differ.
! 405: */
! 406: static
! 407: void handle_received_icmp6_packet(
! 408: struct net_state_t *net_state,
! 409: const struct sockaddr_storage *remote_addr,
! 410: const struct ICMPHeader *icmp,
! 411: int packet_length,
! 412: struct timeval *timestamp)
! 413: {
! 414: const int icmp_ip_size =
! 415: sizeof(struct ICMPHeader) + sizeof(struct IP6Header);
! 416: const struct IP6Header *inner_ip;
! 417: int inner_size = packet_length - sizeof(struct ICMPHeader);
! 418: int mpls_count;
! 419: struct mpls_label_t mpls[MAX_MPLS_LABELS];
! 420:
! 421: mpls_count =
! 422: decode_mpls_labels(icmp, packet_length, mpls, MAX_MPLS_LABELS);
! 423:
! 424: if (icmp->type == ICMP6_ECHOREPLY) {
! 425: find_and_receive_probe(net_state, remote_addr, timestamp,
! 426: ICMP_ECHOREPLY, IPPROTO_ICMP, icmp->id,
! 427: icmp->sequence, mpls_count, mpls);
! 428: }
! 429:
! 430: if (packet_length < icmp_ip_size) {
! 431: return;
! 432: }
! 433: inner_ip = (struct IP6Header *) (icmp + 1);
! 434:
! 435: if (icmp->type == ICMP6_TIME_EXCEEDED) {
! 436: handle_inner_ip6_packet(net_state, remote_addr,
! 437: ICMP_TIME_EXCEEDED, inner_ip, inner_size,
! 438: timestamp, mpls_count, mpls);
! 439: }
! 440:
! 441: if (icmp->type == ICMP6_DEST_UNREACH) {
! 442: if (icmp->code == ICMP6_PORT_UNREACH) {
! 443: handle_inner_ip6_packet(net_state, remote_addr,
! 444: ICMP_ECHOREPLY, inner_ip, inner_size,
! 445: timestamp, mpls_count, mpls);
! 446: }
! 447: }
! 448: }
! 449:
! 450: /*
! 451: We've received a new IPv4 ICMP packet.
! 452: We'll check to see that it is a response to one of our probes, and
! 453: if so, report the result of the probe to our command stream.
! 454: */
! 455: void handle_received_ip4_packet(
! 456: struct net_state_t *net_state,
! 457: const struct sockaddr_storage *remote_addr,
! 458: const void *packet,
! 459: int packet_length,
! 460: struct timeval *timestamp)
! 461: {
! 462: const int ip_icmp_size =
! 463: sizeof(struct IPHeader) + sizeof(struct ICMPHeader);
! 464: const struct IPHeader *ip;
! 465: const struct ICMPHeader *icmp;
! 466: int icmp_length;
! 467:
! 468: /* Ensure that we don't access memory beyond the bounds of the packet */
! 469: if (packet_length < ip_icmp_size) {
! 470: return;
! 471: }
! 472:
! 473: ip = (struct IPHeader *) packet;
! 474: if (ip->protocol != IPPROTO_ICMP) {
! 475: return;
! 476: }
! 477:
! 478: icmp = (struct ICMPHeader *) (ip + 1);
! 479: icmp_length = packet_length - sizeof(struct IPHeader);
! 480:
! 481: handle_received_icmp4_packet(net_state, remote_addr, icmp, icmp_length,
! 482: timestamp);
! 483: }
! 484:
! 485: /*
! 486: Unlike ICMPv6 raw sockets, unlike ICMPv4, don't include the IP header
! 487: in received packets, so we can assume the packet we got starts
! 488: with the ICMP packet.
! 489: */
! 490: void handle_received_ip6_packet(
! 491: struct net_state_t *net_state,
! 492: const struct sockaddr_storage *remote_addr,
! 493: const void *packet,
! 494: int packet_length,
! 495: struct timeval *timestamp)
! 496: {
! 497: const struct ICMPHeader *icmp;
! 498:
! 499: icmp = (struct ICMPHeader *) packet;
! 500:
! 501: handle_received_icmp6_packet(net_state, remote_addr, icmp,
! 502: packet_length, timestamp);
! 503: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to deconstruct_unix.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 / packet