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