1/* $NetBSD: iptests.c,v 1.5 2018/02/04 08:19:42 mrg Exp $ */ 2 3/* 4 * Copyright (C) 2012 by Darren Reed. 5 * 6 * See the IPFILTER.LICENCE file for details on licencing. 7 * 8 */ 9#if !defined(lint) 10static __attribute__((__used__)) const char sccsid[] = "%W% %G% (C)1995 Darren Reed"; 11static __attribute__((__used__)) const char rcsid[] = "@(#)Id: iptests.c,v 1.1.1.2 2012/07/22 13:44:37 darrenr"; 12#endif 13#include <sys/param.h> 14#include <sys/types.h> 15#include <stdbool.h> 16#if defined(__NetBSD__) && defined(__vax__) 17/* 18 * XXX need to declare boolean_t for _KERNEL <sys/files.h> 19 * which ends up including <sys/device.h> for vax. See PR#32907 20 * for further details. 21 */ 22typedef int boolean_t; 23#endif 24#include <sys/time.h> 25#if !defined(__osf__) 26# ifdef __NetBSD__ 27# include <machine/lock.h> 28# include <sys/mutex.h> 29# endif 30# define _KERNEL 31# define KERNEL 32# if !defined(solaris) && !defined(linux) && !defined(__sgi) && !defined(hpux) 33# include <sys/file.h> 34# else 35# ifdef solaris 36# include <sys/dditypes.h> 37# endif 38# endif 39# undef _KERNEL 40# undef KERNEL 41#endif 42#if !defined(solaris) && !defined(linux) && !defined(__sgi) 43# include <nlist.h> 44#if defined(__FreeBSD__) 45# include <sys/user.h> 46#endif 47# include <sys/proc.h> 48#endif 49#if !defined(ultrix) && !defined(hpux) && !defined(linux) && \ 50 !defined(__sgi) && !defined(__osf__) && !defined(_AIX51) 51# include <kvm.h> 52#endif 53#ifndef ultrix 54# include <sys/socket.h> 55#endif 56#if defined(solaris) 57# include <sys/stream.h> 58#else 59# include <sys/socketvar.h> 60#endif 61#ifdef sun 62#include <sys/systm.h> 63#include <sys/session.h> 64#endif 65#if BSD >= 199103 66# include <sys/sysctl.h> 67# include <sys/filedesc.h> 68# include <paths.h> 69#endif 70#include <netinet/in_systm.h> 71#include <sys/socket.h> 72#ifdef __hpux 73# define _NET_ROUTE_INCLUDED 74#endif 75#include <net/if.h> 76#if defined(linux) && (LINUX >= 0200) 77# include <asm/atomic.h> 78#endif 79#if !defined(linux) 80# if defined(__FreeBSD__) 81# include "radix_ipf.h" 82# endif 83# if !defined(solaris) 84# include <net/route.h> 85# endif 86#else 87# define __KERNEL__ /* because there's a macro not wrapped by this */ 88# include <net/route.h> /* in this file :-/ */ 89#endif 90#include <netinet/in.h> 91#include <arpa/inet.h> 92#include <netinet/ip.h> 93#if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 94# include <sys/sysmacros.h> 95#endif 96#include <stdio.h> 97#include <unistd.h> 98#include <stdlib.h> 99#include <string.h> 100#ifdef __hpux 101# undef _NET_ROUTE_INCLUDED 102#endif 103#if !defined(linux) 104# include <netinet/ip_var.h> 105# if !defined(__hpux) && !defined(solaris) 106# include <netinet/in_pcb.h> 107# endif 108#endif 109#include "ipsend.h" 110#if !defined(linux) && !defined(__hpux) 111# include <netinet/tcp_timer.h> 112# include <netinet/tcp_var.h> 113#endif 114#if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 106000000) 115# define USE_NANOSLEEP 116#endif 117 118 119#ifdef USE_NANOSLEEP 120# define PAUSE() ts.tv_sec = 0; ts.tv_nsec = 10000000; \ 121 (void) nanosleep(&ts, NULL) 122#else 123# define PAUSE() tv.tv_sec = 0; tv.tv_usec = 10000; \ 124 (void) select(0, NULL, NULL, NULL, &tv) 125#endif 126 127 128void ip_test1(dev, mtu, ip, gwip, ptest) 129 char *dev; 130 int mtu; 131 ip_t *ip; 132 struct in_addr gwip; 133 int ptest; 134{ 135#ifdef USE_NANOSLEEP 136 struct timespec ts; 137#else 138 struct timeval tv; 139#endif 140 udphdr_t *u; 141 int nfd, i = 0, len, id = getpid(); 142 143 IP_HL_A(ip, sizeof(*ip) >> 2); 144 IP_V_A(ip, IPVERSION); 145 ip->ip_tos = 0; 146 ip->ip_off = 0; 147 ip->ip_ttl = 60; 148 ip->ip_p = IPPROTO_UDP; 149 ip->ip_sum = 0; 150 u = (udphdr_t *)(ip + 1); 151 u->uh_sport = htons(1); 152 u->uh_dport = htons(9); 153 u->uh_sum = 0; 154 u->uh_ulen = htons(sizeof(*u) + 4); 155 ip->ip_len = sizeof(*ip) + ntohs(u->uh_ulen); 156 len = ip->ip_len; 157 158 nfd = initdevice(dev, 1); 159 if (nfd == -1) 160 return; 161 162 if (!ptest || (ptest == 1)) { 163 /* 164 * Part1: hl < len 165 */ 166 ip->ip_id = 0; 167 printf("1.1. sending packets with ip_hl < ip_len\n"); 168 for (i = 0; i < ((sizeof(*ip) + ntohs(u->uh_ulen)) >> 2); i++) { 169 IP_HL_A(ip, i >> 2); 170 (void) send_ip(nfd, 1500, ip, gwip, 1); 171 printf("%d\r", i); 172 fflush(stdout); 173 PAUSE(); 174 } 175 putchar('\n'); 176 } 177 178 if (!ptest || (ptest == 2)) { 179 /* 180 * Part2: hl > len 181 */ 182 ip->ip_id = 0; 183 printf("1.2. sending packets with ip_hl > ip_len\n"); 184 for (; i < ((sizeof(*ip) * 2 + ntohs(u->uh_ulen)) >> 2); i++) { 185 IP_HL_A(ip, i >> 2); 186 (void) send_ip(nfd, 1500, ip, gwip, 1); 187 printf("%d\r", i); 188 fflush(stdout); 189 PAUSE(); 190 } 191 putchar('\n'); 192 } 193 194 if (!ptest || (ptest == 3)) { 195 /* 196 * Part3: v < 4 197 */ 198 ip->ip_id = 0; 199 printf("1.3. ip_v < 4\n"); 200 IP_HL_A(ip, sizeof(*ip) >> 2); 201 for (i = 0; i < 4; i++) { 202 IP_V_A(ip, i); 203 (void) send_ip(nfd, 1500, ip, gwip, 1); 204 printf("%d\r", i); 205 fflush(stdout); 206 PAUSE(); 207 } 208 putchar('\n'); 209 } 210 211 if (!ptest || (ptest == 4)) { 212 /* 213 * Part4: v > 4 214 */ 215 ip->ip_id = 0; 216 printf("1.4. ip_v > 4\n"); 217 for (i = 5; i < 16; i++) { 218 IP_V_A(ip, i); 219 (void) send_ip(nfd, 1500, ip, gwip, 1); 220 printf("%d\r", i); 221 fflush(stdout); 222 PAUSE(); 223 } 224 putchar('\n'); 225 } 226 227 if (!ptest || (ptest == 5)) { 228 /* 229 * Part5: len < packet 230 */ 231 ip->ip_id = 0; 232 IP_V_A(ip, IPVERSION); 233 i = ip->ip_len + 1; 234 printf("1.5.0 ip_len < packet size (size++, long packets)\n"); 235 for (; i < (ip->ip_len * 2); i++) { 236 ip->ip_id = htons(id++); 237 ip->ip_sum = 0; 238 ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 239 (void) send_ether(nfd, (char *)ip, i, gwip); 240 printf("%d\r", i); 241 fflush(stdout); 242 PAUSE(); 243 } 244 putchar('\n'); 245 printf("1.5.1 ip_len < packet size (ip_len-, short packets)\n"); 246 for (i = len; i > 0; i--) { 247 ip->ip_id = htons(id++); 248 ip->ip_len = i; 249 ip->ip_sum = 0; 250 ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 251 (void) send_ether(nfd, (char *)ip, len, gwip); 252 printf("%d\r", i); 253 fflush(stdout); 254 PAUSE(); 255 } 256 putchar('\n'); 257 } 258 259 if (!ptest || (ptest == 6)) { 260 /* 261 * Part6: len > packet 262 */ 263 ip->ip_id = 0; 264 printf("1.6.0 ip_len > packet size (increase ip_len)\n"); 265 for (i = len + 1; i < (len * 2); i++) { 266 ip->ip_id = htons(id++); 267 ip->ip_len = i; 268 ip->ip_sum = 0; 269 ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 270 (void) send_ether(nfd, (char *)ip, len, gwip); 271 printf("%d\r", i); 272 fflush(stdout); 273 PAUSE(); 274 } 275 putchar('\n'); 276 ip->ip_len = len; 277 printf("1.6.1 ip_len > packet size (size--, short packets)\n"); 278 for (i = len; i > 0; i--) { 279 ip->ip_id = htons(id++); 280 ip->ip_sum = 0; 281 ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 282 (void) send_ether(nfd, (char *)ip, i, gwip); 283 printf("%d\r", i); 284 fflush(stdout); 285 PAUSE(); 286 } 287 putchar('\n'); 288 } 289 290 if (!ptest || (ptest == 7)) { 291 /* 292 * Part7: 0 length fragment 293 */ 294 printf("1.7.0 Zero length fragments (ip_off = 0x2000)\n"); 295 ip->ip_id = 0; 296 ip->ip_len = sizeof(*ip); 297 ip->ip_off = htons(IP_MF); 298 (void) send_ip(nfd, mtu, ip, gwip, 1); 299 fflush(stdout); 300 PAUSE(); 301 302 printf("1.7.1 Zero length fragments (ip_off = 0x3000)\n"); 303 ip->ip_id = 0; 304 ip->ip_len = sizeof(*ip); 305 ip->ip_off = htons(IP_MF); 306 (void) send_ip(nfd, mtu, ip, gwip, 1); 307 fflush(stdout); 308 PAUSE(); 309 310 printf("1.7.2 Zero length fragments (ip_off = 0xa000)\n"); 311 ip->ip_id = 0; 312 ip->ip_len = sizeof(*ip); 313 ip->ip_off = htons(0xa000); 314 (void) send_ip(nfd, mtu, ip, gwip, 1); 315 fflush(stdout); 316 PAUSE(); 317 318 printf("1.7.3 Zero length fragments (ip_off = 0x0100)\n"); 319 ip->ip_id = 0; 320 ip->ip_len = sizeof(*ip); 321 ip->ip_off = htons(0x0100); 322 (void) send_ip(nfd, mtu, ip, gwip, 1); 323 fflush(stdout); 324 PAUSE(); 325 } 326 327 if (!ptest || (ptest == 8)) { 328 struct timeval tv; 329 330 gettimeofday(&tv, NULL); 331 srand(tv.tv_sec ^ getpid() ^ tv.tv_usec); 332 /* 333 * Part8.1: 63k packet + 1k fragment at offset 0x1ffe 334 * Mark it as being ICMP (so it doesn't get junked), but 335 * don't bother about the ICMP header, we're not worrying 336 * about that here. 337 */ 338 ip->ip_p = IPPROTO_ICMP; 339 ip->ip_off = htons(IP_MF); 340 u->uh_dport = htons(9); 341 ip->ip_id = htons(id++); 342 printf("1.8.1 63k packet + 1k fragment at offset 0x1ffe\n"); 343 ip->ip_len = 768 + 20 + 8; 344 (void) send_ip(nfd, mtu, ip, gwip, 1); 345 printf("%d\r", i); 346 347 ip->ip_len = MIN(768 + 20, mtu - 68); 348 i = 512; 349 for (; i < (63 * 1024 + 768); i += 768) { 350 ip->ip_off = htons(IP_MF | (i >> 3)); 351 (void) send_ip(nfd, mtu, ip, gwip, 1); 352 printf("%d\r", i); 353 fflush(stdout); 354 PAUSE(); 355 } 356 ip->ip_len = 896 + 20; 357 ip->ip_off = htons(i >> 3); 358 (void) send_ip(nfd, mtu, ip, gwip, 1); 359 printf("%d\r", i); 360 putchar('\n'); 361 fflush(stdout); 362 363 /* 364 * Part8.2: 63k packet + 1k fragment at offset 0x1ffe 365 * Mark it as being ICMP (so it doesn't get junked), but 366 * don't bother about the ICMP header, we're not worrying 367 * about that here. (Lossage here) 368 */ 369 ip->ip_p = IPPROTO_ICMP; 370 ip->ip_off = htons(IP_MF); 371 u->uh_dport = htons(9); 372 ip->ip_id = htons(id++); 373 printf("1.8.2 63k packet + 1k fragment at offset 0x1ffe\n"); 374 ip->ip_len = 768 + 20 + 8; 375 if ((rand() & 0x1f) != 0) { 376 (void) send_ip(nfd, mtu, ip, gwip, 1); 377 printf("%d\r", i); 378 } else 379 printf("skip 0\n"); 380 381 ip->ip_len = MIN(768 + 20, mtu - 68); 382 i = 512; 383 for (; i < (63 * 1024 + 768); i += 768) { 384 ip->ip_off = htons(IP_MF | (i >> 3)); 385 if ((rand() & 0x1f) != 0) { 386 (void) send_ip(nfd, mtu, ip, gwip, 1); 387 printf("%d\r", i); 388 } else 389 printf("skip %d\n", i); 390 fflush(stdout); 391 PAUSE(); 392 } 393 ip->ip_len = 896 + 20; 394 ip->ip_off = htons(i >> 3); 395 if ((rand() & 0x1f) != 0) { 396 (void) send_ip(nfd, mtu, ip, gwip, 1); 397 printf("%d\r", i); 398 } else 399 printf("skip\n"); 400 putchar('\n'); 401 fflush(stdout); 402 403 /* 404 * Part8.3: 33k packet - test for not dealing with -ve length 405 * Mark it as being ICMP (so it doesn't get junked), but 406 * don't bother about the ICMP header, we're not worrying 407 * about that here. 408 */ 409 ip->ip_p = IPPROTO_ICMP; 410 ip->ip_off = htons(IP_MF); 411 u->uh_dport = htons(9); 412 ip->ip_id = htons(id++); 413 printf("1.8.3 33k packet\n"); 414 ip->ip_len = 768 + 20 + 8; 415 (void) send_ip(nfd, mtu, ip, gwip, 1); 416 printf("%d\r", i); 417 418 ip->ip_len = MIN(768 + 20, mtu - 68); 419 i = 512; 420 for (; i < (32 * 1024 + 768); i += 768) { 421 ip->ip_off = htons(IP_MF | (i >> 3)); 422 (void) send_ip(nfd, mtu, ip, gwip, 1); 423 printf("%d\r", i); 424 fflush(stdout); 425 PAUSE(); 426 } 427 ip->ip_len = 896 + 20; 428 ip->ip_off = htons(i >> 3); 429 (void) send_ip(nfd, mtu, ip, gwip, 1); 430 printf("%d\r", i); 431 putchar('\n'); 432 fflush(stdout); 433 } 434 435 ip->ip_len = len; 436 ip->ip_off = 0; 437 if (!ptest || (ptest == 9)) { 438 /* 439 * Part9: off & 0x8000 == 0x8000 440 */ 441 ip->ip_id = 0; 442 ip->ip_off = htons(0x8000); 443 printf("1.9. ip_off & 0x8000 == 0x8000\n"); 444 (void) send_ip(nfd, mtu, ip, gwip, 1); 445 fflush(stdout); 446 PAUSE(); 447 } 448 449 ip->ip_off = 0; 450 451 if (!ptest || (ptest == 10)) { 452 /* 453 * Part10: ttl = 255 454 */ 455 ip->ip_id = 0; 456 ip->ip_ttl = 255; 457 printf("1.10.0 ip_ttl = 255\n"); 458 (void) send_ip(nfd, mtu, ip, gwip, 1); 459 fflush(stdout); 460 PAUSE(); 461 462 ip->ip_ttl = 128; 463 printf("1.10.1 ip_ttl = 128\n"); 464 (void) send_ip(nfd, mtu, ip, gwip, 1); 465 fflush(stdout); 466 PAUSE(); 467 468 ip->ip_ttl = 0; 469 printf("1.10.2 ip_ttl = 0\n"); 470 (void) send_ip(nfd, mtu, ip, gwip, 1); 471 fflush(stdout); 472 PAUSE(); 473 } 474 475 (void) close(nfd); 476} 477 478 479void ip_test2(dev, mtu, ip, gwip, ptest) 480 char *dev; 481 int mtu; 482 ip_t *ip; 483 struct in_addr gwip; 484 int ptest; 485{ 486#ifdef USE_NANOSLEEP 487 struct timespec ts; 488#else 489 struct timeval tv; 490#endif 491 int nfd; 492 u_char *s; 493 494 495 nfd = initdevice(dev, 1); 496 if (nfd == -1) 497 return; 498 499 IP_HL_A(ip, 6); 500 ip->ip_len = IP_HL(ip) << 2; 501 s = (u_char *)(ip + 1); 502 s[IPOPT_OPTVAL] = IPOPT_NOP; 503 s++; 504 if (!ptest || (ptest == 1)) { 505 /* 506 * Test 1: option length > packet length, 507 * header length == packet length 508 */ 509 s[IPOPT_OPTVAL] = IPOPT_TS; 510 s[IPOPT_OLEN] = 4; 511 s[IPOPT_OFFSET] = IPOPT_MINOFF; 512 ip->ip_p = IPPROTO_IP; 513 printf("2.1 option length > packet length\n"); 514 (void) send_ip(nfd, mtu, ip, gwip, 1); 515 fflush(stdout); 516 PAUSE(); 517 } 518 519 IP_HL_A(ip, 7); 520 ip->ip_len = IP_HL(ip) << 2; 521 if (!ptest || (ptest == 1)) { 522 /* 523 * Test 2: options have length = 0 524 */ 525 printf("2.2.1 option length = 0, RR\n"); 526 s[IPOPT_OPTVAL] = IPOPT_RR; 527 s[IPOPT_OLEN] = 0; 528 (void) send_ip(nfd, mtu, ip, gwip, 1); 529 fflush(stdout); 530 PAUSE(); 531 532 printf("2.2.2 option length = 0, TS\n"); 533 s[IPOPT_OPTVAL] = IPOPT_TS; 534 s[IPOPT_OLEN] = 0; 535 (void) send_ip(nfd, mtu, ip, gwip, 1); 536 fflush(stdout); 537 PAUSE(); 538 539 printf("2.2.3 option length = 0, SECURITY\n"); 540 s[IPOPT_OPTVAL] = IPOPT_SECURITY; 541 s[IPOPT_OLEN] = 0; 542 (void) send_ip(nfd, mtu, ip, gwip, 1); 543 fflush(stdout); 544 PAUSE(); 545 546 printf("2.2.4 option length = 0, LSRR\n"); 547 s[IPOPT_OPTVAL] = IPOPT_LSRR; 548 s[IPOPT_OLEN] = 0; 549 (void) send_ip(nfd, mtu, ip, gwip, 1); 550 fflush(stdout); 551 PAUSE(); 552 553 printf("2.2.5 option length = 0, SATID\n"); 554 s[IPOPT_OPTVAL] = IPOPT_SATID; 555 s[IPOPT_OLEN] = 0; 556 (void) send_ip(nfd, mtu, ip, gwip, 1); 557 fflush(stdout); 558 PAUSE(); 559 560 printf("2.2.6 option length = 0, SSRR\n"); 561 s[IPOPT_OPTVAL] = IPOPT_SSRR; 562 s[IPOPT_OLEN] = 0; 563 (void) send_ip(nfd, mtu, ip, gwip, 1); 564 fflush(stdout); 565 PAUSE(); 566 } 567 568 (void) close(nfd); 569} 570 571 572/* 573 * test 3 (ICMP) 574 */ 575void ip_test3(dev, mtu, ip, gwip, ptest) 576 char *dev; 577 int mtu; 578 ip_t *ip; 579 struct in_addr gwip; 580 int ptest; 581{ 582 static int ict1[10] = { 8, 9, 10, 13, 14, 15, 16, 17, 18, 0 }; 583 static int ict2[8] = { 3, 9, 10, 13, 14, 17, 18, 0 }; 584#ifdef USE_NANOSLEEP 585 struct timespec ts; 586#else 587 struct timeval tv; 588#endif 589 struct icmp *icp; 590 int nfd, i; 591 592 IP_HL_A(ip, sizeof(*ip) >> 2); 593 IP_V_A(ip, IPVERSION); 594 ip->ip_tos = 0; 595 ip->ip_off = 0; 596 ip->ip_ttl = 60; 597 ip->ip_p = IPPROTO_ICMP; 598 ip->ip_sum = 0; 599 ip->ip_len = sizeof(*ip) + sizeof(*icp); 600 icp = (struct icmp *)((char *)ip + (IP_HL(ip) << 2)); 601 602 nfd = initdevice(dev, 1); 603 if (nfd == -1) 604 return; 605 606 if (!ptest || (ptest == 1)) { 607 /* 608 * Type 0 - 31, 255, code = 0 609 */ 610 bzero((char *)icp, sizeof(*icp)); 611 for (i = 0; i < 32; i++) { 612 icp->icmp_type = i; 613 (void) send_icmp(nfd, mtu, ip, gwip); 614 PAUSE(); 615 printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, i); 616 } 617 icp->icmp_type = 255; 618 (void) send_icmp(nfd, mtu, ip, gwip); 619 PAUSE(); 620 printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, 255); 621 putchar('\n'); 622 } 623 624 if (!ptest || (ptest == 2)) { 625 /* 626 * Type 3, code = 0 - 31 627 */ 628 icp->icmp_type = 3; 629 for (i = 0; i < 32; i++) { 630 icp->icmp_code = i; 631 (void) send_icmp(nfd, mtu, ip, gwip); 632 PAUSE(); 633 printf("3.2.%d ICMP type 3 code %d (all 0's)\r", i, i); 634 } 635 } 636 637 if (!ptest || (ptest == 3)) { 638 /* 639 * Type 4, code = 0,127,128,255 640 */ 641 icp->icmp_type = 4; 642 icp->icmp_code = 0; 643 (void) send_icmp(nfd, mtu, ip, gwip); 644 PAUSE(); 645 printf("3.3.1 ICMP type 4 code 0 (all 0's)\r"); 646 icp->icmp_code = 127; 647 (void) send_icmp(nfd, mtu, ip, gwip); 648 PAUSE(); 649 printf("3.3.2 ICMP type 4 code 127 (all 0's)\r"); 650 icp->icmp_code = 128; 651 (void) send_icmp(nfd, mtu, ip, gwip); 652 PAUSE(); 653 printf("3.3.3 ICMP type 4 code 128 (all 0's)\r"); 654 icp->icmp_code = 255; 655 (void) send_icmp(nfd, mtu, ip, gwip); 656 PAUSE(); 657 printf("3.3.4 ICMP type 4 code 255 (all 0's)\r"); 658 } 659 660 if (!ptest || (ptest == 4)) { 661 /* 662 * Type 5, code = 0,127,128,255 663 */ 664 icp->icmp_type = 5; 665 icp->icmp_code = 0; 666 (void) send_icmp(nfd, mtu, ip, gwip); 667 PAUSE(); 668 printf("3.4.1 ICMP type 5 code 0 (all 0's)\r"); 669 icp->icmp_code = 127; 670 (void) send_icmp(nfd, mtu, ip, gwip); 671 PAUSE(); 672 printf("3.4.2 ICMP type 5 code 127 (all 0's)\r"); 673 icp->icmp_code = 128; 674 (void) send_icmp(nfd, mtu, ip, gwip); 675 PAUSE(); 676 printf("3.4.3 ICMP type 5 code 128 (all 0's)\r"); 677 icp->icmp_code = 255; 678 (void) send_icmp(nfd, mtu, ip, gwip); 679 PAUSE(); 680 printf("3.4.4 ICMP type 5 code 255 (all 0's)\r"); 681 } 682 683 if (!ptest || (ptest == 5)) { 684 /* 685 * Type 8-10;13-18, code - 0,127,128,255 686 */ 687 for (i = 0; ict1[i]; i++) { 688 icp->icmp_type = ict1[i]; 689 icp->icmp_code = 0; 690 (void) send_icmp(nfd, mtu, ip, gwip); 691 PAUSE(); 692 printf("3.5.%d ICMP type 5 code 0 (all 0's)\r", 693 i * 4); 694 icp->icmp_code = 127; 695 (void) send_icmp(nfd, mtu, ip, gwip); 696 PAUSE(); 697 printf("3.5.%d ICMP type 5 code 127 (all 0's)\r", 698 i * 4 + 1); 699 icp->icmp_code = 128; 700 (void) send_icmp(nfd, mtu, ip, gwip); 701 PAUSE(); 702 printf("3.5.%d ICMP type 5 code 128 (all 0's)\r", 703 i * 4 + 2); 704 icp->icmp_code = 255; 705 (void) send_icmp(nfd, mtu, ip, gwip); 706 PAUSE(); 707 printf("3.5.%d ICMP type 5 code 255 (all 0's)\r", 708 i * 4 + 3); 709 } 710 putchar('\n'); 711 } 712 713 if (!ptest || (ptest == 6)) { 714 /* 715 * Type 12, code - 0,127,128,129,255 716 */ 717 icp->icmp_type = 12; 718 icp->icmp_code = 0; 719 (void) send_icmp(nfd, mtu, ip, gwip); 720 PAUSE(); 721 printf("3.6.1 ICMP type 12 code 0 (all 0's)\r"); 722 icp->icmp_code = 127; 723 (void) send_icmp(nfd, mtu, ip, gwip); 724 PAUSE(); 725 printf("3.6.2 ICMP type 12 code 127 (all 0's)\r"); 726 icp->icmp_code = 128; 727 (void) send_icmp(nfd, mtu, ip, gwip); 728 PAUSE(); 729 printf("3.6.3 ICMP type 12 code 128 (all 0's)\r"); 730 icp->icmp_code = 129; 731 (void) send_icmp(nfd, mtu, ip, gwip); 732 PAUSE(); 733 printf("3.6.4 ICMP type 12 code 129 (all 0's)\r"); 734 icp->icmp_code = 255; 735 (void) send_icmp(nfd, mtu, ip, gwip); 736 PAUSE(); 737 printf("3.6.5 ICMP type 12 code 255 (all 0's)\r"); 738 putchar('\n'); 739 } 740 741 if (!ptest || (ptest == 7)) { 742 /* 743 * Type 3;9-10;13-14;17-18 - shorter packets 744 */ 745 ip->ip_len = sizeof(*ip) + sizeof(*icp) / 2; 746 for (i = 0; ict2[i]; i++) { 747 icp->icmp_type = ict1[i]; 748 icp->icmp_code = 0; 749 (void) send_icmp(nfd, mtu, ip, gwip); 750 PAUSE(); 751 printf("3.5.%d ICMP type %d code 0 (all 0's)\r", 752 i * 4, icp->icmp_type); 753 icp->icmp_code = 127; 754 (void) send_icmp(nfd, mtu, ip, gwip); 755 PAUSE(); 756 printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 757 i * 4 + 1, icp->icmp_type); 758 icp->icmp_code = 128; 759 (void) send_icmp(nfd, mtu, ip, gwip); 760 PAUSE(); 761 printf("3.5.%d ICMP type %d code 128 (all 0's)\r", 762 i * 4 + 2, icp->icmp_type); 763 icp->icmp_code = 255; 764 (void) send_icmp(nfd, mtu, ip, gwip); 765 PAUSE(); 766 printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 767 i * 4 + 3, icp->icmp_type); 768 } 769 putchar('\n'); 770 } 771} 772 773 774/* Perform test 4 (UDP) */ 775 776void ip_test4(dev, mtu, ip, gwip, ptest) 777 char *dev; 778 int mtu; 779 ip_t *ip; 780 struct in_addr gwip; 781 int ptest; 782{ 783#ifdef USE_NANOSLEEP 784 struct timespec ts; 785#else 786 struct timeval tv; 787#endif 788 udphdr_t *u; 789 int nfd, i; 790 791 792 IP_HL_A(ip, sizeof(*ip) >> 2); 793 IP_V_A(ip, IPVERSION); 794 ip->ip_tos = 0; 795 ip->ip_off = 0; 796 ip->ip_ttl = 60; 797 ip->ip_p = IPPROTO_UDP; 798 ip->ip_sum = 0; 799 u = (udphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 800 u->uh_sport = htons(1); 801 u->uh_dport = htons(1); 802 u->uh_ulen = htons(sizeof(*u) + 4); 803 804 nfd = initdevice(dev, 1); 805 if (nfd == -1) 806 return; 807 808 if (!ptest || (ptest == 1)) { 809 /* 810 * Test 1. ulen > packet 811 */ 812 u->uh_ulen = htons(sizeof(*u) + 4); 813 ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 814 printf("4.1 UDP uh_ulen > packet size - short packets\n"); 815 for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 816 u->uh_ulen = htons(i); 817 (void) send_udp(nfd, 1500, ip, gwip); 818 printf("%d\r", i); 819 fflush(stdout); 820 PAUSE(); 821 } 822 putchar('\n'); 823 } 824 825 if (!ptest || (ptest == 2)) { 826 /* 827 * Test 2. ulen < packet 828 */ 829 u->uh_ulen = htons(sizeof(*u) + 4); 830 ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 831 printf("4.2 UDP uh_ulen < packet size - short packets\n"); 832 for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 833 ip->ip_len = i; 834 (void) send_udp(nfd, 1500, ip, gwip); 835 printf("%d\r", i); 836 fflush(stdout); 837 PAUSE(); 838 } 839 putchar('\n'); 840 } 841 842 if (!ptest || (ptest == 3)) { 843 /* 844 * Test 3: sport = 0, sport = 1, sport = 32767 845 * sport = 32768, sport = 65535 846 */ 847 u->uh_ulen = sizeof(*u) + 4; 848 ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 849 printf("4.3.1 UDP sport = 0\n"); 850 u->uh_sport = 0; 851 (void) send_udp(nfd, 1500, ip, gwip); 852 printf("0\n"); 853 fflush(stdout); 854 PAUSE(); 855 printf("4.3.2 UDP sport = 1\n"); 856 u->uh_sport = htons(1); 857 (void) send_udp(nfd, 1500, ip, gwip); 858 printf("1\n"); 859 fflush(stdout); 860 PAUSE(); 861 printf("4.3.3 UDP sport = 32767\n"); 862 u->uh_sport = htons(32767); 863 (void) send_udp(nfd, 1500, ip, gwip); 864 printf("32767\n"); 865 fflush(stdout); 866 PAUSE(); 867 printf("4.3.4 UDP sport = 32768\n"); 868 u->uh_sport = htons(32768); 869 (void) send_udp(nfd, 1500, ip, gwip); 870 printf("32768\n"); 871 putchar('\n'); 872 fflush(stdout); 873 PAUSE(); 874 printf("4.3.5 UDP sport = 65535\n"); 875 u->uh_sport = htons(65535); 876 (void) send_udp(nfd, 1500, ip, gwip); 877 printf("65535\n"); 878 fflush(stdout); 879 PAUSE(); 880 } 881 882 if (!ptest || (ptest == 4)) { 883 /* 884 * Test 4: dport = 0, dport = 1, dport = 32767 885 * dport = 32768, dport = 65535 886 */ 887 u->uh_ulen = ntohs(sizeof(*u) + 4); 888 u->uh_sport = htons(1); 889 ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 890 printf("4.4.1 UDP dport = 0\n"); 891 u->uh_dport = 0; 892 (void) send_udp(nfd, 1500, ip, gwip); 893 printf("0\n"); 894 fflush(stdout); 895 PAUSE(); 896 printf("4.4.2 UDP dport = 1\n"); 897 u->uh_dport = htons(1); 898 (void) send_udp(nfd, 1500, ip, gwip); 899 printf("1\n"); 900 fflush(stdout); 901 PAUSE(); 902 printf("4.4.3 UDP dport = 32767\n"); 903 u->uh_dport = htons(32767); 904 (void) send_udp(nfd, 1500, ip, gwip); 905 printf("32767\n"); 906 fflush(stdout); 907 PAUSE(); 908 printf("4.4.4 UDP dport = 32768\n"); 909 u->uh_dport = htons(32768); 910 (void) send_udp(nfd, 1500, ip, gwip); 911 printf("32768\n"); 912 fflush(stdout); 913 PAUSE(); 914 printf("4.4.5 UDP dport = 65535\n"); 915 u->uh_dport = htons(65535); 916 (void) send_udp(nfd, 1500, ip, gwip); 917 printf("65535\n"); 918 fflush(stdout); 919 PAUSE(); 920 } 921 922 if (!ptest || (ptest == 5)) { 923 /* 924 * Test 5: sizeof(ip_t) <= MTU <= sizeof(udphdr_t) + 925 * sizeof(ip_t) 926 */ 927 printf("4.5 UDP 20 <= MTU <= 32\n"); 928 for (i = sizeof(*ip); i <= ntohs(u->uh_ulen); i++) { 929 (void) send_udp(nfd, i, ip, gwip); 930 printf("%d\r", i); 931 fflush(stdout); 932 PAUSE(); 933 } 934 putchar('\n'); 935 } 936} 937 938 939/* Perform test 5 (TCP) */ 940 941void ip_test5(dev, mtu, ip, gwip, ptest) 942 char *dev; 943 int mtu; 944 ip_t *ip; 945 struct in_addr gwip; 946 int ptest; 947{ 948#ifdef USE_NANOSLEEP 949 struct timespec ts; 950#else 951 struct timeval tv; 952#endif 953 tcphdr_t *t; 954 int nfd, i; 955 956 t = (tcphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 957#if !defined(linux) && !defined(__osf__) 958 t->th_x2 = 0; 959#endif 960 TCP_OFF_A(t, 0); 961 t->th_sport = htons(1); 962 t->th_dport = htons(1); 963 t->th_win = htons(4096); 964 t->th_urp = 0; 965 t->th_sum = 0; 966 t->th_seq = htonl(1); 967 t->th_ack = 0; 968 ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 969 970 nfd = initdevice(dev, 1); 971 if (nfd == -1) 972 return; 973 974 if (!ptest || (ptest == 1)) { 975 /* 976 * Test 1: flags variations, 0 - 3f 977 */ 978 TCP_OFF_A(t, sizeof(*t) >> 2); 979 printf("5.1 Test TCP flag combinations\n"); 980 for (i = 0; i <= (TH_URG|TH_ACK|TH_PUSH|TH_RST|TH_SYN|TH_FIN); 981 i++) { 982 t->th_flags = i; 983 (void) send_tcp(nfd, mtu, ip, gwip); 984 printf("%d\r", i); 985 fflush(stdout); 986 PAUSE(); 987 } 988 putchar('\n'); 989 } 990 991 if (!ptest || (ptest == 2)) { 992 t->th_flags = TH_SYN; 993 /* 994 * Test 2: seq = 0, seq = 1, seq = 0x7fffffff, seq=0x80000000, 995 * seq = 0xa000000, seq = 0xffffffff 996 */ 997 printf("5.2.1 TCP seq = 0\n"); 998 t->th_seq = htonl(0); 999 (void) send_tcp(nfd, mtu, ip, gwip); 1000 fflush(stdout); 1001 PAUSE(); 1002 1003 printf("5.2.2 TCP seq = 1\n"); 1004 t->th_seq = htonl(1); 1005 (void) send_tcp(nfd, mtu, ip, gwip); 1006 fflush(stdout); 1007 PAUSE(); 1008 1009 printf("5.2.3 TCP seq = 0x7fffffff\n"); 1010 t->th_seq = htonl(0x7fffffff); 1011 (void) send_tcp(nfd, mtu, ip, gwip); 1012 fflush(stdout); 1013 PAUSE(); 1014 1015 printf("5.2.4 TCP seq = 0x80000000\n"); 1016 t->th_seq = htonl(0x80000000); 1017 (void) send_tcp(nfd, mtu, ip, gwip); 1018 fflush(stdout); 1019 PAUSE(); 1020 1021 printf("5.2.5 TCP seq = 0xc0000000\n"); 1022 t->th_seq = htonl(0xc0000000); 1023 (void) send_tcp(nfd, mtu, ip, gwip); 1024 fflush(stdout); 1025 PAUSE(); 1026 1027 printf("5.2.6 TCP seq = 0xffffffff\n"); 1028 t->th_seq = htonl(0xffffffff); 1029 (void) send_tcp(nfd, mtu, ip, gwip); 1030 fflush(stdout); 1031 PAUSE(); 1032 } 1033 1034 if (!ptest || (ptest == 3)) { 1035 t->th_flags = TH_ACK; 1036 /* 1037 * Test 3: ack = 0, ack = 1, ack = 0x7fffffff, ack = 0x8000000 1038 * ack = 0xa000000, ack = 0xffffffff 1039 */ 1040 printf("5.3.1 TCP ack = 0\n"); 1041 t->th_ack = 0; 1042 (void) send_tcp(nfd, mtu, ip, gwip); 1043 fflush(stdout); 1044 PAUSE(); 1045 1046 printf("5.3.2 TCP ack = 1\n"); 1047 t->th_ack = htonl(1); 1048 (void) send_tcp(nfd, mtu, ip, gwip); 1049 fflush(stdout); 1050 PAUSE(); 1051 1052 printf("5.3.3 TCP ack = 0x7fffffff\n"); 1053 t->th_ack = htonl(0x7fffffff); 1054 (void) send_tcp(nfd, mtu, ip, gwip); 1055 fflush(stdout); 1056 PAUSE(); 1057 1058 printf("5.3.4 TCP ack = 0x80000000\n"); 1059 t->th_ack = htonl(0x80000000); 1060 (void) send_tcp(nfd, mtu, ip, gwip); 1061 fflush(stdout); 1062 PAUSE(); 1063 1064 printf("5.3.5 TCP ack = 0xc0000000\n"); 1065 t->th_ack = htonl(0xc0000000); 1066 (void) send_tcp(nfd, mtu, ip, gwip); 1067 fflush(stdout); 1068 PAUSE(); 1069 1070 printf("5.3.6 TCP ack = 0xffffffff\n"); 1071 t->th_ack = htonl(0xffffffff); 1072 (void) send_tcp(nfd, mtu, ip, gwip); 1073 fflush(stdout); 1074 PAUSE(); 1075 } 1076 1077 if (!ptest || (ptest == 4)) { 1078 t->th_flags = TH_SYN; 1079 /* 1080 * Test 4: win = 0, win = 32768, win = 65535 1081 */ 1082 printf("5.4.1 TCP win = 0\n"); 1083 t->th_seq = htonl(0); 1084 (void) send_tcp(nfd, mtu, ip, gwip); 1085 fflush(stdout); 1086 PAUSE(); 1087 1088 printf("5.4.2 TCP win = 32768\n"); 1089 t->th_seq = htonl(0x7fff); 1090 (void) send_tcp(nfd, mtu, ip, gwip); 1091 fflush(stdout); 1092 PAUSE(); 1093 1094 printf("5.4.3 TCP win = 65535\n"); 1095 t->th_win = htons(0xffff); 1096 (void) send_tcp(nfd, mtu, ip, gwip); 1097 fflush(stdout); 1098 PAUSE(); 1099 } 1100 1101#if !defined(linux) && !defined(__SVR4) && !defined(__svr4__) && \ 1102 !defined(__sgi) && !defined(__hpux) && !defined(__osf__) 1103 { 1104 struct tcpcb *tcbp, tcb; 1105 struct tcpiphdr ti; 1106 struct sockaddr_in sin; 1107 int fd; 1108 socklen_t slen; 1109 1110 bzero((char *)&sin, sizeof(sin)); 1111 1112 for (i = 1; i < 63; i++) { 1113 fd = socket(AF_INET, SOCK_STREAM, 0); 1114 bzero((char *)&sin, sizeof(sin)); 1115 sin.sin_addr.s_addr = ip->ip_dst.s_addr; 1116 sin.sin_port = htons(i); 1117 sin.sin_family = AF_INET; 1118 if (!connect(fd, (struct sockaddr *)&sin, sizeof(sin))) 1119 break; 1120 close(fd); 1121 } 1122 1123 if (i == 63) { 1124 printf("Couldn't open a TCP socket between ports 1 and 63\n"); 1125 printf("to host %s for test 5 and 6 - skipping.\n", 1126 inet_ntoa(ip->ip_dst)); 1127 goto skip_five_and_six; 1128 } 1129 1130 bcopy((char *)ip, (char *)&ti, sizeof(*ip)); 1131 t->th_dport = htons(i); 1132 slen = sizeof(sin); 1133 if (!getsockname(fd, (struct sockaddr *)&sin, &slen)) 1134 t->th_sport = sin.sin_port; 1135 if (!(tcbp = find_tcp(fd, &ti))) { 1136 printf("Can't find PCB\n"); 1137 goto skip_five_and_six; 1138 } 1139 KMCPY(&tcb, tcbp, sizeof(tcb)); 1140 ti.ti_win = tcb.rcv_adv; 1141 ti.ti_seq = htonl(tcb.snd_nxt - 1); 1142 ti.ti_ack = tcb.rcv_nxt; 1143 1144 if (!ptest || (ptest == 5)) { 1145 /* 1146 * Test 5: urp 1147 */ 1148 t->th_flags = TH_ACK|TH_URG; 1149 printf("5.5.1 TCP Urgent pointer, sport %hu dport %hu\n", 1150 ntohs(t->th_sport), ntohs(t->th_dport)); 1151 t->th_urp = htons(1); 1152 (void) send_tcp(nfd, mtu, ip, gwip); 1153 PAUSE(); 1154 1155 t->th_seq = htonl(tcb.snd_nxt); 1156 ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t) + 1; 1157 t->th_urp = htons(0x7fff); 1158 (void) send_tcp(nfd, mtu, ip, gwip); 1159 PAUSE(); 1160 t->th_urp = htons(0x8000); 1161 (void) send_tcp(nfd, mtu, ip, gwip); 1162 PAUSE(); 1163 t->th_urp = htons(0xffff); 1164 (void) send_tcp(nfd, mtu, ip, gwip); 1165 PAUSE(); 1166 t->th_urp = 0; 1167 t->th_flags &= ~TH_URG; 1168 ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 1169 } 1170 1171 if (!ptest || (ptest == 6)) { 1172 /* 1173 * Test 6: data offset, off = 0, off is inside, off is outside 1174 */ 1175 t->th_flags = TH_ACK; 1176 printf("5.6.1 TCP off = 1-15, len = 40\n"); 1177 for (i = 1; i < 16; i++) { 1178 TCP_OFF_A(t, ntohs(i)); 1179 (void) send_tcp(nfd, mtu, ip, gwip); 1180 printf("%d\r", i); 1181 fflush(stdout); 1182 PAUSE(); 1183 } 1184 putchar('\n'); 1185 ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 1186 } 1187 1188 (void) close(fd); 1189 } 1190skip_five_and_six: 1191#endif 1192 t->th_seq = htonl(1); 1193 t->th_ack = htonl(1); 1194 TCP_OFF_A(t, 0); 1195 1196 if (!ptest || (ptest == 7)) { 1197 t->th_flags = TH_SYN; 1198 /* 1199 * Test 7: sport = 0, sport = 1, sport = 32767 1200 * sport = 32768, sport = 65535 1201 */ 1202 printf("5.7.1 TCP sport = 0\n"); 1203 t->th_sport = 0; 1204 (void) send_tcp(nfd, mtu, ip, gwip); 1205 fflush(stdout); 1206 PAUSE(); 1207 1208 printf("5.7.2 TCP sport = 1\n"); 1209 t->th_sport = htons(1); 1210 (void) send_tcp(nfd, mtu, ip, gwip); 1211 fflush(stdout); 1212 PAUSE(); 1213 1214 printf("5.7.3 TCP sport = 32767\n"); 1215 t->th_sport = htons(32767); 1216 (void) send_tcp(nfd, mtu, ip, gwip); 1217 fflush(stdout); 1218 PAUSE(); 1219 1220 printf("5.7.4 TCP sport = 32768\n"); 1221 t->th_sport = htons(32768); 1222 (void) send_tcp(nfd, mtu, ip, gwip); 1223 fflush(stdout); 1224 PAUSE(); 1225 1226 printf("5.7.5 TCP sport = 65535\n"); 1227 t->th_sport = htons(65535); 1228 (void) send_tcp(nfd, mtu, ip, gwip); 1229 fflush(stdout); 1230 PAUSE(); 1231 } 1232 1233 if (!ptest || (ptest == 8)) { 1234 t->th_sport = htons(1); 1235 t->th_flags = TH_SYN; 1236 /* 1237 * Test 8: dport = 0, dport = 1, dport = 32767 1238 * dport = 32768, dport = 65535 1239 */ 1240 printf("5.8.1 TCP dport = 0\n"); 1241 t->th_dport = 0; 1242 (void) send_tcp(nfd, mtu, ip, gwip); 1243 fflush(stdout); 1244 PAUSE(); 1245 1246 printf("5.8.2 TCP dport = 1\n"); 1247 t->th_dport = htons(1); 1248 (void) send_tcp(nfd, mtu, ip, gwip); 1249 fflush(stdout); 1250 PAUSE(); 1251 1252 printf("5.8.3 TCP dport = 32767\n"); 1253 t->th_dport = htons(32767); 1254 (void) send_tcp(nfd, mtu, ip, gwip); 1255 fflush(stdout); 1256 PAUSE(); 1257 1258 printf("5.8.4 TCP dport = 32768\n"); 1259 t->th_dport = htons(32768); 1260 (void) send_tcp(nfd, mtu, ip, gwip); 1261 fflush(stdout); 1262 PAUSE(); 1263 1264 printf("5.8.5 TCP dport = 65535\n"); 1265 t->th_dport = htons(65535); 1266 (void) send_tcp(nfd, mtu, ip, gwip); 1267 fflush(stdout); 1268 PAUSE(); 1269 } 1270 1271 /* LAND attack - self connect, so make src & dst ip/port the same */ 1272 if (!ptest || (ptest == 9)) { 1273 printf("5.9 TCP LAND attack. sport = 25, dport = 25\n"); 1274 /* chose SMTP port 25 */ 1275 t->th_sport = htons(25); 1276 t->th_dport = htons(25); 1277 t->th_flags = TH_SYN; 1278 ip->ip_src = ip->ip_dst; 1279 (void) send_tcp(nfd, mtu, ip, gwip); 1280 fflush(stdout); 1281 PAUSE(); 1282 } 1283 1284 /* TCP options header checking */ 1285 /* 0 length options, etc */ 1286} 1287 1288 1289/* Perform test 6 (exhaust mbuf test) */ 1290 1291void ip_test6(dev, mtu, ip, gwip, ptest) 1292 char *dev; 1293 int mtu; 1294 ip_t *ip; 1295 struct in_addr gwip; 1296 int ptest; 1297{ 1298#ifdef USE_NANOSLEEP 1299 struct timespec ts; 1300#else 1301 struct timeval tv; 1302#endif 1303 udphdr_t *u; 1304 int nfd, i, j, k; 1305 1306 IP_V_A(ip, IPVERSION); 1307 ip->ip_tos = 0; 1308 ip->ip_off = 0; 1309 ip->ip_ttl = 60; 1310 ip->ip_p = IPPROTO_UDP; 1311 ip->ip_sum = 0; 1312 u = (udphdr_t *)(ip + 1); 1313 u->uh_sport = htons(1); 1314 u->uh_dport = htons(9); 1315 u->uh_sum = 0; 1316 1317 nfd = initdevice(dev, 1); 1318 if (nfd == -1) 1319 return; 1320 1321 u->uh_ulen = htons(7168); 1322 1323 printf("6. Exhaustive mbuf test.\n"); 1324 printf(" Send 7k packet in 768 & 128 byte fragments, 128 times.\n"); 1325 printf(" Total of around 8,900 packets\n"); 1326 for (i = 0; i < 128; i++) { 1327 /* 1328 * First send the entire packet in 768 byte chunks. 1329 */ 1330 ip->ip_len = sizeof(*ip) + 768 + sizeof(*u); 1331 IP_HL_A(ip, sizeof(*ip) >> 2); 1332 ip->ip_off = htons(IP_MF); 1333 (void) send_ip(nfd, 1500, ip, gwip, 1); 1334 printf("%d %d\r", i, 0); 1335 fflush(stdout); 1336 PAUSE(); 1337 /* 1338 * And again using 128 byte chunks. 1339 */ 1340 ip->ip_len = sizeof(*ip) + 128 + sizeof(*u); 1341 ip->ip_off = htons(IP_MF); 1342 (void) send_ip(nfd, 1500, ip, gwip, 1); 1343 printf("%d %d\r", i, 0); 1344 fflush(stdout); 1345 PAUSE(); 1346 1347 for (j = 768; j < 3584; j += 768) { 1348 ip->ip_len = sizeof(*ip) + 768; 1349 ip->ip_off = htons(IP_MF|(j>>3)); 1350 (void) send_ip(nfd, 1500, ip, gwip, 1); 1351 printf("%d %d\r", i, j); 1352 fflush(stdout); 1353 PAUSE(); 1354 1355 ip->ip_len = sizeof(*ip) + 128; 1356 for (k = j - 768; k < j; k += 128) { 1357 ip->ip_off = htons(IP_MF|(k>>3)); 1358 (void) send_ip(nfd, 1500, ip, gwip, 1); 1359 printf("%d %d\r", i, k); 1360 fflush(stdout); 1361 PAUSE(); 1362 } 1363 } 1364 } 1365 putchar('\n'); 1366} 1367 1368 1369/* Perform test 7 (random packets) */ 1370 1371static u_long tbuf[64]; 1372 1373void ip_test7(dev, mtu, ip, gwip, ptest) 1374 char *dev; 1375 int mtu; 1376 ip_t *ip; 1377 struct in_addr gwip; 1378 int ptest; 1379{ 1380 ip_t *pip; 1381#ifdef USE_NANOSLEEP 1382 struct timespec ts; 1383#else 1384 struct timeval tv; 1385#endif 1386 int nfd, i, j; 1387 u_char *s; 1388 1389 nfd = initdevice(dev, 1); 1390 if (nfd == -1) 1391 return; 1392 1393 pip = (ip_t *)tbuf; 1394 1395 srand(time(NULL) ^ (getpid() * getppid())); 1396 1397 printf("7. send 1024 random IP packets.\n"); 1398 1399 for (i = 0; i < 512; i++) { 1400 for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 1401 *s = (rand() >> 13) & 0xff; 1402 IP_V_A(pip, IPVERSION); 1403 bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 1404 sizeof(struct in_addr)); 1405 pip->ip_sum = 0; 1406 pip->ip_len &= 0xff; 1407 (void) send_ip(nfd, mtu, pip, gwip, 0); 1408 printf("%d\r", i); 1409 fflush(stdout); 1410 PAUSE(); 1411 } 1412 putchar('\n'); 1413 1414 for (i = 0; i < 512; i++) { 1415 for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 1416 *s = (rand() >> 13) & 0xff; 1417 IP_V_A(pip, IPVERSION); 1418 pip->ip_off &= htons(0xc000); 1419 bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 1420 sizeof(struct in_addr)); 1421 pip->ip_sum = 0; 1422 pip->ip_len &= 0xff; 1423 (void) send_ip(nfd, mtu, pip, gwip, 0); 1424 printf("%d\r", i); 1425 fflush(stdout); 1426 PAUSE(); 1427 } 1428 putchar('\n'); 1429} 1430