iptests.c revision 161357
1145519Sdarrenr/* $FreeBSD: head/contrib/ipfilter/ipsend/iptests.c 161357 2006-08-16 12:23:02Z guido $ */ 2145519Sdarrenr 322514Sdarrenr/* 453024Sguido * Copyright (C) 1993-1998 by Darren Reed. 522514Sdarrenr * 680490Sdarrenr * See the IPFILTER.LICENCE file for details on licencing. 7145519Sdarrenr * 822514Sdarrenr */ 9145519Sdarrenr#if !defined(lint) 10145519Sdarrenrstatic const char sccsid[] = "%W% %G% (C)1995 Darren Reed"; 11161357Sguidostatic const char rcsid[] = "@(#)$Id: iptests.c,v 2.8.2.7 2006/03/21 16:10:55 darrenr Exp $"; 1292691Sdarrenr#endif 13145519Sdarrenr#include <sys/param.h> 1422514Sdarrenr#include <sys/types.h> 15161357Sguido#if defined(__NetBSD__) && defined(__vax__) 16161357Sguido/* 17161357Sguido * XXX need to declare boolean_t for _KERNEL <sys/files.h> 18161357Sguido * which ends up including <sys/device.h> for vax. See PR#32907 19161357Sguido * for further details. 20161357Sguido */ 21161357Sguidotypedef int boolean_t; 22161357Sguido#endif 2322514Sdarrenr#include <sys/time.h> 24145519Sdarrenr#if !defined(__osf__) 25145519Sdarrenr# define _KERNEL 26145519Sdarrenr# define KERNEL 27145519Sdarrenr# if !defined(solaris) && !defined(linux) && !defined(__sgi) && !defined(hpux) 28145519Sdarrenr# include <sys/file.h> 29145519Sdarrenr# else 30145519Sdarrenr# ifdef solaris 31145519Sdarrenr# include <sys/dditypes.h> 32145519Sdarrenr# endif 3353024Sguido# endif 34145519Sdarrenr# undef _KERNEL 35145519Sdarrenr# undef KERNEL 3653024Sguido#endif 3753024Sguido#if !defined(solaris) && !defined(linux) && !defined(__sgi) 3822514Sdarrenr# include <nlist.h> 3922514Sdarrenr# include <sys/user.h> 4022514Sdarrenr# include <sys/proc.h> 4122514Sdarrenr#endif 42145519Sdarrenr#if !defined(ultrix) && !defined(hpux) && !defined(linux) && \ 43153881Sguido !defined(__sgi) && !defined(__osf__) && !defined(_AIX51) 4431183Speter# include <kvm.h> 4531183Speter#endif 4631183Speter#ifndef ultrix 4731183Speter# include <sys/socket.h> 4831183Speter#endif 4926119Sdarrenr#if defined(solaris) 5026119Sdarrenr# include <sys/stream.h> 5126119Sdarrenr#endif 5222514Sdarrenr#include <sys/socketvar.h> 5322514Sdarrenr#ifdef sun 5422514Sdarrenr#include <sys/systm.h> 5522514Sdarrenr#include <sys/session.h> 5622514Sdarrenr#endif 5722514Sdarrenr#if BSD >= 199103 5831183Speter# include <sys/sysctl.h> 5931183Speter# include <sys/filedesc.h> 6031183Speter# include <paths.h> 6122514Sdarrenr#endif 6222514Sdarrenr#include <netinet/in_systm.h> 6322514Sdarrenr#include <sys/socket.h> 64145519Sdarrenr#ifdef __hpux 65145519Sdarrenr# define _NET_ROUTE_INCLUDED 66145519Sdarrenr#endif 6722514Sdarrenr#include <net/if.h> 6831183Speter#if defined(linux) && (LINUX >= 0200) 6931183Speter# include <asm/atomic.h> 7031183Speter#endif 7131183Speter#if !defined(linux) 72145519Sdarrenr# if defined(__FreeBSD__) 73145519Sdarrenr# include "radix_ipf.h" 74145519Sdarrenr# endif 7531183Speter# include <net/route.h> 7631183Speter#else 7731183Speter# define __KERNEL__ /* because there's a macro not wrapped by this */ 7831183Speter# include <net/route.h> /* in this file :-/ */ 7931183Speter#endif 8022514Sdarrenr#include <netinet/in.h> 8122514Sdarrenr#include <arpa/inet.h> 8222514Sdarrenr#include <netinet/ip.h> 83145519Sdarrenr#if !defined(linux) 8431183Speter# include <netinet/ip_var.h> 85145519Sdarrenr# if !defined(__hpux) 86145519Sdarrenr# include <netinet/in_pcb.h> 87145519Sdarrenr# endif 8831183Speter#endif 8931183Speter#if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 9031183Speter# include <sys/sysmacros.h> 9131183Speter#endif 92145519Sdarrenr#include <stdio.h> 93145519Sdarrenr#include <unistd.h> 94145519Sdarrenr#include <stdlib.h> 95145519Sdarrenr#include <string.h> 96145519Sdarrenr#ifdef __hpux 97145519Sdarrenr# undef _NET_ROUTE_INCLUDED 98110920Sdarrenr#endif 9924583Sdarrenr#include "ipsend.h" 100145519Sdarrenr#if !defined(linux) && !defined(__hpux) 101145519Sdarrenr# include <netinet/tcp_timer.h> 102145519Sdarrenr# include <netinet/tcp_var.h> 10380490Sdarrenr#endif 104145519Sdarrenr#if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 106000000) 105145519Sdarrenr# define USE_NANOSLEEP 10684843Sbde#endif 10724583Sdarrenr 10880490Sdarrenr 109145519Sdarrenr#ifdef USE_NANOSLEEP 110145519Sdarrenr# define PAUSE() ts.tv_sec = 0; ts.tv_nsec = 10000000; \ 111110920Sdarrenr (void) nanosleep(&ts, NULL) 112110920Sdarrenr#else 113110920Sdarrenr# define PAUSE() tv.tv_sec = 0; tv.tv_usec = 10000; \ 114145519Sdarrenr (void) select(0, NULL, NULL, NULL, &tv) 115110920Sdarrenr#endif 11622514Sdarrenr 11722514Sdarrenr 11822514Sdarrenrvoid ip_test1(dev, mtu, ip, gwip, ptest) 11922514Sdarrenrchar *dev; 12022514Sdarrenrint mtu; 12122514Sdarrenrip_t *ip; 12222514Sdarrenrstruct in_addr gwip; 12322514Sdarrenrint ptest; 12422514Sdarrenr{ 125145519Sdarrenr#ifdef USE_NANOSLEEP 126110920Sdarrenr struct timespec ts; 127110920Sdarrenr#else 12822514Sdarrenr struct timeval tv; 129110920Sdarrenr#endif 13022514Sdarrenr udphdr_t *u; 13131183Speter int nfd, i = 0, len, id = getpid(); 13222514Sdarrenr 133145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 134145519Sdarrenr IP_V_A(ip, IPVERSION); 13522514Sdarrenr ip->ip_tos = 0; 13622514Sdarrenr ip->ip_off = 0; 13722514Sdarrenr ip->ip_ttl = 60; 13822514Sdarrenr ip->ip_p = IPPROTO_UDP; 13922514Sdarrenr ip->ip_sum = 0; 14022514Sdarrenr u = (udphdr_t *)(ip + 1); 14137074Speter u->uh_sport = htons(1); 14237074Speter u->uh_dport = htons(9); 14322514Sdarrenr u->uh_sum = 0; 14437074Speter u->uh_ulen = htons(sizeof(*u) + 4); 14537074Speter ip->ip_len = sizeof(*ip) + ntohs(u->uh_ulen); 14622514Sdarrenr len = ip->ip_len; 147161357Sguido 148145519Sdarrenr nfd = initdevice(dev, 1); 149161357Sguido if (nfd == -1) 150161357Sguido return; 15122514Sdarrenr 15222514Sdarrenr if (!ptest || (ptest == 1)) { 15322514Sdarrenr /* 15422514Sdarrenr * Part1: hl < len 15522514Sdarrenr */ 15622514Sdarrenr ip->ip_id = 0; 15722514Sdarrenr printf("1.1. sending packets with ip_hl < ip_len\n"); 15837074Speter for (i = 0; i < ((sizeof(*ip) + ntohs(u->uh_ulen)) >> 2); i++) { 159145519Sdarrenr IP_HL_A(ip, i >> 2); 16022514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 16122514Sdarrenr printf("%d\r", i); 16222514Sdarrenr fflush(stdout); 16322514Sdarrenr PAUSE(); 16422514Sdarrenr } 16522514Sdarrenr putchar('\n'); 16622514Sdarrenr } 16722514Sdarrenr 16822514Sdarrenr if (!ptest || (ptest == 2)) { 16922514Sdarrenr /* 17022514Sdarrenr * Part2: hl > len 17122514Sdarrenr */ 17222514Sdarrenr ip->ip_id = 0; 17322514Sdarrenr printf("1.2. sending packets with ip_hl > ip_len\n"); 17437074Speter for (; i < ((sizeof(*ip) * 2 + ntohs(u->uh_ulen)) >> 2); i++) { 175145519Sdarrenr IP_HL_A(ip, i >> 2); 17622514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 17722514Sdarrenr printf("%d\r", i); 17822514Sdarrenr fflush(stdout); 17922514Sdarrenr PAUSE(); 18022514Sdarrenr } 18122514Sdarrenr putchar('\n'); 18222514Sdarrenr } 18322514Sdarrenr 18422514Sdarrenr if (!ptest || (ptest == 3)) { 18522514Sdarrenr /* 18622514Sdarrenr * Part3: v < 4 18722514Sdarrenr */ 18822514Sdarrenr ip->ip_id = 0; 18922514Sdarrenr printf("1.3. ip_v < 4\n"); 190145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 19122514Sdarrenr for (i = 0; i < 4; i++) { 192145519Sdarrenr IP_V_A(ip, i); 19322514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 19422514Sdarrenr printf("%d\r", i); 19522514Sdarrenr fflush(stdout); 19622514Sdarrenr PAUSE(); 19722514Sdarrenr } 19822514Sdarrenr putchar('\n'); 19922514Sdarrenr } 20022514Sdarrenr 20122514Sdarrenr if (!ptest || (ptest == 4)) { 20222514Sdarrenr /* 20322514Sdarrenr * Part4: v > 4 20422514Sdarrenr */ 20522514Sdarrenr ip->ip_id = 0; 20622514Sdarrenr printf("1.4. ip_v > 4\n"); 20722514Sdarrenr for (i = 5; i < 16; i++) { 208145519Sdarrenr IP_V_A(ip, i); 20922514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 21022514Sdarrenr printf("%d\r", i); 21122514Sdarrenr fflush(stdout); 21222514Sdarrenr PAUSE(); 21322514Sdarrenr } 21422514Sdarrenr putchar('\n'); 21522514Sdarrenr } 21622514Sdarrenr 21722514Sdarrenr if (!ptest || (ptest == 5)) { 21822514Sdarrenr /* 21922514Sdarrenr * Part5: len < packet 22022514Sdarrenr */ 22122514Sdarrenr ip->ip_id = 0; 222145519Sdarrenr IP_V_A(ip, IPVERSION); 22322514Sdarrenr i = ip->ip_len + 1; 22422514Sdarrenr printf("1.5.0 ip_len < packet size (size++, long packets)\n"); 22537074Speter for (; i < (ip->ip_len * 2); i++) { 22622514Sdarrenr ip->ip_id = htons(id++); 22722514Sdarrenr ip->ip_sum = 0; 228145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 22924583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 23022514Sdarrenr printf("%d\r", i); 23122514Sdarrenr fflush(stdout); 23222514Sdarrenr PAUSE(); 23322514Sdarrenr } 23422514Sdarrenr putchar('\n'); 23522514Sdarrenr printf("1.5.1 ip_len < packet size (ip_len-, short packets)\n"); 23622514Sdarrenr for (i = len; i > 0; i--) { 23722514Sdarrenr ip->ip_id = htons(id++); 23837074Speter ip->ip_len = i; 23922514Sdarrenr ip->ip_sum = 0; 240145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 24124583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 24222514Sdarrenr printf("%d\r", i); 24322514Sdarrenr fflush(stdout); 24422514Sdarrenr PAUSE(); 24522514Sdarrenr } 24622514Sdarrenr putchar('\n'); 24722514Sdarrenr } 24822514Sdarrenr 24922514Sdarrenr if (!ptest || (ptest == 6)) { 25022514Sdarrenr /* 25122514Sdarrenr * Part6: len > packet 25222514Sdarrenr */ 25322514Sdarrenr ip->ip_id = 0; 25422514Sdarrenr printf("1.6.0 ip_len > packet size (increase ip_len)\n"); 25522514Sdarrenr for (i = len + 1; i < (len * 2); i++) { 25622514Sdarrenr ip->ip_id = htons(id++); 25737074Speter ip->ip_len = i; 25822514Sdarrenr ip->ip_sum = 0; 259145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 26024583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 26122514Sdarrenr printf("%d\r", i); 26222514Sdarrenr fflush(stdout); 26322514Sdarrenr PAUSE(); 26422514Sdarrenr } 26522514Sdarrenr putchar('\n'); 26637074Speter ip->ip_len = len; 26722514Sdarrenr printf("1.6.1 ip_len > packet size (size--, short packets)\n"); 26822514Sdarrenr for (i = len; i > 0; i--) { 26922514Sdarrenr ip->ip_id = htons(id++); 27022514Sdarrenr ip->ip_sum = 0; 271145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 27224583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 27322514Sdarrenr printf("%d\r", i); 27422514Sdarrenr fflush(stdout); 27522514Sdarrenr PAUSE(); 27622514Sdarrenr } 27722514Sdarrenr putchar('\n'); 27822514Sdarrenr } 27922514Sdarrenr 28022514Sdarrenr if (!ptest || (ptest == 7)) { 28122514Sdarrenr /* 28222514Sdarrenr * Part7: 0 length fragment 28322514Sdarrenr */ 28422514Sdarrenr printf("1.7.0 Zero length fragments (ip_off = 0x2000)\n"); 28522514Sdarrenr ip->ip_id = 0; 28622514Sdarrenr ip->ip_len = sizeof(*ip); 28722514Sdarrenr ip->ip_off = htons(IP_MF); 28822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 28922514Sdarrenr fflush(stdout); 29022514Sdarrenr PAUSE(); 29122514Sdarrenr 29222514Sdarrenr printf("1.7.1 Zero length fragments (ip_off = 0x3000)\n"); 29322514Sdarrenr ip->ip_id = 0; 29422514Sdarrenr ip->ip_len = sizeof(*ip); 29522514Sdarrenr ip->ip_off = htons(IP_MF); 29622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 29722514Sdarrenr fflush(stdout); 29822514Sdarrenr PAUSE(); 29922514Sdarrenr 30022514Sdarrenr printf("1.7.2 Zero length fragments (ip_off = 0xa000)\n"); 30122514Sdarrenr ip->ip_id = 0; 30222514Sdarrenr ip->ip_len = sizeof(*ip); 30322514Sdarrenr ip->ip_off = htons(0xa000); 30422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 30522514Sdarrenr fflush(stdout); 30622514Sdarrenr PAUSE(); 30722514Sdarrenr 30822514Sdarrenr printf("1.7.3 Zero length fragments (ip_off = 0x0100)\n"); 30922514Sdarrenr ip->ip_id = 0; 31022514Sdarrenr ip->ip_len = sizeof(*ip); 31122514Sdarrenr ip->ip_off = htons(0x0100); 31222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 31322514Sdarrenr fflush(stdout); 31422514Sdarrenr PAUSE(); 31522514Sdarrenr } 31622514Sdarrenr 31722514Sdarrenr if (!ptest || (ptest == 8)) { 31822514Sdarrenr struct timeval tv; 31922514Sdarrenr 32022514Sdarrenr gettimeofday(&tv, NULL); 32122514Sdarrenr srand(tv.tv_sec ^ getpid() ^ tv.tv_usec); 32222514Sdarrenr /* 32322514Sdarrenr * Part8.1: 63k packet + 1k fragment at offset 0x1ffe 32422514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 32522514Sdarrenr * don't bother about the ICMP header, we're not worrying 32622514Sdarrenr * about that here. 32722514Sdarrenr */ 32822514Sdarrenr ip->ip_p = IPPROTO_ICMP; 32937074Speter ip->ip_off = htons(IP_MF); 33022514Sdarrenr u->uh_dport = htons(9); 33122514Sdarrenr ip->ip_id = htons(id++); 33222514Sdarrenr printf("1.8.1 63k packet + 1k fragment at offset 0x1ffe\n"); 33322514Sdarrenr ip->ip_len = 768 + 20 + 8; 33422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 33522514Sdarrenr printf("%d\r", i); 33622514Sdarrenr 33722514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 33822514Sdarrenr i = 512; 33922514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 340145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 34122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 34222514Sdarrenr printf("%d\r", i); 34322514Sdarrenr fflush(stdout); 34422514Sdarrenr PAUSE(); 34522514Sdarrenr } 34622514Sdarrenr ip->ip_len = 896 + 20; 347145519Sdarrenr ip->ip_off = htons(i >> 3); 34822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 34922514Sdarrenr printf("%d\r", i); 35022514Sdarrenr putchar('\n'); 35122514Sdarrenr fflush(stdout); 35222514Sdarrenr 35322514Sdarrenr /* 35422514Sdarrenr * Part8.2: 63k packet + 1k fragment at offset 0x1ffe 35522514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 35622514Sdarrenr * don't bother about the ICMP header, we're not worrying 35722514Sdarrenr * about that here. (Lossage here) 35822514Sdarrenr */ 35922514Sdarrenr ip->ip_p = IPPROTO_ICMP; 36037074Speter ip->ip_off = htons(IP_MF); 36122514Sdarrenr u->uh_dport = htons(9); 36222514Sdarrenr ip->ip_id = htons(id++); 36322514Sdarrenr printf("1.8.2 63k packet + 1k fragment at offset 0x1ffe\n"); 36422514Sdarrenr ip->ip_len = 768 + 20 + 8; 36522514Sdarrenr if ((rand() & 0x1f) != 0) { 36622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 36722514Sdarrenr printf("%d\r", i); 36822514Sdarrenr } else 36922514Sdarrenr printf("skip 0\n"); 37022514Sdarrenr 37122514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 37222514Sdarrenr i = 512; 37322514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 374145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 37522514Sdarrenr if ((rand() & 0x1f) != 0) { 37622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 37722514Sdarrenr printf("%d\r", i); 37822514Sdarrenr } else 37922514Sdarrenr printf("skip %d\n", i); 38022514Sdarrenr fflush(stdout); 38122514Sdarrenr PAUSE(); 38222514Sdarrenr } 38322514Sdarrenr ip->ip_len = 896 + 20; 384145519Sdarrenr ip->ip_off = htons(i >> 3); 38522514Sdarrenr if ((rand() & 0x1f) != 0) { 38622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 38722514Sdarrenr printf("%d\r", i); 38822514Sdarrenr } else 38922514Sdarrenr printf("skip\n"); 39022514Sdarrenr putchar('\n'); 39122514Sdarrenr fflush(stdout); 39222514Sdarrenr 39322514Sdarrenr /* 39422514Sdarrenr * Part8.3: 33k packet - test for not dealing with -ve length 39522514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 39622514Sdarrenr * don't bother about the ICMP header, we're not worrying 39722514Sdarrenr * about that here. 39822514Sdarrenr */ 39922514Sdarrenr ip->ip_p = IPPROTO_ICMP; 40037074Speter ip->ip_off = htons(IP_MF); 40122514Sdarrenr u->uh_dport = htons(9); 40222514Sdarrenr ip->ip_id = htons(id++); 40322514Sdarrenr printf("1.8.3 33k packet\n"); 40422514Sdarrenr ip->ip_len = 768 + 20 + 8; 40522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 40622514Sdarrenr printf("%d\r", i); 40722514Sdarrenr 40822514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 40922514Sdarrenr i = 512; 41022514Sdarrenr for (; i < (32 * 1024 + 768); i += 768) { 411145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 41222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 41322514Sdarrenr printf("%d\r", i); 41422514Sdarrenr fflush(stdout); 41522514Sdarrenr PAUSE(); 41622514Sdarrenr } 41722514Sdarrenr ip->ip_len = 896 + 20; 418145519Sdarrenr ip->ip_off = htons(i >> 3); 41922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 42022514Sdarrenr printf("%d\r", i); 42122514Sdarrenr putchar('\n'); 42222514Sdarrenr fflush(stdout); 42322514Sdarrenr } 42422514Sdarrenr 42522514Sdarrenr ip->ip_len = len; 42622514Sdarrenr ip->ip_off = 0; 42722514Sdarrenr if (!ptest || (ptest == 9)) { 42822514Sdarrenr /* 42922514Sdarrenr * Part9: off & 0x8000 == 0x8000 43022514Sdarrenr */ 43122514Sdarrenr ip->ip_id = 0; 43237074Speter ip->ip_off = htons(0x8000); 43322514Sdarrenr printf("1.9. ip_off & 0x8000 == 0x8000\n"); 43422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 43522514Sdarrenr fflush(stdout); 43622514Sdarrenr PAUSE(); 43722514Sdarrenr } 43822514Sdarrenr 43922514Sdarrenr ip->ip_off = 0; 44022514Sdarrenr 44122514Sdarrenr if (!ptest || (ptest == 10)) { 44222514Sdarrenr /* 44322514Sdarrenr * Part10: ttl = 255 44422514Sdarrenr */ 44522514Sdarrenr ip->ip_id = 0; 44622514Sdarrenr ip->ip_ttl = 255; 44722514Sdarrenr printf("1.10.0 ip_ttl = 255\n"); 44822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 44922514Sdarrenr fflush(stdout); 45022514Sdarrenr PAUSE(); 45122514Sdarrenr 45222514Sdarrenr ip->ip_ttl = 128; 45322514Sdarrenr printf("1.10.1 ip_ttl = 128\n"); 45422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 45522514Sdarrenr fflush(stdout); 45622514Sdarrenr PAUSE(); 45722514Sdarrenr 45822514Sdarrenr ip->ip_ttl = 0; 45922514Sdarrenr printf("1.10.2 ip_ttl = 0\n"); 46022514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 46122514Sdarrenr fflush(stdout); 46222514Sdarrenr PAUSE(); 46322514Sdarrenr } 46422514Sdarrenr 46522514Sdarrenr (void) close(nfd); 46622514Sdarrenr} 46722514Sdarrenr 46822514Sdarrenr 46922514Sdarrenrvoid ip_test2(dev, mtu, ip, gwip, ptest) 47022514Sdarrenrchar *dev; 47122514Sdarrenrint mtu; 47222514Sdarrenrip_t *ip; 47322514Sdarrenrstruct in_addr gwip; 47422514Sdarrenrint ptest; 47522514Sdarrenr{ 476145519Sdarrenr#ifdef USE_NANOSLEEP 477110920Sdarrenr struct timespec ts; 478110920Sdarrenr#else 47922514Sdarrenr struct timeval tv; 480110920Sdarrenr#endif 48122514Sdarrenr int nfd; 48222514Sdarrenr u_char *s; 48322514Sdarrenr 484161357Sguido 485145519Sdarrenr nfd = initdevice(dev, 1); 486161357Sguido if (nfd == -1) 487161357Sguido return; 48822514Sdarrenr 489145519Sdarrenr IP_HL_A(ip, 6); 490145519Sdarrenr ip->ip_len = IP_HL(ip) << 2; 491161357Sguido s = (u_char *)(ip + 1); 49222514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_NOP; 49322514Sdarrenr s++; 49422514Sdarrenr if (!ptest || (ptest == 1)) { 49522514Sdarrenr /* 49622514Sdarrenr * Test 1: option length > packet length, 49722514Sdarrenr * header length == packet length 49822514Sdarrenr */ 49922514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 50022514Sdarrenr s[IPOPT_OLEN] = 4; 50122514Sdarrenr s[IPOPT_OFFSET] = IPOPT_MINOFF; 50222514Sdarrenr ip->ip_p = IPPROTO_IP; 50322514Sdarrenr printf("2.1 option length > packet length\n"); 50422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 50522514Sdarrenr fflush(stdout); 50622514Sdarrenr PAUSE(); 50722514Sdarrenr } 50822514Sdarrenr 509145519Sdarrenr IP_HL_A(ip, 7); 510145519Sdarrenr ip->ip_len = IP_HL(ip) << 2; 51122514Sdarrenr if (!ptest || (ptest == 1)) { 51222514Sdarrenr /* 51322514Sdarrenr * Test 2: options have length = 0 51422514Sdarrenr */ 51522514Sdarrenr printf("2.2.1 option length = 0, RR\n"); 51622514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_RR; 51722514Sdarrenr s[IPOPT_OLEN] = 0; 51822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 51922514Sdarrenr fflush(stdout); 52022514Sdarrenr PAUSE(); 52122514Sdarrenr 52222514Sdarrenr printf("2.2.2 option length = 0, TS\n"); 52322514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 52422514Sdarrenr s[IPOPT_OLEN] = 0; 52522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 52622514Sdarrenr fflush(stdout); 52722514Sdarrenr PAUSE(); 52822514Sdarrenr 52922514Sdarrenr printf("2.2.3 option length = 0, SECURITY\n"); 53022514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SECURITY; 53122514Sdarrenr s[IPOPT_OLEN] = 0; 53222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 53322514Sdarrenr fflush(stdout); 53422514Sdarrenr PAUSE(); 53522514Sdarrenr 53622514Sdarrenr printf("2.2.4 option length = 0, LSRR\n"); 53722514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_LSRR; 53822514Sdarrenr s[IPOPT_OLEN] = 0; 53922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 54022514Sdarrenr fflush(stdout); 54122514Sdarrenr PAUSE(); 54222514Sdarrenr 54322514Sdarrenr printf("2.2.5 option length = 0, SATID\n"); 54422514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SATID; 54522514Sdarrenr s[IPOPT_OLEN] = 0; 54622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 54722514Sdarrenr fflush(stdout); 54822514Sdarrenr PAUSE(); 54922514Sdarrenr 55022514Sdarrenr printf("2.2.6 option length = 0, SSRR\n"); 55122514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SSRR; 55222514Sdarrenr s[IPOPT_OLEN] = 0; 55322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 55422514Sdarrenr fflush(stdout); 55522514Sdarrenr PAUSE(); 55622514Sdarrenr } 55722514Sdarrenr 55822514Sdarrenr (void) close(nfd); 55922514Sdarrenr} 56022514Sdarrenr 56122514Sdarrenr 56222514Sdarrenr/* 56322514Sdarrenr * test 3 (ICMP) 56422514Sdarrenr */ 56522514Sdarrenrvoid ip_test3(dev, mtu, ip, gwip, ptest) 56622514Sdarrenrchar *dev; 56722514Sdarrenrint mtu; 56822514Sdarrenrip_t *ip; 56922514Sdarrenrstruct in_addr gwip; 57022514Sdarrenrint ptest; 57122514Sdarrenr{ 57222514Sdarrenr static int ict1[10] = { 8, 9, 10, 13, 14, 15, 16, 17, 18, 0 }; 57322514Sdarrenr static int ict2[8] = { 3, 9, 10, 13, 14, 17, 18, 0 }; 574145519Sdarrenr#ifdef USE_NANOSLEEP 575110920Sdarrenr struct timespec ts; 576110920Sdarrenr#else 57722514Sdarrenr struct timeval tv; 578110920Sdarrenr#endif 57922514Sdarrenr struct icmp *icp; 58022514Sdarrenr int nfd, i; 58122514Sdarrenr 582145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 583145519Sdarrenr IP_V_A(ip, IPVERSION); 58422514Sdarrenr ip->ip_tos = 0; 58522514Sdarrenr ip->ip_off = 0; 58622514Sdarrenr ip->ip_ttl = 60; 58722514Sdarrenr ip->ip_p = IPPROTO_ICMP; 58822514Sdarrenr ip->ip_sum = 0; 58922514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp); 590145519Sdarrenr icp = (struct icmp *)((char *)ip + (IP_HL(ip) << 2)); 591161357Sguido 592145519Sdarrenr nfd = initdevice(dev, 1); 593161357Sguido if (nfd == -1) 594161357Sguido return; 59522514Sdarrenr 59622514Sdarrenr if (!ptest || (ptest == 1)) { 59722514Sdarrenr /* 59822514Sdarrenr * Type 0 - 31, 255, code = 0 59922514Sdarrenr */ 60022514Sdarrenr bzero((char *)icp, sizeof(*icp)); 60122514Sdarrenr for (i = 0; i < 32; i++) { 60222514Sdarrenr icp->icmp_type = i; 60322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 60422514Sdarrenr PAUSE(); 60522514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, i); 60622514Sdarrenr } 60722514Sdarrenr icp->icmp_type = 255; 60822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 60922514Sdarrenr PAUSE(); 61022514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, 255); 61122514Sdarrenr putchar('\n'); 61222514Sdarrenr } 61322514Sdarrenr 61422514Sdarrenr if (!ptest || (ptest == 2)) { 61522514Sdarrenr /* 61622514Sdarrenr * Type 3, code = 0 - 31 61722514Sdarrenr */ 61822514Sdarrenr icp->icmp_type = 3; 61922514Sdarrenr for (i = 0; i < 32; i++) { 62022514Sdarrenr icp->icmp_code = i; 62122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 62222514Sdarrenr PAUSE(); 62322514Sdarrenr printf("3.2.%d ICMP type 3 code %d (all 0's)\r", i, i); 62422514Sdarrenr } 62522514Sdarrenr } 62622514Sdarrenr 62722514Sdarrenr if (!ptest || (ptest == 3)) { 62822514Sdarrenr /* 62922514Sdarrenr * Type 4, code = 0,127,128,255 63022514Sdarrenr */ 63122514Sdarrenr icp->icmp_type = 4; 63222514Sdarrenr icp->icmp_code = 0; 63322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 63422514Sdarrenr PAUSE(); 63522514Sdarrenr printf("3.3.1 ICMP type 4 code 0 (all 0's)\r"); 63622514Sdarrenr icp->icmp_code = 127; 63722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 63822514Sdarrenr PAUSE(); 63922514Sdarrenr printf("3.3.2 ICMP type 4 code 127 (all 0's)\r"); 64022514Sdarrenr icp->icmp_code = 128; 64122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64222514Sdarrenr PAUSE(); 64322514Sdarrenr printf("3.3.3 ICMP type 4 code 128 (all 0's)\r"); 64422514Sdarrenr icp->icmp_code = 255; 64522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64622514Sdarrenr PAUSE(); 64722514Sdarrenr printf("3.3.4 ICMP type 4 code 255 (all 0's)\r"); 64822514Sdarrenr } 64922514Sdarrenr 65022514Sdarrenr if (!ptest || (ptest == 4)) { 65122514Sdarrenr /* 65222514Sdarrenr * Type 5, code = 0,127,128,255 65322514Sdarrenr */ 65422514Sdarrenr icp->icmp_type = 5; 65522514Sdarrenr icp->icmp_code = 0; 65622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 65722514Sdarrenr PAUSE(); 65822514Sdarrenr printf("3.4.1 ICMP type 5 code 0 (all 0's)\r"); 65922514Sdarrenr icp->icmp_code = 127; 66022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66122514Sdarrenr PAUSE(); 66222514Sdarrenr printf("3.4.2 ICMP type 5 code 127 (all 0's)\r"); 66322514Sdarrenr icp->icmp_code = 128; 66422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66522514Sdarrenr PAUSE(); 66622514Sdarrenr printf("3.4.3 ICMP type 5 code 128 (all 0's)\r"); 66722514Sdarrenr icp->icmp_code = 255; 66822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66922514Sdarrenr PAUSE(); 67022514Sdarrenr printf("3.4.4 ICMP type 5 code 255 (all 0's)\r"); 67122514Sdarrenr } 67222514Sdarrenr 67322514Sdarrenr if (!ptest || (ptest == 5)) { 67422514Sdarrenr /* 67522514Sdarrenr * Type 8-10;13-18, code - 0,127,128,255 67622514Sdarrenr */ 67722514Sdarrenr for (i = 0; ict1[i]; i++) { 67822514Sdarrenr icp->icmp_type = ict1[i]; 67922514Sdarrenr icp->icmp_code = 0; 68022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 68122514Sdarrenr PAUSE(); 68222514Sdarrenr printf("3.5.%d ICMP type 5 code 0 (all 0's)\r", 68322514Sdarrenr i * 4); 68422514Sdarrenr icp->icmp_code = 127; 68522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 68622514Sdarrenr PAUSE(); 68722514Sdarrenr printf("3.5.%d ICMP type 5 code 127 (all 0's)\r", 68822514Sdarrenr i * 4 + 1); 68922514Sdarrenr icp->icmp_code = 128; 69022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69122514Sdarrenr PAUSE(); 69222514Sdarrenr printf("3.5.%d ICMP type 5 code 128 (all 0's)\r", 69322514Sdarrenr i * 4 + 2); 69422514Sdarrenr icp->icmp_code = 255; 69522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69622514Sdarrenr PAUSE(); 69722514Sdarrenr printf("3.5.%d ICMP type 5 code 255 (all 0's)\r", 69822514Sdarrenr i * 4 + 3); 69922514Sdarrenr } 70022514Sdarrenr putchar('\n'); 70122514Sdarrenr } 70222514Sdarrenr 70322514Sdarrenr if (!ptest || (ptest == 6)) { 70422514Sdarrenr /* 70522514Sdarrenr * Type 12, code - 0,127,128,129,255 70622514Sdarrenr */ 70722514Sdarrenr icp->icmp_type = 12; 70822514Sdarrenr icp->icmp_code = 0; 70922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 71022514Sdarrenr PAUSE(); 71122514Sdarrenr printf("3.6.1 ICMP type 12 code 0 (all 0's)\r"); 71222514Sdarrenr icp->icmp_code = 127; 71322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 71422514Sdarrenr PAUSE(); 71522514Sdarrenr printf("3.6.2 ICMP type 12 code 127 (all 0's)\r"); 71622514Sdarrenr icp->icmp_code = 128; 71722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 71822514Sdarrenr PAUSE(); 71922514Sdarrenr printf("3.6.3 ICMP type 12 code 128 (all 0's)\r"); 72022514Sdarrenr icp->icmp_code = 129; 72122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72222514Sdarrenr PAUSE(); 72322514Sdarrenr printf("3.6.4 ICMP type 12 code 129 (all 0's)\r"); 72422514Sdarrenr icp->icmp_code = 255; 72522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72622514Sdarrenr PAUSE(); 72722514Sdarrenr printf("3.6.5 ICMP type 12 code 255 (all 0's)\r"); 72822514Sdarrenr putchar('\n'); 72922514Sdarrenr } 73022514Sdarrenr 73122514Sdarrenr if (!ptest || (ptest == 7)) { 73222514Sdarrenr /* 73322514Sdarrenr * Type 3;9-10;13-14;17-18 - shorter packets 73422514Sdarrenr */ 73522514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp) / 2; 73622514Sdarrenr for (i = 0; ict2[i]; i++) { 73722514Sdarrenr icp->icmp_type = ict1[i]; 73822514Sdarrenr icp->icmp_code = 0; 73922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 74022514Sdarrenr PAUSE(); 74122514Sdarrenr printf("3.5.%d ICMP type %d code 0 (all 0's)\r", 74222514Sdarrenr i * 4, icp->icmp_type); 74322514Sdarrenr icp->icmp_code = 127; 74422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 74522514Sdarrenr PAUSE(); 74622514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 74722514Sdarrenr i * 4 + 1, icp->icmp_type); 74822514Sdarrenr icp->icmp_code = 128; 74922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 75022514Sdarrenr PAUSE(); 75122514Sdarrenr printf("3.5.%d ICMP type %d code 128 (all 0's)\r", 75222514Sdarrenr i * 4 + 2, icp->icmp_type); 75322514Sdarrenr icp->icmp_code = 255; 75422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 75522514Sdarrenr PAUSE(); 75622514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 75722514Sdarrenr i * 4 + 3, icp->icmp_type); 75822514Sdarrenr } 75922514Sdarrenr putchar('\n'); 76022514Sdarrenr } 76122514Sdarrenr} 76222514Sdarrenr 76322514Sdarrenr 76422514Sdarrenr/* Perform test 4 (UDP) */ 76522514Sdarrenr 76622514Sdarrenrvoid ip_test4(dev, mtu, ip, gwip, ptest) 76722514Sdarrenrchar *dev; 76822514Sdarrenrint mtu; 76922514Sdarrenrip_t *ip; 77022514Sdarrenrstruct in_addr gwip; 77122514Sdarrenrint ptest; 77222514Sdarrenr{ 773145519Sdarrenr#ifdef USE_NANOSLEEP 774110920Sdarrenr struct timespec ts; 775110920Sdarrenr#else 77622514Sdarrenr struct timeval tv; 777110920Sdarrenr#endif 77831183Speter udphdr_t *u; 77922514Sdarrenr int nfd, i; 78022514Sdarrenr 78122514Sdarrenr 782145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 783145519Sdarrenr IP_V_A(ip, IPVERSION); 78422514Sdarrenr ip->ip_tos = 0; 78522514Sdarrenr ip->ip_off = 0; 78622514Sdarrenr ip->ip_ttl = 60; 78722514Sdarrenr ip->ip_p = IPPROTO_UDP; 78822514Sdarrenr ip->ip_sum = 0; 789145519Sdarrenr u = (udphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 79037074Speter u->uh_sport = htons(1); 79137074Speter u->uh_dport = htons(1); 79237074Speter u->uh_ulen = htons(sizeof(*u) + 4); 793161357Sguido 794145519Sdarrenr nfd = initdevice(dev, 1); 795161357Sguido if (nfd == -1) 796161357Sguido return; 79722514Sdarrenr 79822514Sdarrenr if (!ptest || (ptest == 1)) { 79922514Sdarrenr /* 80022514Sdarrenr * Test 1. ulen > packet 80122514Sdarrenr */ 80237074Speter u->uh_ulen = htons(sizeof(*u) + 4); 803145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 80422514Sdarrenr printf("4.1 UDP uh_ulen > packet size - short packets\n"); 80537074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 80637074Speter u->uh_ulen = htons(i); 80722514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 80822514Sdarrenr printf("%d\r", i); 80922514Sdarrenr fflush(stdout); 81022514Sdarrenr PAUSE(); 81122514Sdarrenr } 81222514Sdarrenr putchar('\n'); 81322514Sdarrenr } 81422514Sdarrenr 81522514Sdarrenr if (!ptest || (ptest == 2)) { 81622514Sdarrenr /* 81722514Sdarrenr * Test 2. ulen < packet 81822514Sdarrenr */ 81937074Speter u->uh_ulen = htons(sizeof(*u) + 4); 820145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 82122514Sdarrenr printf("4.2 UDP uh_ulen < packet size - short packets\n"); 82237074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 82322514Sdarrenr ip->ip_len = i; 82422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 82522514Sdarrenr printf("%d\r", i); 82622514Sdarrenr fflush(stdout); 82722514Sdarrenr PAUSE(); 82822514Sdarrenr } 82922514Sdarrenr putchar('\n'); 83022514Sdarrenr } 83122514Sdarrenr 83222514Sdarrenr if (!ptest || (ptest == 3)) { 83322514Sdarrenr /* 83422514Sdarrenr * Test 3: sport = 0, sport = 1, sport = 32767 83522514Sdarrenr * sport = 32768, sport = 65535 83622514Sdarrenr */ 83722514Sdarrenr u->uh_ulen = sizeof(*u) + 4; 838145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 83922514Sdarrenr printf("4.3.1 UDP sport = 0\n"); 84022514Sdarrenr u->uh_sport = 0; 84122514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 84222514Sdarrenr printf("0\n"); 84322514Sdarrenr fflush(stdout); 84422514Sdarrenr PAUSE(); 84522514Sdarrenr printf("4.3.2 UDP sport = 1\n"); 84637074Speter u->uh_sport = htons(1); 84722514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 84822514Sdarrenr printf("1\n"); 84922514Sdarrenr fflush(stdout); 85022514Sdarrenr PAUSE(); 85122514Sdarrenr printf("4.3.3 UDP sport = 32767\n"); 85237074Speter u->uh_sport = htons(32767); 85322514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 85422514Sdarrenr printf("32767\n"); 85522514Sdarrenr fflush(stdout); 85622514Sdarrenr PAUSE(); 85722514Sdarrenr printf("4.3.4 UDP sport = 32768\n"); 85837074Speter u->uh_sport = htons(32768); 85922514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86022514Sdarrenr printf("32768\n"); 86122514Sdarrenr putchar('\n'); 86222514Sdarrenr fflush(stdout); 86322514Sdarrenr PAUSE(); 86422514Sdarrenr printf("4.3.5 UDP sport = 65535\n"); 86537074Speter u->uh_sport = htons(65535); 86622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86722514Sdarrenr printf("65535\n"); 86822514Sdarrenr fflush(stdout); 86922514Sdarrenr PAUSE(); 87022514Sdarrenr } 87122514Sdarrenr 87222514Sdarrenr if (!ptest || (ptest == 4)) { 87322514Sdarrenr /* 87422514Sdarrenr * Test 4: dport = 0, dport = 1, dport = 32767 87522514Sdarrenr * dport = 32768, dport = 65535 87622514Sdarrenr */ 87737074Speter u->uh_ulen = ntohs(sizeof(*u) + 4); 87837074Speter u->uh_sport = htons(1); 879145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 88022514Sdarrenr printf("4.4.1 UDP dport = 0\n"); 88122514Sdarrenr u->uh_dport = 0; 88222514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 88322514Sdarrenr printf("0\n"); 88422514Sdarrenr fflush(stdout); 88522514Sdarrenr PAUSE(); 88622514Sdarrenr printf("4.4.2 UDP dport = 1\n"); 88737074Speter u->uh_dport = htons(1); 88822514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 88922514Sdarrenr printf("1\n"); 89022514Sdarrenr fflush(stdout); 89122514Sdarrenr PAUSE(); 89222514Sdarrenr printf("4.4.3 UDP dport = 32767\n"); 89337074Speter u->uh_dport = htons(32767); 89422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 89522514Sdarrenr printf("32767\n"); 89622514Sdarrenr fflush(stdout); 89722514Sdarrenr PAUSE(); 89822514Sdarrenr printf("4.4.4 UDP dport = 32768\n"); 89937074Speter u->uh_dport = htons(32768); 90022514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 90122514Sdarrenr printf("32768\n"); 90222514Sdarrenr fflush(stdout); 90322514Sdarrenr PAUSE(); 90422514Sdarrenr printf("4.4.5 UDP dport = 65535\n"); 90537074Speter u->uh_dport = htons(65535); 90622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 90722514Sdarrenr printf("65535\n"); 90822514Sdarrenr fflush(stdout); 90922514Sdarrenr PAUSE(); 91022514Sdarrenr } 91122514Sdarrenr 91231183Speter if (!ptest || (ptest == 5)) { 91322514Sdarrenr /* 91431183Speter * Test 5: sizeof(ip_t) <= MTU <= sizeof(udphdr_t) + 91531183Speter * sizeof(ip_t) 91622514Sdarrenr */ 91722514Sdarrenr printf("4.5 UDP 20 <= MTU <= 32\n"); 91837074Speter for (i = sizeof(*ip); i <= ntohs(u->uh_ulen); i++) { 91922514Sdarrenr (void) send_udp(nfd, i, ip, gwip); 92022514Sdarrenr printf("%d\r", i); 92122514Sdarrenr fflush(stdout); 92222514Sdarrenr PAUSE(); 92322514Sdarrenr } 92422514Sdarrenr putchar('\n'); 92522514Sdarrenr } 92622514Sdarrenr} 92722514Sdarrenr 92822514Sdarrenr 92922514Sdarrenr/* Perform test 5 (TCP) */ 93022514Sdarrenr 93122514Sdarrenrvoid ip_test5(dev, mtu, ip, gwip, ptest) 93222514Sdarrenrchar *dev; 93322514Sdarrenrint mtu; 93422514Sdarrenrip_t *ip; 93522514Sdarrenrstruct in_addr gwip; 93622514Sdarrenrint ptest; 93722514Sdarrenr{ 938145519Sdarrenr#ifdef USE_NANOSLEEP 939110920Sdarrenr struct timespec ts; 940110920Sdarrenr#else 94122514Sdarrenr struct timeval tv; 942110920Sdarrenr#endif 94322514Sdarrenr tcphdr_t *t; 94422514Sdarrenr int nfd, i; 94522514Sdarrenr 946145519Sdarrenr t = (tcphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 947145519Sdarrenr#if !defined(linux) && !defined(__osf__) 94822514Sdarrenr t->th_x2 = 0; 94931183Speter#endif 950145519Sdarrenr TCP_OFF_A(t, 0); 95137074Speter t->th_sport = htons(1); 95237074Speter t->th_dport = htons(1); 95337074Speter t->th_win = htons(4096); 95422514Sdarrenr t->th_urp = 0; 95522514Sdarrenr t->th_sum = 0; 95637074Speter t->th_seq = htonl(1); 95722514Sdarrenr t->th_ack = 0; 95834739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 959161357Sguido 960145519Sdarrenr nfd = initdevice(dev, 1); 961161357Sguido if (nfd == -1) 962161357Sguido return; 96322514Sdarrenr 96422514Sdarrenr if (!ptest || (ptest == 1)) { 96522514Sdarrenr /* 96622514Sdarrenr * Test 1: flags variations, 0 - 3f 96722514Sdarrenr */ 968145519Sdarrenr TCP_OFF_A(t, sizeof(*t) >> 2); 96922514Sdarrenr printf("5.1 Test TCP flag combinations\n"); 97022514Sdarrenr for (i = 0; i <= (TH_URG|TH_ACK|TH_PUSH|TH_RST|TH_SYN|TH_FIN); 97122514Sdarrenr i++) { 97222514Sdarrenr t->th_flags = i; 97322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 97422514Sdarrenr printf("%d\r", i); 97522514Sdarrenr fflush(stdout); 97622514Sdarrenr PAUSE(); 97722514Sdarrenr } 97822514Sdarrenr putchar('\n'); 97922514Sdarrenr } 98022514Sdarrenr 98122514Sdarrenr if (!ptest || (ptest == 2)) { 98222514Sdarrenr t->th_flags = TH_SYN; 98322514Sdarrenr /* 98422514Sdarrenr * Test 2: seq = 0, seq = 1, seq = 0x7fffffff, seq=0x80000000, 98522514Sdarrenr * seq = 0xa000000, seq = 0xffffffff 98622514Sdarrenr */ 98722514Sdarrenr printf("5.2.1 TCP seq = 0\n"); 98837074Speter t->th_seq = htonl(0); 98922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 99022514Sdarrenr fflush(stdout); 99122514Sdarrenr PAUSE(); 99222514Sdarrenr 99322514Sdarrenr printf("5.2.2 TCP seq = 1\n"); 99437074Speter t->th_seq = htonl(1); 99522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 99622514Sdarrenr fflush(stdout); 99722514Sdarrenr PAUSE(); 99822514Sdarrenr 99922514Sdarrenr printf("5.2.3 TCP seq = 0x7fffffff\n"); 100037074Speter t->th_seq = htonl(0x7fffffff); 100122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 100222514Sdarrenr fflush(stdout); 100322514Sdarrenr PAUSE(); 100422514Sdarrenr 100522514Sdarrenr printf("5.2.4 TCP seq = 0x80000000\n"); 100637074Speter t->th_seq = htonl(0x80000000); 100722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 100822514Sdarrenr fflush(stdout); 100922514Sdarrenr PAUSE(); 101022514Sdarrenr 101122514Sdarrenr printf("5.2.5 TCP seq = 0xc0000000\n"); 101237074Speter t->th_seq = htonl(0xc0000000); 101322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 101422514Sdarrenr fflush(stdout); 101522514Sdarrenr PAUSE(); 101622514Sdarrenr 101722514Sdarrenr printf("5.2.6 TCP seq = 0xffffffff\n"); 101837074Speter t->th_seq = htonl(0xffffffff); 101922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102022514Sdarrenr fflush(stdout); 102122514Sdarrenr PAUSE(); 102222514Sdarrenr } 102322514Sdarrenr 102422514Sdarrenr if (!ptest || (ptest == 3)) { 102522514Sdarrenr t->th_flags = TH_ACK; 102622514Sdarrenr /* 102722514Sdarrenr * Test 3: ack = 0, ack = 1, ack = 0x7fffffff, ack = 0x8000000 102822514Sdarrenr * ack = 0xa000000, ack = 0xffffffff 102922514Sdarrenr */ 103022514Sdarrenr printf("5.3.1 TCP ack = 0\n"); 103122514Sdarrenr t->th_ack = 0; 103222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 103322514Sdarrenr fflush(stdout); 103422514Sdarrenr PAUSE(); 103522514Sdarrenr 103622514Sdarrenr printf("5.3.2 TCP ack = 1\n"); 103737074Speter t->th_ack = htonl(1); 103822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 103922514Sdarrenr fflush(stdout); 104022514Sdarrenr PAUSE(); 104122514Sdarrenr 104222514Sdarrenr printf("5.3.3 TCP ack = 0x7fffffff\n"); 104337074Speter t->th_ack = htonl(0x7fffffff); 104422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 104522514Sdarrenr fflush(stdout); 104622514Sdarrenr PAUSE(); 104722514Sdarrenr 104822514Sdarrenr printf("5.3.4 TCP ack = 0x80000000\n"); 104937074Speter t->th_ack = htonl(0x80000000); 105022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105122514Sdarrenr fflush(stdout); 105222514Sdarrenr PAUSE(); 105322514Sdarrenr 105422514Sdarrenr printf("5.3.5 TCP ack = 0xc0000000\n"); 105537074Speter t->th_ack = htonl(0xc0000000); 105622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105722514Sdarrenr fflush(stdout); 105822514Sdarrenr PAUSE(); 105922514Sdarrenr 106022514Sdarrenr printf("5.3.6 TCP ack = 0xffffffff\n"); 106137074Speter t->th_ack = htonl(0xffffffff); 106222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 106322514Sdarrenr fflush(stdout); 106422514Sdarrenr PAUSE(); 106522514Sdarrenr } 106622514Sdarrenr 106722514Sdarrenr if (!ptest || (ptest == 4)) { 106822514Sdarrenr t->th_flags = TH_SYN; 106922514Sdarrenr /* 107022514Sdarrenr * Test 4: win = 0, win = 32768, win = 65535 107122514Sdarrenr */ 107222514Sdarrenr printf("5.4.1 TCP win = 0\n"); 107337074Speter t->th_seq = htonl(0); 107422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 107522514Sdarrenr fflush(stdout); 107622514Sdarrenr PAUSE(); 107722514Sdarrenr 107822514Sdarrenr printf("5.4.2 TCP win = 32768\n"); 107937074Speter t->th_seq = htonl(0x7fff); 108022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 108122514Sdarrenr fflush(stdout); 108222514Sdarrenr PAUSE(); 108322514Sdarrenr 108422514Sdarrenr printf("5.4.3 TCP win = 65535\n"); 108537074Speter t->th_win = htons(0xffff); 108622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 108722514Sdarrenr fflush(stdout); 108822514Sdarrenr PAUSE(); 108922514Sdarrenr } 109022514Sdarrenr 109134739Speter#if !defined(linux) && !defined(__SVR4) && !defined(__svr4__) && \ 1092145519Sdarrenr !defined(__sgi) && !defined(__hpux) && !defined(__osf__) 109322514Sdarrenr { 109434739Speter struct tcpcb *tcbp, tcb; 109522514Sdarrenr struct tcpiphdr ti; 109622514Sdarrenr struct sockaddr_in sin; 109722514Sdarrenr int fd, slen; 109822514Sdarrenr 109922514Sdarrenr bzero((char *)&sin, sizeof(sin)); 110022514Sdarrenr 110122514Sdarrenr for (i = 1; i < 63; i++) { 110222514Sdarrenr fd = socket(AF_INET, SOCK_STREAM, 0); 110334739Speter bzero((char *)&sin, sizeof(sin)); 110422514Sdarrenr sin.sin_addr.s_addr = ip->ip_dst.s_addr; 110522514Sdarrenr sin.sin_port = htons(i); 110634739Speter sin.sin_family = AF_INET; 110722514Sdarrenr if (!connect(fd, (struct sockaddr *)&sin, sizeof(sin))) 110822514Sdarrenr break; 110934739Speter close(fd); 111022514Sdarrenr } 111122514Sdarrenr 111222514Sdarrenr if (i == 63) { 111322514Sdarrenr printf("Couldn't open a TCP socket between ports 1 and 63\n"); 111422514Sdarrenr printf("to host %s for test 5 and 6 - skipping.\n", 111522514Sdarrenr inet_ntoa(ip->ip_dst)); 111622514Sdarrenr goto skip_five_and_six; 111722514Sdarrenr } 111822514Sdarrenr 111922514Sdarrenr bcopy((char *)ip, (char *)&ti, sizeof(*ip)); 112034739Speter t->th_dport = htons(i); 112122514Sdarrenr slen = sizeof(sin); 112222514Sdarrenr if (!getsockname(fd, (struct sockaddr *)&sin, &slen)) 112334739Speter t->th_sport = sin.sin_port; 112434739Speter if (!(tcbp = find_tcp(fd, &ti))) { 112522514Sdarrenr printf("Can't find PCB\n"); 112622514Sdarrenr goto skip_five_and_six; 112722514Sdarrenr } 112834739Speter KMCPY(&tcb, tcbp, sizeof(tcb)); 112922514Sdarrenr ti.ti_win = tcb.rcv_adv; 113037074Speter ti.ti_seq = htonl(tcb.snd_nxt - 1); 113122514Sdarrenr ti.ti_ack = tcb.rcv_nxt; 113222514Sdarrenr 113322514Sdarrenr if (!ptest || (ptest == 5)) { 113422514Sdarrenr /* 113522514Sdarrenr * Test 5: urp 113622514Sdarrenr */ 113734739Speter t->th_flags = TH_ACK|TH_URG; 113834739Speter printf("5.5.1 TCP Urgent pointer, sport %hu dport %hu\n", 113934739Speter ntohs(t->th_sport), ntohs(t->th_dport)); 114034739Speter t->th_urp = htons(1); 114122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 114222514Sdarrenr PAUSE(); 114334739Speter 114437074Speter t->th_seq = htonl(tcb.snd_nxt); 114534739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t) + 1; 114634739Speter t->th_urp = htons(0x7fff); 114722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 114822514Sdarrenr PAUSE(); 114934739Speter t->th_urp = htons(0x8000); 115022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 115122514Sdarrenr PAUSE(); 115234739Speter t->th_urp = htons(0xffff); 115322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 115422514Sdarrenr PAUSE(); 115537074Speter t->th_urp = 0; 115634739Speter t->th_flags &= ~TH_URG; 115734739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 115822514Sdarrenr } 115922514Sdarrenr 116022514Sdarrenr if (!ptest || (ptest == 6)) { 116122514Sdarrenr /* 116222514Sdarrenr * Test 6: data offset, off = 0, off is inside, off is outside 116322514Sdarrenr */ 116434739Speter t->th_flags = TH_ACK; 116534739Speter printf("5.6.1 TCP off = 1-15, len = 40\n"); 116634739Speter for (i = 1; i < 16; i++) { 1167145519Sdarrenr TCP_OFF_A(t, ntohs(i)); 116822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 116922514Sdarrenr printf("%d\r", i); 117022514Sdarrenr fflush(stdout); 117122514Sdarrenr PAUSE(); 117222514Sdarrenr } 117322514Sdarrenr putchar('\n'); 117434739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 117522514Sdarrenr } 117622514Sdarrenr 117722514Sdarrenr (void) close(fd); 117822514Sdarrenr } 117922514Sdarrenrskip_five_and_six: 118022514Sdarrenr#endif 118137074Speter t->th_seq = htonl(1); 118237074Speter t->th_ack = htonl(1); 1183145519Sdarrenr TCP_OFF_A(t, 0); 118422514Sdarrenr 118522514Sdarrenr if (!ptest || (ptest == 7)) { 118622514Sdarrenr t->th_flags = TH_SYN; 118722514Sdarrenr /* 118822514Sdarrenr * Test 7: sport = 0, sport = 1, sport = 32767 118922514Sdarrenr * sport = 32768, sport = 65535 119022514Sdarrenr */ 119122514Sdarrenr printf("5.7.1 TCP sport = 0\n"); 119222514Sdarrenr t->th_sport = 0; 119322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 119422514Sdarrenr fflush(stdout); 119522514Sdarrenr PAUSE(); 119622514Sdarrenr 119722514Sdarrenr printf("5.7.2 TCP sport = 1\n"); 119837074Speter t->th_sport = htons(1); 119922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120022514Sdarrenr fflush(stdout); 120122514Sdarrenr PAUSE(); 120222514Sdarrenr 120322514Sdarrenr printf("5.7.3 TCP sport = 32767\n"); 120437074Speter t->th_sport = htons(32767); 120522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120622514Sdarrenr fflush(stdout); 120722514Sdarrenr PAUSE(); 120822514Sdarrenr 120922514Sdarrenr printf("5.7.4 TCP sport = 32768\n"); 121037074Speter t->th_sport = htons(32768); 121122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 121222514Sdarrenr fflush(stdout); 121322514Sdarrenr PAUSE(); 121422514Sdarrenr 121522514Sdarrenr printf("5.7.5 TCP sport = 65535\n"); 121637074Speter t->th_sport = htons(65535); 121722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 121822514Sdarrenr fflush(stdout); 121922514Sdarrenr PAUSE(); 122022514Sdarrenr } 122122514Sdarrenr 122222514Sdarrenr if (!ptest || (ptest == 8)) { 122337074Speter t->th_sport = htons(1); 122434739Speter t->th_flags = TH_SYN; 122522514Sdarrenr /* 122622514Sdarrenr * Test 8: dport = 0, dport = 1, dport = 32767 122722514Sdarrenr * dport = 32768, dport = 65535 122822514Sdarrenr */ 122922514Sdarrenr printf("5.8.1 TCP dport = 0\n"); 123022514Sdarrenr t->th_dport = 0; 123122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 123222514Sdarrenr fflush(stdout); 123322514Sdarrenr PAUSE(); 123422514Sdarrenr 123522514Sdarrenr printf("5.8.2 TCP dport = 1\n"); 123637074Speter t->th_dport = htons(1); 123722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 123822514Sdarrenr fflush(stdout); 123922514Sdarrenr PAUSE(); 124022514Sdarrenr 124122514Sdarrenr printf("5.8.3 TCP dport = 32767\n"); 124237074Speter t->th_dport = htons(32767); 124322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 124422514Sdarrenr fflush(stdout); 124522514Sdarrenr PAUSE(); 124622514Sdarrenr 124722514Sdarrenr printf("5.8.4 TCP dport = 32768\n"); 124837074Speter t->th_dport = htons(32768); 124922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 125022514Sdarrenr fflush(stdout); 125122514Sdarrenr PAUSE(); 125222514Sdarrenr 125322514Sdarrenr printf("5.8.5 TCP dport = 65535\n"); 125437074Speter t->th_dport = htons(65535); 125522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 125622514Sdarrenr fflush(stdout); 125722514Sdarrenr PAUSE(); 125822514Sdarrenr } 125934739Speter 126034739Speter /* LAND attack - self connect, so make src & dst ip/port the same */ 126134739Speter if (!ptest || (ptest == 9)) { 126234739Speter printf("5.9 TCP LAND attack. sport = 25, dport = 25\n"); 126334739Speter /* chose SMTP port 25 */ 126434739Speter t->th_sport = htons(25); 126534739Speter t->th_dport = htons(25); 126634739Speter t->th_flags = TH_SYN; 126734739Speter ip->ip_src = ip->ip_dst; 126834739Speter (void) send_tcp(nfd, mtu, ip, gwip); 126934739Speter fflush(stdout); 127034739Speter PAUSE(); 127134739Speter } 127234739Speter 127322514Sdarrenr /* TCP options header checking */ 127422514Sdarrenr /* 0 length options, etc */ 127522514Sdarrenr} 127622514Sdarrenr 127722514Sdarrenr 127822514Sdarrenr/* Perform test 6 (exhaust mbuf test) */ 127922514Sdarrenr 128022514Sdarrenrvoid ip_test6(dev, mtu, ip, gwip, ptest) 128122514Sdarrenrchar *dev; 128222514Sdarrenrint mtu; 128322514Sdarrenrip_t *ip; 128422514Sdarrenrstruct in_addr gwip; 128522514Sdarrenrint ptest; 128622514Sdarrenr{ 1287145519Sdarrenr#ifdef USE_NANOSLEEP 1288110920Sdarrenr struct timespec ts; 1289110920Sdarrenr#else 129022514Sdarrenr struct timeval tv; 1291110920Sdarrenr#endif 129222514Sdarrenr udphdr_t *u; 129322514Sdarrenr int nfd, i, j, k; 129422514Sdarrenr 1295145519Sdarrenr IP_V_A(ip, IPVERSION); 129622514Sdarrenr ip->ip_tos = 0; 129722514Sdarrenr ip->ip_off = 0; 129822514Sdarrenr ip->ip_ttl = 60; 129922514Sdarrenr ip->ip_p = IPPROTO_UDP; 130022514Sdarrenr ip->ip_sum = 0; 130122514Sdarrenr u = (udphdr_t *)(ip + 1); 130237074Speter u->uh_sport = htons(1); 130337074Speter u->uh_dport = htons(9); 130422514Sdarrenr u->uh_sum = 0; 130522514Sdarrenr 1306145519Sdarrenr nfd = initdevice(dev, 1); 1307161357Sguido if (nfd == -1) 1308161357Sguido return; 1309161357Sguido 131037074Speter u->uh_ulen = htons(7168); 131122514Sdarrenr 131234739Speter printf("6. Exhaustive mbuf test.\n"); 131334739Speter printf(" Send 7k packet in 768 & 128 byte fragments, 128 times.\n"); 131434739Speter printf(" Total of around 8,900 packets\n"); 131522514Sdarrenr for (i = 0; i < 128; i++) { 131622514Sdarrenr /* 131722514Sdarrenr * First send the entire packet in 768 byte chunks. 131822514Sdarrenr */ 131922514Sdarrenr ip->ip_len = sizeof(*ip) + 768 + sizeof(*u); 1320145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 132137074Speter ip->ip_off = htons(IP_MF); 132222514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 132322514Sdarrenr printf("%d %d\r", i, 0); 132422514Sdarrenr fflush(stdout); 132522514Sdarrenr PAUSE(); 132622514Sdarrenr /* 132722514Sdarrenr * And again using 128 byte chunks. 132822514Sdarrenr */ 132922514Sdarrenr ip->ip_len = sizeof(*ip) + 128 + sizeof(*u); 133037074Speter ip->ip_off = htons(IP_MF); 133122514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 133222514Sdarrenr printf("%d %d\r", i, 0); 133322514Sdarrenr fflush(stdout); 133422514Sdarrenr PAUSE(); 133522514Sdarrenr 133622514Sdarrenr for (j = 768; j < 3584; j += 768) { 133722514Sdarrenr ip->ip_len = sizeof(*ip) + 768; 1338145519Sdarrenr ip->ip_off = htons(IP_MF|(j>>3)); 133922514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 134022514Sdarrenr printf("%d %d\r", i, j); 134122514Sdarrenr fflush(stdout); 134222514Sdarrenr PAUSE(); 134322514Sdarrenr 134422514Sdarrenr ip->ip_len = sizeof(*ip) + 128; 134522514Sdarrenr for (k = j - 768; k < j; k += 128) { 1346145519Sdarrenr ip->ip_off = htons(IP_MF|(k>>3)); 134722514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 134822514Sdarrenr printf("%d %d\r", i, k); 134922514Sdarrenr fflush(stdout); 135022514Sdarrenr PAUSE(); 135122514Sdarrenr } 135222514Sdarrenr } 135322514Sdarrenr } 135422514Sdarrenr putchar('\n'); 135522514Sdarrenr} 135622514Sdarrenr 135722514Sdarrenr 135822514Sdarrenr/* Perform test 7 (random packets) */ 135922514Sdarrenr 136022514Sdarrenrstatic u_long tbuf[64]; 136122514Sdarrenr 136222514Sdarrenrvoid ip_test7(dev, mtu, ip, gwip, ptest) 136322514Sdarrenrchar *dev; 136422514Sdarrenrint mtu; 136522514Sdarrenrip_t *ip; 136622514Sdarrenrstruct in_addr gwip; 136722514Sdarrenrint ptest; 136822514Sdarrenr{ 1369145519Sdarrenr ip_t *pip; 1370145519Sdarrenr#ifdef USE_NANOSLEEP 1371110920Sdarrenr struct timespec ts; 1372110920Sdarrenr#else 1373110920Sdarrenr struct timeval tv; 1374110920Sdarrenr#endif 137522514Sdarrenr int nfd, i, j; 137622514Sdarrenr u_char *s; 137722514Sdarrenr 1378145519Sdarrenr nfd = initdevice(dev, 1); 1379161357Sguido if (nfd == -1) 1380161357Sguido return; 1381161357Sguido 138222514Sdarrenr pip = (ip_t *)tbuf; 138322514Sdarrenr 138422514Sdarrenr srand(time(NULL) ^ (getpid() * getppid())); 138522514Sdarrenr 138622514Sdarrenr printf("7. send 1024 random IP packets.\n"); 138722514Sdarrenr 138822514Sdarrenr for (i = 0; i < 512; i++) { 138922514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 139022514Sdarrenr *s = (rand() >> 13) & 0xff; 1391145519Sdarrenr IP_V_A(pip, IPVERSION); 139222514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 139322514Sdarrenr sizeof(struct in_addr)); 139422514Sdarrenr pip->ip_sum = 0; 139522514Sdarrenr pip->ip_len &= 0xff; 139622514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 139722514Sdarrenr printf("%d\r", i); 139822514Sdarrenr fflush(stdout); 139922514Sdarrenr PAUSE(); 140022514Sdarrenr } 140122514Sdarrenr putchar('\n'); 140222514Sdarrenr 140322514Sdarrenr for (i = 0; i < 512; i++) { 140422514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 140522514Sdarrenr *s = (rand() >> 13) & 0xff; 1406145519Sdarrenr IP_V_A(pip, IPVERSION); 140737074Speter pip->ip_off &= htons(0xc000); 140822514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 140922514Sdarrenr sizeof(struct in_addr)); 141022514Sdarrenr pip->ip_sum = 0; 141122514Sdarrenr pip->ip_len &= 0xff; 141222514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 141322514Sdarrenr printf("%d\r", i); 141422514Sdarrenr fflush(stdout); 141522514Sdarrenr PAUSE(); 141622514Sdarrenr } 141722514Sdarrenr putchar('\n'); 141822514Sdarrenr} 1419