Annotation of embedaddon/mtr/packet/construct_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 "construct_unix.h"
! 20:
! 21: #include <errno.h>
! 22: #include <stdio.h>
! 23: #include <string.h>
! 24: #include <sys/socket.h>
! 25: #include <unistd.h>
! 26:
! 27: #include "protocols.h"
! 28:
! 29: /* A source of data for computing a checksum */
! 30: struct checksum_source_t {
! 31: const void *data;
! 32: size_t size;
! 33: };
! 34:
! 35: /* Compute the IP checksum (or ICMP checksum) of a packet. */
! 36: static
! 37: uint16_t compute_checksum(
! 38: const void *packet,
! 39: int size)
! 40: {
! 41: const uint8_t *packet_bytes = (uint8_t *) packet;
! 42: uint32_t sum = 0;
! 43: int i;
! 44:
! 45: for (i = 0; i < size; i++) {
! 46: if ((i & 1) == 0) {
! 47: sum += packet_bytes[i] << 8;
! 48: } else {
! 49: sum += packet_bytes[i];
! 50: }
! 51: }
! 52:
! 53: /*
! 54: Sums which overflow a 16-bit value have the high bits
! 55: added back into the low 16 bits.
! 56: */
! 57: while (sum >> 16) {
! 58: sum = (sum >> 16) + (sum & 0xffff);
! 59: }
! 60:
! 61: /*
! 62: The value stored is the one's complement of the
! 63: mathematical sum.
! 64: */
! 65: return (~sum & 0xffff);
! 66: }
! 67:
! 68: /* Encode the IP header length field in the order required by the OS. */
! 69: static
! 70: uint16_t length_byte_swap(
! 71: const struct net_state_t *net_state,
! 72: uint16_t length)
! 73: {
! 74: if (net_state->platform.ip_length_host_order) {
! 75: return length;
! 76: } else {
! 77: return htons(length);
! 78: }
! 79: }
! 80:
! 81: /* Construct a combined sockaddr from a source address and source port */
! 82: static
! 83: void construct_addr_port(
! 84: struct sockaddr_storage *addr_with_port,
! 85: const struct sockaddr_storage *addr,
! 86: int port)
! 87: {
! 88: struct sockaddr_in *addr4;
! 89: struct sockaddr_in6 *addr6;
! 90:
! 91: memcpy(addr_with_port, addr, sizeof(struct sockaddr_storage));
! 92:
! 93: if (addr->ss_family == AF_INET6) {
! 94: addr6 = (struct sockaddr_in6 *) addr_with_port;
! 95: addr6->sin6_port = htons(port);
! 96: } else {
! 97: addr4 = (struct sockaddr_in *) addr_with_port;
! 98: addr4->sin_port = htons(port);
! 99: }
! 100: }
! 101:
! 102: /* Construct a header for IP version 4 */
! 103: static
! 104: void construct_ip4_header(
! 105: const struct net_state_t *net_state,
! 106: char *packet_buffer,
! 107: int packet_size,
! 108: const struct sockaddr_storage *srcaddr,
! 109: const struct sockaddr_storage *destaddr,
! 110: const struct probe_param_t *param)
! 111: {
! 112: struct IPHeader *ip;
! 113: struct sockaddr_in *srcaddr4 = (struct sockaddr_in *) srcaddr;
! 114: struct sockaddr_in *destaddr4 = (struct sockaddr_in *) destaddr;
! 115:
! 116: ip = (struct IPHeader *) &packet_buffer[0];
! 117:
! 118: memset(ip, 0, sizeof(struct IPHeader));
! 119:
! 120: ip->version = 0x45;
! 121: ip->tos = param->type_of_service;
! 122: ip->len = length_byte_swap(net_state, packet_size);
! 123: ip->ttl = param->ttl;
! 124: ip->protocol = param->protocol;
! 125: memcpy(&ip->saddr, &srcaddr4->sin_addr, sizeof(uint32_t));
! 126: memcpy(&ip->daddr, &destaddr4->sin_addr, sizeof(uint32_t));
! 127: }
! 128:
! 129: /* Construct an ICMP header for IPv4 */
! 130: static
! 131: void construct_icmp4_header(
! 132: const struct net_state_t *net_state,
! 133: int sequence,
! 134: char *packet_buffer,
! 135: int packet_size,
! 136: const struct probe_param_t *param)
! 137: {
! 138: struct ICMPHeader *icmp;
! 139: int icmp_size;
! 140:
! 141: icmp = (struct ICMPHeader *) &packet_buffer[sizeof(struct IPHeader)];
! 142: icmp_size = packet_size - sizeof(struct IPHeader);
! 143:
! 144: memset(icmp, 0, sizeof(struct ICMPHeader));
! 145:
! 146: icmp->type = ICMP_ECHO;
! 147: icmp->id = htons(getpid());
! 148: icmp->sequence = htons(sequence);
! 149: icmp->checksum = htons(compute_checksum(icmp, icmp_size));
! 150: }
! 151:
! 152: /* Construct an ICMP header for IPv6 */
! 153: static
! 154: int construct_icmp6_packet(
! 155: const struct net_state_t *net_state,
! 156: int sequence,
! 157: char *packet_buffer,
! 158: int packet_size,
! 159: const struct probe_param_t *param)
! 160: {
! 161: struct ICMPHeader *icmp;
! 162:
! 163: icmp = (struct ICMPHeader *) packet_buffer;
! 164:
! 165: memset(icmp, 0, sizeof(struct ICMPHeader));
! 166:
! 167: icmp->type = ICMP6_ECHO;
! 168: icmp->id = htons(getpid());
! 169: icmp->sequence = htons(sequence);
! 170:
! 171: return 0;
! 172: }
! 173:
! 174: /*
! 175: Set the port numbers for an outgoing UDP probe.
! 176: There is limited space in the header for a sequence number
! 177: to identify the probe upon return.
! 178:
! 179: We store the sequence number in the destination port, the local
! 180: port, or the checksum. The location chosen depends upon which
! 181: probe parameters have been requested.
! 182: */
! 183: static
! 184: void set_udp_ports(
! 185: struct UDPHeader *udp,
! 186: int sequence,
! 187: const struct probe_param_t *param)
! 188: {
! 189: if (param->dest_port) {
! 190: udp->dstport = htons(param->dest_port);
! 191:
! 192: if (param->local_port) {
! 193: udp->srcport = htons(param->local_port);
! 194: udp->checksum = htons(sequence);
! 195: } else {
! 196: udp->srcport = htons(sequence);
! 197: udp->checksum = 0;
! 198: }
! 199: } else {
! 200: udp->dstport = htons(sequence);
! 201:
! 202: if (param->local_port) {
! 203: udp->srcport = htons(param->local_port);
! 204: } else {
! 205: udp->srcport = htons(getpid());
! 206: }
! 207:
! 208: udp->checksum = 0;
! 209: }
! 210: }
! 211:
! 212: /*
! 213: Construct a header for UDP probes, using the port number associated
! 214: with the probe.
! 215: */
! 216: static
! 217: void construct_udp4_header(
! 218: const struct net_state_t *net_state,
! 219: int sequence,
! 220: char *packet_buffer,
! 221: int packet_size,
! 222: const struct probe_param_t *param)
! 223: {
! 224: struct UDPHeader *udp;
! 225: int udp_size;
! 226:
! 227: udp = (struct UDPHeader *) &packet_buffer[sizeof(struct IPHeader)];
! 228: udp_size = packet_size - sizeof(struct IPHeader);
! 229:
! 230: memset(udp, 0, sizeof(struct UDPHeader));
! 231:
! 232: set_udp_ports(udp, sequence, param);
! 233: udp->length = htons(udp_size);
! 234: }
! 235:
! 236: /* Construct a header for UDPv6 probes */
! 237: static
! 238: int construct_udp6_packet(
! 239: const struct net_state_t *net_state,
! 240: int sequence,
! 241: char *packet_buffer,
! 242: int packet_size,
! 243: const struct probe_param_t *param)
! 244: {
! 245: int udp_socket = net_state->platform.udp6_send_socket;
! 246: struct UDPHeader *udp;
! 247: int udp_size;
! 248:
! 249: udp = (struct UDPHeader *) packet_buffer;
! 250: udp_size = packet_size;
! 251:
! 252: memset(udp, 0, sizeof(struct UDPHeader));
! 253:
! 254: set_udp_ports(udp, sequence, param);
! 255: udp->length = htons(udp_size);
! 256:
! 257: /*
! 258: Instruct the kernel to put the pseudoheader checksum into the
! 259: UDP header.
! 260: */
! 261: int chksum_offset = (char *) &udp->checksum - (char *) udp;
! 262: if (setsockopt(udp_socket, IPPROTO_IPV6,
! 263: IPV6_CHECKSUM, &chksum_offset, sizeof(int))) {
! 264: return -1;
! 265: }
! 266:
! 267: return 0;
! 268: }
! 269:
! 270: /*
! 271: Set the socket options for an outgoing stream protocol socket based on
! 272: the packet parameters.
! 273: */
! 274: static
! 275: int set_stream_socket_options(
! 276: int stream_socket,
! 277: const struct probe_param_t *param)
! 278: {
! 279: int level;
! 280: int opt;
! 281: int reuse = 1;
! 282:
! 283: /* Allow binding to a local port previously in use */
! 284: #ifdef SO_REUSEPORT
! 285: /*
! 286: FreeBSD wants SO_REUSEPORT in addition to SO_REUSEADDR to
! 287: bind to the same port
! 288: */
! 289: if (setsockopt(stream_socket, SOL_SOCKET, SO_REUSEPORT,
! 290: &reuse, sizeof(int)) == -1) {
! 291:
! 292: return -1;
! 293: }
! 294: #endif
! 295:
! 296: if (setsockopt(stream_socket, SOL_SOCKET, SO_REUSEADDR,
! 297: &reuse, sizeof(int)) == -1) {
! 298:
! 299: return -1;
! 300: }
! 301:
! 302: /* Set the number of hops the probe will transit across */
! 303: if (param->ip_version == 6) {
! 304: level = IPPROTO_IPV6;
! 305: opt = IPV6_UNICAST_HOPS;
! 306: } else {
! 307: level = IPPROTO_IP;
! 308: opt = IP_TTL;
! 309: }
! 310:
! 311: if (setsockopt(stream_socket, level, opt, ¶m->ttl, sizeof(int)) ==
! 312: -1) {
! 313:
! 314: return -1;
! 315: }
! 316:
! 317: /* Set the "type of service" field of the IP header */
! 318: if (param->ip_version == 6) {
! 319: level = IPPROTO_IPV6;
! 320: opt = IPV6_TCLASS;
! 321: } else {
! 322: level = IPPROTO_IP;
! 323: opt = IP_TOS;
! 324: }
! 325:
! 326: if (setsockopt(stream_socket, level, opt,
! 327: ¶m->type_of_service, sizeof(int)) == -1) {
! 328:
! 329: return -1;
! 330: }
! 331: #ifdef SO_MARK
! 332: if (param->routing_mark) {
! 333: if (setsockopt(stream_socket, SOL_SOCKET,
! 334: SO_MARK, ¶m->routing_mark, sizeof(int))) {
! 335: return -1;
! 336: }
! 337: }
! 338: #endif
! 339:
! 340: return 0;
! 341: }
! 342:
! 343: /*
! 344: Open a TCP or SCTP socket, respecting the probe paramters as much as
! 345: we can, and use it as an outgoing probe.
! 346: */
! 347: static
! 348: int open_stream_socket(
! 349: const struct net_state_t *net_state,
! 350: int protocol,
! 351: int port,
! 352: const struct sockaddr_storage *src_sockaddr,
! 353: const struct sockaddr_storage *dest_sockaddr,
! 354: const struct probe_param_t *param)
! 355: {
! 356: int stream_socket;
! 357: int addr_len;
! 358: int dest_port;
! 359: struct sockaddr_storage dest_port_addr;
! 360: struct sockaddr_storage src_port_addr;
! 361:
! 362: if (param->ip_version == 6) {
! 363: stream_socket = socket(AF_INET6, SOCK_STREAM, protocol);
! 364: addr_len = sizeof(struct sockaddr_in6);
! 365: } else if (param->ip_version == 4) {
! 366: stream_socket = socket(AF_INET, SOCK_STREAM, protocol);
! 367: addr_len = sizeof(struct sockaddr_in);
! 368: } else {
! 369: errno = EINVAL;
! 370: return -1;
! 371: }
! 372:
! 373: if (stream_socket == -1) {
! 374: return -1;
! 375: }
! 376:
! 377: set_socket_nonblocking(stream_socket);
! 378:
! 379: if (set_stream_socket_options(stream_socket, param)) {
! 380: close(stream_socket);
! 381: return -1;
! 382: }
! 383:
! 384: /*
! 385: Bind to a known local port so we can identify which probe
! 386: causes a TTL expiration.
! 387: */
! 388: construct_addr_port(&src_port_addr, src_sockaddr, port);
! 389: if (bind(stream_socket, (struct sockaddr *) &src_port_addr, addr_len)) {
! 390: close(stream_socket);
! 391: return -1;
! 392: }
! 393:
! 394: if (param->dest_port) {
! 395: dest_port = param->dest_port;
! 396: } else {
! 397: /* Use http if no port is specified */
! 398: dest_port = HTTP_PORT;
! 399: }
! 400:
! 401: /* Attempt a connection */
! 402: construct_addr_port(&dest_port_addr, dest_sockaddr, dest_port);
! 403: if (connect
! 404: (stream_socket, (struct sockaddr *) &dest_port_addr, addr_len)) {
! 405:
! 406: /* EINPROGRESS simply means the connection is in progress */
! 407: if (errno != EINPROGRESS) {
! 408: close(stream_socket);
! 409: return -1;
! 410: }
! 411: }
! 412:
! 413: return stream_socket;
! 414: }
! 415:
! 416: /*
! 417: Determine the size of the constructed packet based on the packet
! 418: parameters. This is the amount of space the packet *we* construct
! 419: uses, and doesn't include any headers the operating system tacks
! 420: onto the packet. (Such as the IPv6 header on non-Linux operating
! 421: systems.)
! 422: */
! 423: static
! 424: int compute_packet_size(
! 425: const struct net_state_t *net_state,
! 426: const struct probe_param_t *param)
! 427: {
! 428: int packet_size;
! 429:
! 430: if (param->protocol == IPPROTO_TCP) {
! 431: return 0;
! 432: }
! 433: #ifdef IPPROTO_SCTP
! 434: if (param->protocol == IPPROTO_SCTP) {
! 435: return 0;
! 436: }
! 437: #endif
! 438:
! 439: /* Start by determining the full size, including omitted headers */
! 440: if (param->ip_version == 6) {
! 441: packet_size = sizeof(struct IP6Header);
! 442: } else if (param->ip_version == 4) {
! 443: packet_size = sizeof(struct IPHeader);
! 444: } else {
! 445: errno = EINVAL;
! 446: return -1;
! 447: }
! 448:
! 449: if (param->protocol == IPPROTO_ICMP) {
! 450: packet_size += sizeof(struct ICMPHeader);
! 451: } else if (param->protocol == IPPROTO_UDP) {
! 452: packet_size += sizeof(struct UDPHeader);
! 453:
! 454: /* We may need to put the sequence number in the payload */
! 455: packet_size += sizeof(int);
! 456: } else {
! 457: errno = EINVAL;
! 458: return -1;
! 459: }
! 460:
! 461: /*
! 462: If the requested size from send-probe is greater, extend the
! 463: packet size.
! 464: */
! 465: if (param->packet_size > packet_size) {
! 466: packet_size = param->packet_size;
! 467: }
! 468:
! 469: /*
! 470: Since we don't explicitly construct the IPv6 header, we
! 471: need to account for it in our transmitted size.
! 472: */
! 473: if (param->ip_version == 6) {
! 474: packet_size -= sizeof(struct IP6Header);
! 475: }
! 476:
! 477: return packet_size;
! 478: }
! 479:
! 480: /* Construct a packet for an IPv4 probe */
! 481: static
! 482: int construct_ip4_packet(
! 483: const struct net_state_t *net_state,
! 484: int *packet_socket,
! 485: int sequence,
! 486: char *packet_buffer,
! 487: int packet_size,
! 488: const struct sockaddr_storage *src_sockaddr,
! 489: const struct sockaddr_storage *dest_sockaddr,
! 490: const struct probe_param_t *param)
! 491: {
! 492: int send_socket = net_state->platform.ip4_send_socket;
! 493: bool is_stream_protocol = false;
! 494:
! 495: if (param->protocol == IPPROTO_TCP) {
! 496: is_stream_protocol = true;
! 497: #ifdef IPPROTO_SCTP
! 498: } else if (param->protocol == IPPROTO_SCTP) {
! 499: is_stream_protocol = true;
! 500: #endif
! 501: } else {
! 502: construct_ip4_header(net_state, packet_buffer, packet_size,
! 503: src_sockaddr, dest_sockaddr, param);
! 504:
! 505: if (param->protocol == IPPROTO_ICMP) {
! 506: construct_icmp4_header(net_state, sequence, packet_buffer,
! 507: packet_size, param);
! 508: } else if (param->protocol == IPPROTO_UDP) {
! 509: construct_udp4_header(net_state, sequence, packet_buffer,
! 510: packet_size, param);
! 511: } else {
! 512: errno = EINVAL;
! 513: return -1;
! 514: }
! 515: }
! 516:
! 517: if (is_stream_protocol) {
! 518: send_socket =
! 519: open_stream_socket(net_state, param->protocol, sequence,
! 520: src_sockaddr, dest_sockaddr, param);
! 521:
! 522: if (send_socket == -1) {
! 523: return -1;
! 524: }
! 525:
! 526: *packet_socket = send_socket;
! 527: return 0;
! 528: }
! 529:
! 530: /*
! 531: The routing mark requires CAP_NET_ADMIN, as opposed to the
! 532: CAP_NET_RAW which we are sometimes explicitly given.
! 533: If we don't have CAP_NET_ADMIN, this will fail, so we'll
! 534: only set the mark if the user has explicitly requested it.
! 535:
! 536: Unfortunately, this means that once the mark is set, it won't
! 537: be set on the socket again until a new mark is explicitly
! 538: specified.
! 539: */
! 540: #ifdef SO_MARK
! 541: if (param->routing_mark) {
! 542: if (setsockopt(send_socket, SOL_SOCKET,
! 543: SO_MARK, ¶m->routing_mark, sizeof(int))) {
! 544: return -1;
! 545: }
! 546: }
! 547: #endif
! 548:
! 549: return 0;
! 550: }
! 551:
! 552: /* Construct a packet for an IPv6 probe */
! 553: static
! 554: int construct_ip6_packet(
! 555: const struct net_state_t *net_state,
! 556: int *packet_socket,
! 557: int sequence,
! 558: char *packet_buffer,
! 559: int packet_size,
! 560: const struct sockaddr_storage *src_sockaddr,
! 561: const struct sockaddr_storage *dest_sockaddr,
! 562: const struct probe_param_t *param)
! 563: {
! 564: int send_socket;
! 565: bool is_stream_protocol = false;
! 566: bool bind_send_socket = true;
! 567: struct sockaddr_storage current_sockaddr;
! 568: int current_sockaddr_len;
! 569:
! 570: if (param->protocol == IPPROTO_TCP) {
! 571: is_stream_protocol = true;
! 572: #ifdef IPPROTO_SCTP
! 573: } else if (param->protocol == IPPROTO_SCTP) {
! 574: is_stream_protocol = true;
! 575: #endif
! 576: } else if (param->protocol == IPPROTO_ICMP) {
! 577: send_socket = net_state->platform.icmp6_send_socket;
! 578:
! 579: if (construct_icmp6_packet
! 580: (net_state, sequence, packet_buffer, packet_size, param)) {
! 581: return -1;
! 582: }
! 583: } else if (param->protocol == IPPROTO_UDP) {
! 584: send_socket = net_state->platform.udp6_send_socket;
! 585:
! 586: if (construct_udp6_packet
! 587: (net_state, sequence, packet_buffer, packet_size, param)) {
! 588: return -1;
! 589: }
! 590: } else {
! 591: errno = EINVAL;
! 592: return -1;
! 593: }
! 594:
! 595: if (is_stream_protocol) {
! 596: send_socket =
! 597: open_stream_socket(net_state, param->protocol, sequence,
! 598: src_sockaddr, dest_sockaddr, param);
! 599:
! 600: if (send_socket == -1) {
! 601: return -1;
! 602: }
! 603:
! 604: *packet_socket = send_socket;
! 605: return 0;
! 606: }
! 607:
! 608: /*
! 609: Check the current socket address, and if it is the same
! 610: as the source address we intend, we will skip the bind.
! 611: This is to accomodate Solaris, which, as of Solaris 11.3,
! 612: will return an EINVAL error on bind if the socket is already
! 613: bound, even if the same address is used.
! 614: */
! 615: current_sockaddr_len = sizeof(struct sockaddr_in6);
! 616: if (getsockname(send_socket, (struct sockaddr *) ¤t_sockaddr,
! 617: ¤t_sockaddr_len) == 0) {
! 618:
! 619: if (memcmp(¤t_sockaddr,
! 620: src_sockaddr, sizeof(struct sockaddr_in6)) == 0) {
! 621: bind_send_socket = false;
! 622: }
! 623: }
! 624:
! 625: /* Bind to our local address */
! 626: if (bind_send_socket) {
! 627: if (bind(send_socket, (struct sockaddr *) src_sockaddr,
! 628: sizeof(struct sockaddr_in6))) {
! 629: return -1;
! 630: }
! 631: }
! 632:
! 633: /* The traffic class in IPv6 is analagous to ToS in IPv4 */
! 634: if (setsockopt(send_socket, IPPROTO_IPV6,
! 635: IPV6_TCLASS, ¶m->type_of_service, sizeof(int))) {
! 636: return -1;
! 637: }
! 638:
! 639: /* Set the time-to-live */
! 640: if (setsockopt(send_socket, IPPROTO_IPV6,
! 641: IPV6_UNICAST_HOPS, ¶m->ttl, sizeof(int))) {
! 642: return -1;
! 643: }
! 644: #ifdef SO_MARK
! 645: if (param->routing_mark) {
! 646: if (setsockopt(send_socket,
! 647: SOL_SOCKET, SO_MARK, ¶m->routing_mark,
! 648: sizeof(int))) {
! 649: return -1;
! 650: }
! 651: }
! 652: #endif
! 653:
! 654: return 0;
! 655: }
! 656:
! 657: /* Construct a probe packet based on the probe parameters */
! 658: int construct_packet(
! 659: const struct net_state_t *net_state,
! 660: int *packet_socket,
! 661: int sequence,
! 662: char *packet_buffer,
! 663: int packet_buffer_size,
! 664: const struct sockaddr_storage *dest_sockaddr,
! 665: const struct sockaddr_storage *src_sockaddr,
! 666: const struct probe_param_t *param)
! 667: {
! 668: int packet_size;
! 669:
! 670: packet_size = compute_packet_size(net_state, param);
! 671: if (packet_size < 0) {
! 672: return -1;
! 673: }
! 674:
! 675: if (packet_buffer_size < packet_size) {
! 676: errno = EINVAL;
! 677: return -1;
! 678: }
! 679:
! 680: memset(packet_buffer, param->bit_pattern, packet_size);
! 681:
! 682: if (param->ip_version == 6) {
! 683: if (construct_ip6_packet(net_state, packet_socket, sequence,
! 684: packet_buffer, packet_size,
! 685: src_sockaddr, dest_sockaddr, param)) {
! 686: return -1;
! 687: }
! 688: } else if (param->ip_version == 4) {
! 689: if (construct_ip4_packet(net_state, packet_socket, sequence,
! 690: packet_buffer, packet_size,
! 691: src_sockaddr, dest_sockaddr, param)) {
! 692: return -1;
! 693: }
! 694: } else {
! 695: errno = EINVAL;
! 696: return -1;
! 697: }
! 698:
! 699: return packet_size;
! 700: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to construct_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