Annotation of embedaddon/arping/src/arping_test.c, revision 1.1
1.1 ! misho 1: /* arping/src/arping_test.c
! 2: *
! 3: * Copyright (C) 2015-2019 Thomas Habets <thomas@habets.se>
! 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 as published by
! 7: * the Free Software Foundation; either version 2 of the License, or
! 8: * (at your option) any later version.
! 9: *
! 10: * This program is distributed in the hope that it will be useful,
! 11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 13: * GNU General Public License for more details.
! 14: *
! 15: * You should have received a copy of the GNU General Public License along
! 16: * with this program; if not, write to the Free Software Foundation, Inc.,
! 17: * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
! 18: */
! 19: #include"config.h"
! 20: #define _GNU_SOURCE
! 21: #include<assert.h>
! 22: #include<errno.h>
! 23: #include<fcntl.h>
! 24: #include<inttypes.h>
! 25: #include<pthread.h>
! 26: #include<stdio.h>
! 27: #include<stdlib.h>
! 28:
! 29: #include<check.h>
! 30: #include<libnet.h>
! 31: #include<pcap.h>
! 32:
! 33: #include"arping.h"
! 34:
! 35: #ifndef ETH_ALEN
! 36: #define ETH_ALEN 6
! 37: #endif
! 38:
! 39: extern libnet_t* libnet;
! 40: extern int mock_libnet_lo_ok;
! 41: extern int mock_libnet_null_ok;
! 42:
! 43: struct registered_test {
! 44: void* fn;
! 45: const char* name;
! 46: };
! 47:
! 48: static int numtests = 0;
! 49: static struct registered_test test_registry[1024];
! 50:
! 51: static int num_exit_tests = 0;
! 52: static struct registered_test test_exit_registry[1024];
! 53:
! 54: int get_mac_addr(const char *in, char *out);
! 55: void strip_newline(char* s);
! 56:
! 57:
! 58: #define MYTEST(a) static void a(int);__attribute__((constructor)) \
! 59: static void cons_##a() { \
! 60: test_registry[numtests].fn = a; \
! 61: test_registry[numtests].name = #a; \
! 62: numtests++; \
! 63: } START_TEST(a)
! 64:
! 65: #define MY_EXIT_TEST(a) static void a(int);__attribute__((constructor)) \
! 66: static void cons_##a() { \
! 67: test_exit_registry[num_exit_tests].fn = a; \
! 68: test_exit_registry[num_exit_tests].name = #a; \
! 69: num_exit_tests++; \
! 70: } START_TEST(a)
! 71:
! 72: /**
! 73: *
! 74: */
! 75: static void
! 76: xclose(int* fd)
! 77: {
! 78: if (0 > close(*fd)) {
! 79: fprintf(stderr, "close(%d): %s", *fd, strerror(errno));
! 80: *fd = -1;
! 81: }
! 82: }
! 83:
! 84: struct captured_output {
! 85: int saved_fd; // Old fd, will be dup2()ed back in place when done.
! 86: int fno; // Overridden fd (e.g. stdout or stderr).
! 87: int reader_fd; // Reader end of the pipe.
! 88: char* buffer; // Output buffer.
! 89: size_t bufsize; // Buffer size.
! 90: pthread_t thread; // Reader thread.
! 91: };
! 92:
! 93: /**
! 94: * Helper function for stdout/stderr catching.
! 95: *
! 96: * This is the main() for the thread that reads from the fake stdout pipe
! 97: * and writes into the buffer.
! 98: *
! 99: */
! 100: static void*
! 101: read_main(void* p)
! 102: {
! 103: struct captured_output* out = p;
! 104: char *cur = out->buffer;
! 105:
! 106: for (;;) {
! 107: ssize_t n;
! 108: n = out->bufsize - (cur - out->buffer);
! 109: assert(n > 0);
! 110: n = read(out->reader_fd, cur, n);
! 111: if (n > 0) {
! 112: cur += n;
! 113: }
! 114: if (n == 0) {
! 115: return NULL;
! 116: }
! 117: }
! 118: }
! 119:
! 120: /**
! 121: * Helper function to capture stdout/stderr output.
! 122: *
! 123: * Args:
! 124: * fd: The fd to capture.
! 125: * Returns:
! 126: * A structure to be used as a handle. Only thing caller should do with
! 127: * this structure is call stop_capture(), read its .buffer member, and
! 128: * uncapture().
! 129: */
! 130: static struct captured_output*
! 131: capture(int fd)
! 132: {
! 133: struct captured_output* out;
! 134:
! 135: out = calloc(1, sizeof(struct captured_output));
! 136: fail_if(out == NULL);
! 137:
! 138: out->fno = fd;
! 139: out->saved_fd = dup(fd);
! 140: out->bufsize = 1024*100;
! 141: out->buffer = calloc(1, out->bufsize);
! 142:
! 143: fail_if(0 > out->saved_fd);
! 144: fail_if(out->buffer == NULL);
! 145:
! 146: // set up pipe
! 147: int fds[2];
! 148: fail_if(0 > pipe(fds));
! 149: fail_if(0 > dup2(fds[1], fd));
! 150: out->reader_fd = fds[0];
! 151: xclose(&fds[1]);
! 152:
! 153: fail_if(pthread_create(&out->thread, NULL, read_main, (void*)out));
! 154: return out;
! 155: }
! 156:
! 157: /**
! 158: * Helper function to capture stdout/stderr output.
! 159: *
! 160: * Stop capture, so that .buffer becomes readable.
! 161: */
! 162: static void
! 163: stop_capture(struct captured_output* out)
! 164: {
! 165: fail_if(0 > dup2(out->saved_fd, out->fno));
! 166: xclose(&out->saved_fd);
! 167: fail_if(pthread_join(out->thread, NULL));
! 168: xclose(&out->reader_fd);
! 169: }
! 170:
! 171: /**
! 172: * Helper function to capture stdout/stderr output.
! 173: *
! 174: * Deallocate buffer. stop_capture() must be called before uncapture().
! 175: */
! 176: static void
! 177: uncapture(struct captured_output* out)
! 178: {
! 179: free(out->buffer);
! 180: out->buffer = NULL;
! 181: free(out);
! 182: }
! 183:
! 184: static uint8_t*
! 185: mkpacket(struct pcap_pkthdr* pkthdr)
! 186: {
! 187: uint8_t* packet = calloc(1, 1500);
! 188: fail_if(packet == NULL);
! 189:
! 190: struct libnet_802_3_hdr* heth;
! 191: struct libnet_arp_hdr* harp;
! 192:
! 193: // Set up ethernet header
! 194: heth = (void*)packet;
! 195: memcpy(heth->_802_3_dhost, "\x11\x22\x33\x44\x55\x66", 6);
! 196: memcpy(heth->_802_3_shost, "\x77\x88\x99\xaa\xbb\xcc", 6);
! 197: heth->_802_3_len = 0; // FIXME: is this correct?
! 198:
! 199: // Set up ARP header.
! 200: harp = (void*)((char*)heth + LIBNET_ETH_H);
! 201: harp->ar_hln = 6;
! 202: harp->ar_pln = 4;
! 203: harp->ar_hrd = htons(ARPHRD_ETHER);
! 204: harp->ar_op = htons(ARPOP_REPLY);
! 205: harp->ar_pro = htons(ETHERTYPE_IP);
! 206:
! 207: memcpy((char*)harp + LIBNET_ARP_H, heth->_802_3_shost, 6);
! 208: memcpy((char*)harp + LIBNET_ARP_H + harp->ar_hln, &dstip, 4);
! 209:
! 210: memcpy((char*)harp + LIBNET_ARP_H
! 211: + harp->ar_hln
! 212: + harp->ar_pln, heth->_802_3_dhost, 6);
! 213: memcpy((char*)harp + LIBNET_ARP_H
! 214: + harp->ar_hln
! 215: + harp->ar_pln
! 216: + harp->ar_hln, &srcip, 4);
! 217:
! 218: pkthdr->ts.tv_sec = time(NULL);
! 219: pkthdr->ts.tv_usec = 0;
! 220: pkthdr->len = 60;
! 221: pkthdr->caplen = 60;
! 222:
! 223: return packet;
! 224: }
! 225:
! 226: static void
! 227: dump_packet(uint8_t* packet, int len)
! 228: {
! 229: int c;
! 230: for (c = 0; c < len; c++) {
! 231: fprintf(stderr, "0x%.2x, ", (int)packet[c]);
! 232: if (!((c+1) % 10)) {
! 233: fprintf(stderr, "\n");
! 234: }
! 235: }
! 236: fprintf(stderr, "\n");
! 237: }
! 238:
! 239: MYTEST(test_mkpacket)
! 240: {
! 241: uint8_t correct_packet[] = {
! 242: 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
! 243: 0xbb, 0xcc, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04,
! 244: 0x00, 0x02, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0x12, 0x34,
! 245: 0x56, 0x78, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x87, 0x65,
! 246: 0x43, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 247: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 248: };
! 249: struct pcap_pkthdr pkthdr;
! 250: dstip = htonl(0x12345678);
! 251: srcip = htonl(0x87654321);
! 252:
! 253: uint8_t* packet = mkpacket(&pkthdr);
! 254: fail_if(packet == NULL);
! 255: fail_unless(pkthdr.caplen == 60);
! 256: if (memcmp(packet, correct_packet, pkthdr.caplen)) {
! 257: dump_packet(packet, pkthdr.caplen);
! 258: }
! 259: fail_unless(!memcmp(packet, correct_packet, pkthdr.caplen));
! 260: } END_TEST
! 261:
! 262:
! 263: // Received uninteresting packet, should not record anything.
! 264: MYTEST(pingip_uninteresting_packet)
! 265: {
! 266: struct pcap_pkthdr pkthdr;
! 267: uint8_t* packet;
! 268: struct libnet_802_3_hdr* heth;
! 269: struct libnet_arp_hdr* harp;
! 270:
! 271: int prev_numrecvd = numrecvd;
! 272: struct captured_output* sout;
! 273:
! 274: // Completely broken packet.
! 275: packet = calloc(1, 1500);
! 276: sout = capture(1);
! 277: pingip_recv(NULL, &pkthdr, packet);
! 278: stop_capture(sout);
! 279: fail_unless(strlen(sout->buffer) == 0);
! 280: fail_unless(prev_numrecvd == numrecvd);
! 281: uncapture(sout);
! 282: free(packet);
! 283:
! 284: // Not ETHERTYPE_IP.
! 285: packet = mkpacket(&pkthdr);
! 286: harp = (void*)((char*)packet + LIBNET_ETH_H);
! 287: harp->ar_pro = 0;
! 288: sout = capture(1);
! 289: pingip_recv(NULL, &pkthdr, packet);
! 290: stop_capture(sout);
! 291: fail_unless(prev_numrecvd == numrecvd);
! 292: fail_unless(strlen(sout->buffer) == 0);
! 293: uncapture(sout);
! 294: free(packet);
! 295:
! 296: // Not ARPHRD_ETHER
! 297: packet = mkpacket(&pkthdr);
! 298: harp = (void*)((char*)packet + LIBNET_ETH_H);
! 299: harp->ar_hrd = 0;
! 300: sout = capture(1);
! 301: pingip_recv(NULL, &pkthdr, packet);
! 302: stop_capture(sout);
! 303: fail_unless(prev_numrecvd == numrecvd);
! 304: fail_unless(strlen(sout->buffer) == 0);
! 305: uncapture(sout);
! 306: free(packet);
! 307:
! 308: // Wrong dstip
! 309: if (0) {
! 310: uint32_t wrongip = 123;
! 311: packet = mkpacket(&pkthdr);
! 312: harp = (void*)((char*)packet + LIBNET_ETH_H);
! 313: memcpy((char*)harp + harp->ar_hln + LIBNET_ARP_H, &wrongip, 4);
! 314: sout = capture(1);
! 315: pingip_recv(NULL, &pkthdr, packet);
! 316: stop_capture(sout);
! 317: fail_unless(prev_numrecvd == numrecvd);
! 318: fail_unless(strlen(sout->buffer) == 0);
! 319: uncapture(sout);
! 320: free(packet);
! 321: }
! 322:
! 323: // Short packet.
! 324: packet = mkpacket(&pkthdr);
! 325: pkthdr.caplen = pkthdr.len = 41;
! 326: sout = capture(1);
! 327: pingip_recv(NULL, &pkthdr, packet);
! 328: stop_capture(sout);
! 329: fail_unless(prev_numrecvd == numrecvd);
! 330: fail_unless(strlen(sout->buffer) == 0);
! 331: uncapture(sout);
! 332: free(packet);
! 333:
! 334: // Short captured packet.
! 335: packet = mkpacket(&pkthdr);
! 336: pkthdr.caplen = 41;
! 337: sout = capture(1);
! 338: pingip_recv(NULL, &pkthdr, packet);
! 339: stop_capture(sout);
! 340: fail_unless(prev_numrecvd == numrecvd);
! 341: fail_unless(strlen(sout->buffer) == 0);
! 342: uncapture(sout);
! 343: free(packet);
! 344:
! 345: // Wrong length of hardware address.
! 346: {
! 347: uint8_t packet[] = {
! 348: 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, // dst
! 349: 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, // src
! 350: 0x00, 0x00, // type
! 351: 0x00, 0x01, // hardware
! 352: 0x08, 0x00, // protocol
! 353: 0x04, 0x04, // lengths (for this test length is wrong)
! 354: 0x00, 0x02, // operator
! 355:
! 356: 0x77, 0x88, 0x99, 0xaa, // sender (wrong length for test)
! 357: 0x12, 0x34, 0x56, 0x78, // sender protocol address
! 358:
! 359: 0x11, 0x22, 0x33, 0x44, // receiver (wrong length for test)
! 360: 0x87, 0x65, 0x43, 0x21, // receiver protocol address
! 361:
! 362: 0x00, 0x00, 0x00, 0x00,
! 363: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 364: 0x00, 0x00, 0x00, 0x00,
! 365: 0x00, 0x00, 0x00, 0x00,
! 366: 0x00, 0x00, 0x00, 0x00,
! 367: 0x6f, 0xa8, 0x58, 0x63,
! 368: };
! 369: pkthdr.len = 60;
! 370: pkthdr.caplen = 60;
! 371: sout = capture(1);
! 372: pingip_recv(NULL, &pkthdr, packet);
! 373: stop_capture(sout);
! 374: fail_unless(strlen(sout->buffer) == 0, sout->buffer);
! 375: fail_unless(prev_numrecvd == numrecvd);
! 376: uncapture(sout);
! 377: }
! 378:
! 379: // Wrong length of protocol address.
! 380: packet = mkpacket(&pkthdr);
! 381: ((struct libnet_arp_hdr*)((char*)packet + LIBNET_ETH_H))->ar_pln = 6;
! 382: sout = capture(1);
! 383: pingip_recv(NULL, &pkthdr, packet);
! 384: stop_capture(sout);
! 385: fail_unless(prev_numrecvd == numrecvd);
! 386: fail_unless(strlen(sout->buffer) == 0);
! 387: uncapture(sout);
! 388: free(packet);
! 389: } END_TEST
! 390:
! 391: // Received reply that actually matches. Things should happen.
! 392: MYTEST(pingip_interesting_packet)
! 393: {
! 394: struct pcap_pkthdr pkthdr;
! 395: extern uint8_t srcmac[ETH_ALEN];
! 396: memcpy(srcmac, "\x11\x22\x33\x44\x55\x66", ETH_ALEN);
! 397: uint8_t packet[] = {
! 398: 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, // dst
! 399: 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, // src
! 400: 0x00, 0x00, // type
! 401: 0x00, 0x01, // hardware
! 402: 0x08, 0x00, // protocol
! 403: 0x06, 0x04, // lengths
! 404: 0x00, 0x02, // operator
! 405:
! 406: 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, // sender
! 407: 0x12, 0x34, 0x56, 0x78, // sender protocol address
! 408:
! 409: 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, // receiver
! 410: 0x87, 0x65, 0x43, 0x21, // receiver protocol address
! 411:
! 412: 0x00, 0x00, 0x00, 0x00,
! 413: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 414: 0x6f, 0xa8, 0x58, 0x63,
! 415: };
! 416: numrecvd = 0;
! 417: int prev_numrecvd = numrecvd;
! 418:
! 419: dstip = htonl(0x12345678);
! 420:
! 421: pkthdr.ts.tv_sec = time(NULL);
! 422: pkthdr.ts.tv_usec = 0;
! 423: pkthdr.len = 60;
! 424: pkthdr.caplen = 60;
! 425:
! 426: struct captured_output *sout;
! 427:
! 428: // First ping.
! 429: const char* correct0 =
! 430: "60 bytes from 77:88:99:aa:bb:cc (18.52.86.120): "
! 431: "index=0 time=";
! 432: sout = capture(1);
! 433: pingip_recv(NULL, &pkthdr, packet);
! 434: stop_capture(sout);
! 435:
! 436: char* emsg = NULL;
! 437: fail_unless(0 < asprintf(&emsg, "Captured: <%s> (%zd), want <%s> %zd\n",
! 438: sout->buffer, strlen(sout->buffer),
! 439: correct0, strlen(correct0)));
! 440: fail_unless(!strncmp(sout->buffer, correct0, strlen(correct0)), emsg);
! 441: uncapture(sout);
! 442: free(emsg);
! 443:
! 444: fail_unless(numrecvd == prev_numrecvd + 1,
! 445: "numrecvd not incremented");
! 446:
! 447: pingip_recv(NULL, &pkthdr, packet);
! 448: fail_unless(numrecvd == prev_numrecvd + 2,
! 449: "numrecvd not incremented second time");
! 450: } END_TEST
! 451:
! 452: MYTEST(strip_newline_test)
! 453: {
! 454: const char *tests[][2] = {
! 455: {"", ""},
! 456: {"\n", ""},
! 457: {"\n\n\n", ""},
! 458: {"foo", "foo"},
! 459: {"foo\n", "foo"},
! 460: {"foo\n\n\n", "foo"},
! 461: {NULL, NULL},
! 462: };
! 463: int c;
! 464: for (c = 0; tests[c][0]; c++){
! 465: char buf[128];
! 466: strcpy(buf, tests[c][0]);
! 467: strip_newline(buf);
! 468: fail_unless(!strcmp(buf, tests[c][1]));
! 469: }
! 470: } END_TEST
! 471:
! 472: MYTEST(get_mac_addr_success)
! 473: {
! 474: const char *tests[][2] = {
! 475: // Null.
! 476: {"0000.0000.0000", "\x00\x00\x00\x00\x00\x00"},
! 477: {"00:00:00:00:00:00", "\x00\x00\x00\x00\x00\x00"},
! 478: {"00-00-00-00-00-00", "\x00\x00\x00\x00\x00\x00"},
! 479:
! 480: // Broadcast.
! 481: {"FFFF.FFFF.FFFF", "\xFF\xFF\xFF\xFF\xFF\xFF"},
! 482: {"FF:FF:FF:FF:FF:FF", "\xFF\xFF\xFF\xFF\xFF\xFF"},
! 483: {"FF-FF-FF-FF-FF-FF", "\xFF\xFF\xFF\xFF\xFF\xFF"},
! 484:
! 485: // Normal looking.
! 486: {"1122.3344.5566", "\x11\x22\x33\x44\x55\x66"},
! 487: {"11:22:33:44:55:66", "\x11\x22\x33\x44\x55\x66"},
! 488: {"11-22-33-44-55-66", "\x11\x22\x33\x44\x55\x66"},
! 489:
! 490: // Has some zeroes.
! 491: {"1100.0000.5566", "\x11\x00\x00\x00\x55\x66"},
! 492: {"11:00:00:00:55:66", "\x11\x00\x00\x00\x55\x66"},
! 493: {"11-00-00-00-55-66", "\x11\x00\x00\x00\x55\x66"},
! 494: {NULL, NULL},
! 495: };
! 496: int c;
! 497: for (c = 0; tests[c][0]; c++){
! 498: char buf[6];
! 499: fail_unless(get_mac_addr(tests[c][0], buf));
! 500: fail_unless(!memcmp(buf, tests[c][1], 6));
! 501: }
! 502: } END_TEST
! 503:
! 504: MYTEST(get_mac_addr_fail)
! 505: {
! 506: const char *tests[] = {
! 507: "",
! 508: "blaha",
! 509: "11:22:33:44:55",
! 510: "11:22:33:44:55:zz",
! 511: NULL,
! 512: };
! 513: int c;
! 514: for (c = 0; tests[c]; c++){
! 515: char buf[6];
! 516: fail_if(get_mac_addr(tests[c], buf));
! 517: }
! 518: } END_TEST
! 519:
! 520: MY_EXIT_TEST(libnet_init_bad_nolo)
! 521: {
! 522: // It'll only try lo if named interface fails.
! 523: // So by accepting lo, we make sure it doesn't try lo.
! 524: mock_libnet_lo_ok = 1;
! 525: do_libnet_init("bad", 0);
! 526: } END_TEST
! 527:
! 528: MY_EXIT_TEST(libnet_init_null_nolo_nonull)
! 529: {
! 530: mock_libnet_lo_ok = 0;
! 531: mock_libnet_null_ok = 0;
! 532: do_libnet_init(NULL, 0);
! 533: } END_TEST
! 534:
! 535: MYTEST(libnet_init_good)
! 536: {
! 537: mock_libnet_lo_ok = 0; // Don't even try falling back to lo.
! 538: do_libnet_init("good", 0);
! 539: fail_if(libnet == NULL);
! 540: } END_TEST
! 541:
! 542: MYTEST(libnet_init_null_nolo)
! 543: {
! 544: mock_libnet_lo_ok = 0;
! 545: mock_libnet_null_ok = 1;
! 546: do_libnet_init(NULL, 0);
! 547: fail_if(libnet == NULL);
! 548: } END_TEST
! 549:
! 550: static Suite*
! 551: arping_suite(void)
! 552: {
! 553: int c;
! 554: Suite* s = suite_create("Arping");
! 555:
! 556: //tcase_add_checked_fixture (tc_core, setup, teardown);
! 557: for (c = 0; c < numtests; c++) {
! 558: TCase *tc_core = tcase_create(test_registry[c].name);
! 559: tcase_add_test(tc_core, test_registry[c].fn);
! 560: suite_add_tcase(s, tc_core);
! 561: }
! 562: for (c = 0; c < num_exit_tests; c++) {
! 563: TCase *tc_core = tcase_create(test_exit_registry[c].name);
! 564: tcase_add_exit_test(tc_core, test_exit_registry[c].fn, 1);
! 565: suite_add_tcase(s, tc_core);
! 566: }
! 567: return s;
! 568: }
! 569:
! 570: int
! 571: main()
! 572: {
! 573: int number_failed;
! 574: Suite *s = arping_suite();
! 575: SRunner *sr = srunner_create (s);
! 576: srunner_run_all (sr, CK_NORMAL);
! 577: number_failed = srunner_ntests_failed (sr);
! 578: srunner_free (sr);
! 579: return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
! 580: }
! 581: /* ---- Emacs Variables ----
! 582: * Local Variables:
! 583: * c-basic-offset: 8
! 584: * indent-tabs-mode: nil
! 585: * End:
! 586: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to arping_test.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / arping / src