iptests.c revision 110920
122514Sdarrenr/* 253024Sguido * Copyright (C) 1993-1998 by Darren Reed. 322514Sdarrenr * 480490Sdarrenr * See the IPFILTER.LICENCE file for details on licencing. 522514Sdarrenr */ 6110920Sdarrenr#if defined(__sgi) && (IRIX > 602) 792691Sdarrenr# include <sys/ptimers.h> 892691Sdarrenr#endif 922514Sdarrenr#include <stdio.h> 1022514Sdarrenr#include <unistd.h> 1122514Sdarrenr#include <stdlib.h> 1222514Sdarrenr#include <string.h> 1322514Sdarrenr#include <sys/types.h> 1422514Sdarrenr#include <sys/time.h> 1522514Sdarrenr#include <sys/param.h> 1653024Sguido#define _KERNEL 1753024Sguido#define KERNEL 1831183Speter#if !defined(solaris) && !defined(linux) && !defined(__sgi) 1922514Sdarrenr# include <sys/file.h> 2053024Sguido#else 2153024Sguido# ifdef solaris 2253024Sguido# include <sys/dditypes.h> 2353024Sguido# endif 2453024Sguido#endif 2553024Sguido#undef _KERNEL 2653024Sguido#undef KERNEL 2753024Sguido#if !defined(solaris) && !defined(linux) && !defined(__sgi) 2822514Sdarrenr# include <nlist.h> 2922514Sdarrenr# include <sys/user.h> 3022514Sdarrenr# include <sys/proc.h> 3122514Sdarrenr#endif 3231183Speter#if !defined(ultrix) && !defined(hpux) && !defined(linux) && !defined(__sgi) 3331183Speter# include <kvm.h> 3431183Speter#endif 3531183Speter#ifndef ultrix 3631183Speter# include <sys/socket.h> 3731183Speter#endif 3826119Sdarrenr#if defined(solaris) 3926119Sdarrenr# include <sys/stream.h> 4026119Sdarrenr#endif 4122514Sdarrenr#include <sys/socketvar.h> 4222514Sdarrenr#ifdef sun 4322514Sdarrenr#include <sys/systm.h> 4422514Sdarrenr#include <sys/session.h> 4522514Sdarrenr#endif 4622514Sdarrenr#if BSD >= 199103 4731183Speter# include <sys/sysctl.h> 4831183Speter# include <sys/filedesc.h> 4931183Speter# include <paths.h> 5022514Sdarrenr#endif 5122514Sdarrenr#include <netinet/in_systm.h> 5222514Sdarrenr#include <sys/socket.h> 5322514Sdarrenr#include <net/if.h> 5431183Speter#if defined(linux) && (LINUX >= 0200) 5531183Speter# include <asm/atomic.h> 5631183Speter#endif 5731183Speter#if !defined(linux) 5831183Speter# include <net/route.h> 5931183Speter#else 6031183Speter# define __KERNEL__ /* because there's a macro not wrapped by this */ 6131183Speter# include <net/route.h> /* in this file :-/ */ 6231183Speter#endif 6322514Sdarrenr#include <netinet/in.h> 6422514Sdarrenr#include <arpa/inet.h> 6522514Sdarrenr#include <netinet/ip.h> 6622514Sdarrenr#include <netinet/tcp.h> 6722514Sdarrenr#include <netinet/udp.h> 6822514Sdarrenr#include <netinet/ip_icmp.h> 6931183Speter#ifndef linux 7031183Speter# include <netinet/ip_var.h> 7131183Speter# include <netinet/in_pcb.h> 7231183Speter# include <netinet/tcp_timer.h> 7331183Speter# include <netinet/tcp_var.h> 7431183Speter#endif 7531183Speter#if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 7631183Speter# include <sys/sysmacros.h> 7731183Speter#endif 78110920Sdarrenr#if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 106000000) 79110920Sdarrenr# define USE_NANOSLEEP 80110920Sdarrenr#endif 8124583Sdarrenr#include "ipsend.h" 8222514Sdarrenr 8384843Sbde#if 0 8480490Sdarrenr#if !defined(lint) 8580490Sdarrenrstatic const char sccsid[] = "%W% %G% (C)1995 Darren Reed"; 86110920Sdarrenrstatic const char rcsid[] = "@(#)$Id: iptests.c,v 2.1.4.8 2002/12/06 11:40:35 darrenr Exp $"; 8780490Sdarrenr#endif 8884843Sbde#endif 8924583Sdarrenr 9084843Sbde__FBSDID("$FreeBSD: head/contrib/ipfilter/ipsend/iptests.c 110920 2003-02-15 06:32:48Z darrenr $"); 9180490Sdarrenr 9284843Sbde 93110920Sdarrenr#ifdef USE_NANOSLEEP 94110920Sdarrenr# define PAUSE() ts.tv_sec = 0; ts.tv_nsec = 10000000; \ 95110920Sdarrenr (void) nanosleep(&ts, NULL) 96110920Sdarrenr#else 97110920Sdarrenr# define PAUSE() tv.tv_sec = 0; tv.tv_usec = 10000; \ 98110920Sdarrenr (void) select(0, NULL, NULL, NULL, &tv) 99110920Sdarrenr#endif 10022514Sdarrenr 10122514Sdarrenr 10222514Sdarrenrvoid ip_test1(dev, mtu, ip, gwip, ptest) 10322514Sdarrenrchar *dev; 10422514Sdarrenrint mtu; 10522514Sdarrenrip_t *ip; 10622514Sdarrenrstruct in_addr gwip; 10722514Sdarrenrint ptest; 10822514Sdarrenr{ 109110920Sdarrenr#ifdef USE_NANOSLEEP 110110920Sdarrenr struct timespec ts; 111110920Sdarrenr#else 11222514Sdarrenr struct timeval tv; 113110920Sdarrenr#endif 11422514Sdarrenr udphdr_t *u; 11531183Speter int nfd, i = 0, len, id = getpid(); 11622514Sdarrenr 11722514Sdarrenr ip->ip_hl = sizeof(*ip) >> 2; 11822514Sdarrenr ip->ip_v = IPVERSION; 11922514Sdarrenr ip->ip_tos = 0; 12022514Sdarrenr ip->ip_off = 0; 12122514Sdarrenr ip->ip_ttl = 60; 12222514Sdarrenr ip->ip_p = IPPROTO_UDP; 12322514Sdarrenr ip->ip_sum = 0; 12422514Sdarrenr u = (udphdr_t *)(ip + 1); 12537074Speter u->uh_sport = htons(1); 12637074Speter u->uh_dport = htons(9); 12722514Sdarrenr u->uh_sum = 0; 12837074Speter u->uh_ulen = htons(sizeof(*u) + 4); 12937074Speter ip->ip_len = sizeof(*ip) + ntohs(u->uh_ulen); 13022514Sdarrenr len = ip->ip_len; 13122514Sdarrenr nfd = initdevice(dev, u->uh_sport, 1); 13222514Sdarrenr 13322514Sdarrenr if (!ptest || (ptest == 1)) { 13422514Sdarrenr /* 13522514Sdarrenr * Part1: hl < len 13622514Sdarrenr */ 13722514Sdarrenr ip->ip_id = 0; 13822514Sdarrenr printf("1.1. sending packets with ip_hl < ip_len\n"); 13937074Speter for (i = 0; i < ((sizeof(*ip) + ntohs(u->uh_ulen)) >> 2); i++) { 14022514Sdarrenr ip->ip_hl = i >> 2; 14122514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 14222514Sdarrenr printf("%d\r", i); 14322514Sdarrenr fflush(stdout); 14422514Sdarrenr PAUSE(); 14522514Sdarrenr } 14622514Sdarrenr putchar('\n'); 14722514Sdarrenr } 14822514Sdarrenr 14922514Sdarrenr if (!ptest || (ptest == 2)) { 15022514Sdarrenr /* 15122514Sdarrenr * Part2: hl > len 15222514Sdarrenr */ 15322514Sdarrenr ip->ip_id = 0; 15422514Sdarrenr printf("1.2. sending packets with ip_hl > ip_len\n"); 15537074Speter for (; i < ((sizeof(*ip) * 2 + ntohs(u->uh_ulen)) >> 2); i++) { 15622514Sdarrenr ip->ip_hl = i >> 2; 15722514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 15822514Sdarrenr printf("%d\r", i); 15922514Sdarrenr fflush(stdout); 16022514Sdarrenr PAUSE(); 16122514Sdarrenr } 16222514Sdarrenr putchar('\n'); 16322514Sdarrenr } 16422514Sdarrenr 16522514Sdarrenr if (!ptest || (ptest == 3)) { 16622514Sdarrenr /* 16722514Sdarrenr * Part3: v < 4 16822514Sdarrenr */ 16922514Sdarrenr ip->ip_id = 0; 17022514Sdarrenr printf("1.3. ip_v < 4\n"); 17122514Sdarrenr ip->ip_hl = sizeof(*ip) >> 2; 17222514Sdarrenr for (i = 0; i < 4; i++) { 17322514Sdarrenr ip->ip_v = i; 17422514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 17522514Sdarrenr printf("%d\r", i); 17622514Sdarrenr fflush(stdout); 17722514Sdarrenr PAUSE(); 17822514Sdarrenr } 17922514Sdarrenr putchar('\n'); 18022514Sdarrenr } 18122514Sdarrenr 18222514Sdarrenr if (!ptest || (ptest == 4)) { 18322514Sdarrenr /* 18422514Sdarrenr * Part4: v > 4 18522514Sdarrenr */ 18622514Sdarrenr ip->ip_id = 0; 18722514Sdarrenr printf("1.4. ip_v > 4\n"); 18822514Sdarrenr for (i = 5; i < 16; i++) { 18922514Sdarrenr ip->ip_v = i; 19022514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 19122514Sdarrenr printf("%d\r", i); 19222514Sdarrenr fflush(stdout); 19322514Sdarrenr PAUSE(); 19422514Sdarrenr } 19522514Sdarrenr putchar('\n'); 19622514Sdarrenr } 19722514Sdarrenr 19822514Sdarrenr if (!ptest || (ptest == 5)) { 19922514Sdarrenr /* 20022514Sdarrenr * Part5: len < packet 20122514Sdarrenr */ 20222514Sdarrenr ip->ip_id = 0; 20322514Sdarrenr ip->ip_v = IPVERSION; 20422514Sdarrenr i = ip->ip_len + 1; 20522514Sdarrenr printf("1.5.0 ip_len < packet size (size++, long packets)\n"); 20637074Speter for (; i < (ip->ip_len * 2); i++) { 20722514Sdarrenr ip->ip_id = htons(id++); 20822514Sdarrenr ip->ip_sum = 0; 20924583Sdarrenr ip->ip_sum = chksum((u_short *)ip, ip->ip_hl << 2); 21024583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 21122514Sdarrenr printf("%d\r", i); 21222514Sdarrenr fflush(stdout); 21322514Sdarrenr PAUSE(); 21422514Sdarrenr } 21522514Sdarrenr putchar('\n'); 21622514Sdarrenr printf("1.5.1 ip_len < packet size (ip_len-, short packets)\n"); 21722514Sdarrenr for (i = len; i > 0; i--) { 21822514Sdarrenr ip->ip_id = htons(id++); 21937074Speter ip->ip_len = i; 22022514Sdarrenr ip->ip_sum = 0; 22124583Sdarrenr ip->ip_sum = chksum((u_short *)ip, ip->ip_hl << 2); 22224583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 22322514Sdarrenr printf("%d\r", i); 22422514Sdarrenr fflush(stdout); 22522514Sdarrenr PAUSE(); 22622514Sdarrenr } 22722514Sdarrenr putchar('\n'); 22822514Sdarrenr } 22922514Sdarrenr 23022514Sdarrenr if (!ptest || (ptest == 6)) { 23122514Sdarrenr /* 23222514Sdarrenr * Part6: len > packet 23322514Sdarrenr */ 23422514Sdarrenr ip->ip_id = 0; 23522514Sdarrenr printf("1.6.0 ip_len > packet size (increase ip_len)\n"); 23622514Sdarrenr for (i = len + 1; i < (len * 2); i++) { 23722514Sdarrenr ip->ip_id = htons(id++); 23837074Speter ip->ip_len = i; 23922514Sdarrenr ip->ip_sum = 0; 24024583Sdarrenr ip->ip_sum = chksum((u_short *)ip, ip->ip_hl << 2); 24124583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 24222514Sdarrenr printf("%d\r", i); 24322514Sdarrenr fflush(stdout); 24422514Sdarrenr PAUSE(); 24522514Sdarrenr } 24622514Sdarrenr putchar('\n'); 24737074Speter ip->ip_len = len; 24822514Sdarrenr printf("1.6.1 ip_len > packet size (size--, short packets)\n"); 24922514Sdarrenr for (i = len; i > 0; i--) { 25022514Sdarrenr ip->ip_id = htons(id++); 25122514Sdarrenr ip->ip_sum = 0; 25224583Sdarrenr ip->ip_sum = chksum((u_short *)ip, ip->ip_hl << 2); 25324583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 25422514Sdarrenr printf("%d\r", i); 25522514Sdarrenr fflush(stdout); 25622514Sdarrenr PAUSE(); 25722514Sdarrenr } 25822514Sdarrenr putchar('\n'); 25922514Sdarrenr } 26022514Sdarrenr 26122514Sdarrenr if (!ptest || (ptest == 7)) { 26222514Sdarrenr /* 26322514Sdarrenr * Part7: 0 length fragment 26422514Sdarrenr */ 26522514Sdarrenr printf("1.7.0 Zero length fragments (ip_off = 0x2000)\n"); 26622514Sdarrenr ip->ip_id = 0; 26722514Sdarrenr ip->ip_len = sizeof(*ip); 26822514Sdarrenr ip->ip_off = htons(IP_MF); 26922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 27022514Sdarrenr fflush(stdout); 27122514Sdarrenr PAUSE(); 27222514Sdarrenr 27322514Sdarrenr printf("1.7.1 Zero length fragments (ip_off = 0x3000)\n"); 27422514Sdarrenr ip->ip_id = 0; 27522514Sdarrenr ip->ip_len = sizeof(*ip); 27622514Sdarrenr ip->ip_off = htons(IP_MF); 27722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 27822514Sdarrenr fflush(stdout); 27922514Sdarrenr PAUSE(); 28022514Sdarrenr 28122514Sdarrenr printf("1.7.2 Zero length fragments (ip_off = 0xa000)\n"); 28222514Sdarrenr ip->ip_id = 0; 28322514Sdarrenr ip->ip_len = sizeof(*ip); 28422514Sdarrenr ip->ip_off = htons(0xa000); 28522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 28622514Sdarrenr fflush(stdout); 28722514Sdarrenr PAUSE(); 28822514Sdarrenr 28922514Sdarrenr printf("1.7.3 Zero length fragments (ip_off = 0x0100)\n"); 29022514Sdarrenr ip->ip_id = 0; 29122514Sdarrenr ip->ip_len = sizeof(*ip); 29222514Sdarrenr ip->ip_off = htons(0x0100); 29322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 29422514Sdarrenr fflush(stdout); 29522514Sdarrenr PAUSE(); 29622514Sdarrenr } 29722514Sdarrenr 29822514Sdarrenr if (!ptest || (ptest == 8)) { 29922514Sdarrenr struct timeval tv; 30022514Sdarrenr 30122514Sdarrenr gettimeofday(&tv, NULL); 30222514Sdarrenr srand(tv.tv_sec ^ getpid() ^ tv.tv_usec); 30322514Sdarrenr /* 30422514Sdarrenr * Part8.1: 63k packet + 1k fragment at offset 0x1ffe 30522514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 30622514Sdarrenr * don't bother about the ICMP header, we're not worrying 30722514Sdarrenr * about that here. 30822514Sdarrenr */ 30922514Sdarrenr ip->ip_p = IPPROTO_ICMP; 31037074Speter ip->ip_off = htons(IP_MF); 31122514Sdarrenr u->uh_dport = htons(9); 31222514Sdarrenr ip->ip_id = htons(id++); 31322514Sdarrenr printf("1.8.1 63k packet + 1k fragment at offset 0x1ffe\n"); 31422514Sdarrenr ip->ip_len = 768 + 20 + 8; 31522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 31622514Sdarrenr printf("%d\r", i); 31722514Sdarrenr 31822514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 31922514Sdarrenr i = 512; 32022514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 32192691Sdarrenr ip->ip_off = htons(IP_MF | ((i >> 3) & 0x1fff)); 32222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 32322514Sdarrenr printf("%d\r", i); 32422514Sdarrenr fflush(stdout); 32522514Sdarrenr PAUSE(); 32622514Sdarrenr } 32722514Sdarrenr ip->ip_len = 896 + 20; 32892691Sdarrenr ip->ip_off = htons((i >> 3) & 0x1fff); 32922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 33022514Sdarrenr printf("%d\r", i); 33122514Sdarrenr putchar('\n'); 33222514Sdarrenr fflush(stdout); 33322514Sdarrenr 33422514Sdarrenr /* 33522514Sdarrenr * Part8.2: 63k packet + 1k fragment at offset 0x1ffe 33622514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 33722514Sdarrenr * don't bother about the ICMP header, we're not worrying 33822514Sdarrenr * about that here. (Lossage here) 33922514Sdarrenr */ 34022514Sdarrenr ip->ip_p = IPPROTO_ICMP; 34137074Speter ip->ip_off = htons(IP_MF); 34222514Sdarrenr u->uh_dport = htons(9); 34322514Sdarrenr ip->ip_id = htons(id++); 34422514Sdarrenr printf("1.8.2 63k packet + 1k fragment at offset 0x1ffe\n"); 34522514Sdarrenr ip->ip_len = 768 + 20 + 8; 34622514Sdarrenr if ((rand() & 0x1f) != 0) { 34722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 34822514Sdarrenr printf("%d\r", i); 34922514Sdarrenr } else 35022514Sdarrenr printf("skip 0\n"); 35122514Sdarrenr 35222514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 35322514Sdarrenr i = 512; 35422514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 35592691Sdarrenr ip->ip_off = htons(IP_MF | ((i >> 3) & 0x1fff)); 35622514Sdarrenr if ((rand() & 0x1f) != 0) { 35722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 35822514Sdarrenr printf("%d\r", i); 35922514Sdarrenr } else 36022514Sdarrenr printf("skip %d\n", i); 36122514Sdarrenr fflush(stdout); 36222514Sdarrenr PAUSE(); 36322514Sdarrenr } 36422514Sdarrenr ip->ip_len = 896 + 20; 36592691Sdarrenr ip->ip_off = htons((i >> 3) & 0x1fff); 36622514Sdarrenr if ((rand() & 0x1f) != 0) { 36722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 36822514Sdarrenr printf("%d\r", i); 36922514Sdarrenr } else 37022514Sdarrenr printf("skip\n"); 37122514Sdarrenr putchar('\n'); 37222514Sdarrenr fflush(stdout); 37322514Sdarrenr 37422514Sdarrenr /* 37522514Sdarrenr * Part8.3: 33k packet - test for not dealing with -ve length 37622514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 37722514Sdarrenr * don't bother about the ICMP header, we're not worrying 37822514Sdarrenr * about that here. 37922514Sdarrenr */ 38022514Sdarrenr ip->ip_p = IPPROTO_ICMP; 38137074Speter ip->ip_off = htons(IP_MF); 38222514Sdarrenr u->uh_dport = htons(9); 38322514Sdarrenr ip->ip_id = htons(id++); 38422514Sdarrenr printf("1.8.3 33k packet\n"); 38522514Sdarrenr ip->ip_len = 768 + 20 + 8; 38622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 38722514Sdarrenr printf("%d\r", i); 38822514Sdarrenr 38922514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 39022514Sdarrenr i = 512; 39122514Sdarrenr for (; i < (32 * 1024 + 768); i += 768) { 39292691Sdarrenr ip->ip_off = htons(IP_MF | ((i >> 3) & 0x1fff)); 39322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 39422514Sdarrenr printf("%d\r", i); 39522514Sdarrenr fflush(stdout); 39622514Sdarrenr PAUSE(); 39722514Sdarrenr } 39822514Sdarrenr ip->ip_len = 896 + 20; 39992691Sdarrenr ip->ip_off = htons((i >> 3) & 0x1fff); 40022514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 40122514Sdarrenr printf("%d\r", i); 40222514Sdarrenr putchar('\n'); 40322514Sdarrenr fflush(stdout); 40422514Sdarrenr } 40522514Sdarrenr 40622514Sdarrenr ip->ip_len = len; 40722514Sdarrenr ip->ip_off = 0; 40822514Sdarrenr if (!ptest || (ptest == 9)) { 40922514Sdarrenr /* 41022514Sdarrenr * Part9: off & 0x8000 == 0x8000 41122514Sdarrenr */ 41222514Sdarrenr ip->ip_id = 0; 41337074Speter ip->ip_off = htons(0x8000); 41422514Sdarrenr printf("1.9. ip_off & 0x8000 == 0x8000\n"); 41522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 41622514Sdarrenr fflush(stdout); 41722514Sdarrenr PAUSE(); 41822514Sdarrenr } 41922514Sdarrenr 42022514Sdarrenr ip->ip_off = 0; 42122514Sdarrenr 42222514Sdarrenr if (!ptest || (ptest == 10)) { 42322514Sdarrenr /* 42422514Sdarrenr * Part10: ttl = 255 42522514Sdarrenr */ 42622514Sdarrenr ip->ip_id = 0; 42722514Sdarrenr ip->ip_ttl = 255; 42822514Sdarrenr printf("1.10.0 ip_ttl = 255\n"); 42922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 43022514Sdarrenr fflush(stdout); 43122514Sdarrenr PAUSE(); 43222514Sdarrenr 43322514Sdarrenr ip->ip_ttl = 128; 43422514Sdarrenr printf("1.10.1 ip_ttl = 128\n"); 43522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 43622514Sdarrenr fflush(stdout); 43722514Sdarrenr PAUSE(); 43822514Sdarrenr 43922514Sdarrenr ip->ip_ttl = 0; 44022514Sdarrenr printf("1.10.2 ip_ttl = 0\n"); 44122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 44222514Sdarrenr fflush(stdout); 44322514Sdarrenr PAUSE(); 44422514Sdarrenr } 44522514Sdarrenr 44622514Sdarrenr (void) close(nfd); 44722514Sdarrenr} 44822514Sdarrenr 44922514Sdarrenr 45022514Sdarrenrvoid ip_test2(dev, mtu, ip, gwip, ptest) 45122514Sdarrenrchar *dev; 45222514Sdarrenrint mtu; 45322514Sdarrenrip_t *ip; 45422514Sdarrenrstruct in_addr gwip; 45522514Sdarrenrint ptest; 45622514Sdarrenr{ 457110920Sdarrenr#ifdef USE_NANOSLEEP 458110920Sdarrenr struct timespec ts; 459110920Sdarrenr#else 46022514Sdarrenr struct timeval tv; 461110920Sdarrenr#endif 46222514Sdarrenr int nfd; 46322514Sdarrenr u_char *s; 46422514Sdarrenr 46522514Sdarrenr s = (u_char *)(ip + 1); 46637074Speter nfd = initdevice(dev, htons(1), 1); 46722514Sdarrenr 46822514Sdarrenr ip->ip_hl = 6; 46922514Sdarrenr ip->ip_len = ip->ip_hl << 2; 47022514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_NOP; 47122514Sdarrenr s++; 47222514Sdarrenr if (!ptest || (ptest == 1)) { 47322514Sdarrenr /* 47422514Sdarrenr * Test 1: option length > packet length, 47522514Sdarrenr * header length == packet length 47622514Sdarrenr */ 47722514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 47822514Sdarrenr s[IPOPT_OLEN] = 4; 47922514Sdarrenr s[IPOPT_OFFSET] = IPOPT_MINOFF; 48022514Sdarrenr ip->ip_p = IPPROTO_IP; 48122514Sdarrenr printf("2.1 option length > packet length\n"); 48222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 48322514Sdarrenr fflush(stdout); 48422514Sdarrenr PAUSE(); 48522514Sdarrenr } 48622514Sdarrenr 48722514Sdarrenr ip->ip_hl = 7; 48822514Sdarrenr ip->ip_len = ip->ip_hl << 2; 48922514Sdarrenr if (!ptest || (ptest == 1)) { 49022514Sdarrenr /* 49122514Sdarrenr * Test 2: options have length = 0 49222514Sdarrenr */ 49322514Sdarrenr printf("2.2.1 option length = 0, RR\n"); 49422514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_RR; 49522514Sdarrenr s[IPOPT_OLEN] = 0; 49622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 49722514Sdarrenr fflush(stdout); 49822514Sdarrenr PAUSE(); 49922514Sdarrenr 50022514Sdarrenr printf("2.2.2 option length = 0, TS\n"); 50122514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 50222514Sdarrenr s[IPOPT_OLEN] = 0; 50322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 50422514Sdarrenr fflush(stdout); 50522514Sdarrenr PAUSE(); 50622514Sdarrenr 50722514Sdarrenr printf("2.2.3 option length = 0, SECURITY\n"); 50822514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SECURITY; 50922514Sdarrenr s[IPOPT_OLEN] = 0; 51022514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 51122514Sdarrenr fflush(stdout); 51222514Sdarrenr PAUSE(); 51322514Sdarrenr 51422514Sdarrenr printf("2.2.4 option length = 0, LSRR\n"); 51522514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_LSRR; 51622514Sdarrenr s[IPOPT_OLEN] = 0; 51722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 51822514Sdarrenr fflush(stdout); 51922514Sdarrenr PAUSE(); 52022514Sdarrenr 52122514Sdarrenr printf("2.2.5 option length = 0, SATID\n"); 52222514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SATID; 52322514Sdarrenr s[IPOPT_OLEN] = 0; 52422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 52522514Sdarrenr fflush(stdout); 52622514Sdarrenr PAUSE(); 52722514Sdarrenr 52822514Sdarrenr printf("2.2.6 option length = 0, SSRR\n"); 52922514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SSRR; 53022514Sdarrenr s[IPOPT_OLEN] = 0; 53122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 53222514Sdarrenr fflush(stdout); 53322514Sdarrenr PAUSE(); 53422514Sdarrenr } 53522514Sdarrenr 53622514Sdarrenr (void) close(nfd); 53722514Sdarrenr} 53822514Sdarrenr 53922514Sdarrenr 54022514Sdarrenr/* 54122514Sdarrenr * test 3 (ICMP) 54222514Sdarrenr */ 54322514Sdarrenrvoid ip_test3(dev, mtu, ip, gwip, ptest) 54422514Sdarrenrchar *dev; 54522514Sdarrenrint mtu; 54622514Sdarrenrip_t *ip; 54722514Sdarrenrstruct in_addr gwip; 54822514Sdarrenrint ptest; 54922514Sdarrenr{ 55022514Sdarrenr static int ict1[10] = { 8, 9, 10, 13, 14, 15, 16, 17, 18, 0 }; 55122514Sdarrenr static int ict2[8] = { 3, 9, 10, 13, 14, 17, 18, 0 }; 552110920Sdarrenr#ifdef USE_NANOSLEEP 553110920Sdarrenr struct timespec ts; 554110920Sdarrenr#else 55522514Sdarrenr struct timeval tv; 556110920Sdarrenr#endif 55722514Sdarrenr struct icmp *icp; 55822514Sdarrenr int nfd, i; 55922514Sdarrenr 56022514Sdarrenr ip->ip_hl = sizeof(*ip) >> 2; 56122514Sdarrenr ip->ip_v = IPVERSION; 56222514Sdarrenr ip->ip_tos = 0; 56322514Sdarrenr ip->ip_off = 0; 56422514Sdarrenr ip->ip_ttl = 60; 56522514Sdarrenr ip->ip_p = IPPROTO_ICMP; 56622514Sdarrenr ip->ip_sum = 0; 56722514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp); 56822514Sdarrenr icp = (struct icmp *)((char *)ip + (ip->ip_hl << 2)); 56937074Speter nfd = initdevice(dev, htons(1), 1); 57022514Sdarrenr 57122514Sdarrenr if (!ptest || (ptest == 1)) { 57222514Sdarrenr /* 57322514Sdarrenr * Type 0 - 31, 255, code = 0 57422514Sdarrenr */ 57522514Sdarrenr bzero((char *)icp, sizeof(*icp)); 57622514Sdarrenr for (i = 0; i < 32; i++) { 57722514Sdarrenr icp->icmp_type = i; 57822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 57922514Sdarrenr PAUSE(); 58022514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, i); 58122514Sdarrenr } 58222514Sdarrenr icp->icmp_type = 255; 58322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 58422514Sdarrenr PAUSE(); 58522514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, 255); 58622514Sdarrenr putchar('\n'); 58722514Sdarrenr } 58822514Sdarrenr 58922514Sdarrenr if (!ptest || (ptest == 2)) { 59022514Sdarrenr /* 59122514Sdarrenr * Type 3, code = 0 - 31 59222514Sdarrenr */ 59322514Sdarrenr icp->icmp_type = 3; 59422514Sdarrenr for (i = 0; i < 32; i++) { 59522514Sdarrenr icp->icmp_code = i; 59622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 59722514Sdarrenr PAUSE(); 59822514Sdarrenr printf("3.2.%d ICMP type 3 code %d (all 0's)\r", i, i); 59922514Sdarrenr } 60022514Sdarrenr } 60122514Sdarrenr 60222514Sdarrenr if (!ptest || (ptest == 3)) { 60322514Sdarrenr /* 60422514Sdarrenr * Type 4, code = 0,127,128,255 60522514Sdarrenr */ 60622514Sdarrenr icp->icmp_type = 4; 60722514Sdarrenr icp->icmp_code = 0; 60822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 60922514Sdarrenr PAUSE(); 61022514Sdarrenr printf("3.3.1 ICMP type 4 code 0 (all 0's)\r"); 61122514Sdarrenr icp->icmp_code = 127; 61222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 61322514Sdarrenr PAUSE(); 61422514Sdarrenr printf("3.3.2 ICMP type 4 code 127 (all 0's)\r"); 61522514Sdarrenr icp->icmp_code = 128; 61622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 61722514Sdarrenr PAUSE(); 61822514Sdarrenr printf("3.3.3 ICMP type 4 code 128 (all 0's)\r"); 61922514Sdarrenr icp->icmp_code = 255; 62022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 62122514Sdarrenr PAUSE(); 62222514Sdarrenr printf("3.3.4 ICMP type 4 code 255 (all 0's)\r"); 62322514Sdarrenr } 62422514Sdarrenr 62522514Sdarrenr if (!ptest || (ptest == 4)) { 62622514Sdarrenr /* 62722514Sdarrenr * Type 5, code = 0,127,128,255 62822514Sdarrenr */ 62922514Sdarrenr icp->icmp_type = 5; 63022514Sdarrenr icp->icmp_code = 0; 63122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 63222514Sdarrenr PAUSE(); 63322514Sdarrenr printf("3.4.1 ICMP type 5 code 0 (all 0's)\r"); 63422514Sdarrenr icp->icmp_code = 127; 63522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 63622514Sdarrenr PAUSE(); 63722514Sdarrenr printf("3.4.2 ICMP type 5 code 127 (all 0's)\r"); 63822514Sdarrenr icp->icmp_code = 128; 63922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64022514Sdarrenr PAUSE(); 64122514Sdarrenr printf("3.4.3 ICMP type 5 code 128 (all 0's)\r"); 64222514Sdarrenr icp->icmp_code = 255; 64322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64422514Sdarrenr PAUSE(); 64522514Sdarrenr printf("3.4.4 ICMP type 5 code 255 (all 0's)\r"); 64622514Sdarrenr } 64722514Sdarrenr 64822514Sdarrenr if (!ptest || (ptest == 5)) { 64922514Sdarrenr /* 65022514Sdarrenr * Type 8-10;13-18, code - 0,127,128,255 65122514Sdarrenr */ 65222514Sdarrenr for (i = 0; ict1[i]; i++) { 65322514Sdarrenr icp->icmp_type = ict1[i]; 65422514Sdarrenr icp->icmp_code = 0; 65522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 65622514Sdarrenr PAUSE(); 65722514Sdarrenr printf("3.5.%d ICMP type 5 code 0 (all 0's)\r", 65822514Sdarrenr i * 4); 65922514Sdarrenr icp->icmp_code = 127; 66022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66122514Sdarrenr PAUSE(); 66222514Sdarrenr printf("3.5.%d ICMP type 5 code 127 (all 0's)\r", 66322514Sdarrenr i * 4 + 1); 66422514Sdarrenr icp->icmp_code = 128; 66522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66622514Sdarrenr PAUSE(); 66722514Sdarrenr printf("3.5.%d ICMP type 5 code 128 (all 0's)\r", 66822514Sdarrenr i * 4 + 2); 66922514Sdarrenr icp->icmp_code = 255; 67022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 67122514Sdarrenr PAUSE(); 67222514Sdarrenr printf("3.5.%d ICMP type 5 code 255 (all 0's)\r", 67322514Sdarrenr i * 4 + 3); 67422514Sdarrenr } 67522514Sdarrenr putchar('\n'); 67622514Sdarrenr } 67722514Sdarrenr 67822514Sdarrenr if (!ptest || (ptest == 6)) { 67922514Sdarrenr /* 68022514Sdarrenr * Type 12, code - 0,127,128,129,255 68122514Sdarrenr */ 68222514Sdarrenr icp->icmp_type = 12; 68322514Sdarrenr icp->icmp_code = 0; 68422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 68522514Sdarrenr PAUSE(); 68622514Sdarrenr printf("3.6.1 ICMP type 12 code 0 (all 0's)\r"); 68722514Sdarrenr icp->icmp_code = 127; 68822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 68922514Sdarrenr PAUSE(); 69022514Sdarrenr printf("3.6.2 ICMP type 12 code 127 (all 0's)\r"); 69122514Sdarrenr icp->icmp_code = 128; 69222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69322514Sdarrenr PAUSE(); 69422514Sdarrenr printf("3.6.3 ICMP type 12 code 128 (all 0's)\r"); 69522514Sdarrenr icp->icmp_code = 129; 69622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69722514Sdarrenr PAUSE(); 69822514Sdarrenr printf("3.6.4 ICMP type 12 code 129 (all 0's)\r"); 69922514Sdarrenr icp->icmp_code = 255; 70022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 70122514Sdarrenr PAUSE(); 70222514Sdarrenr printf("3.6.5 ICMP type 12 code 255 (all 0's)\r"); 70322514Sdarrenr putchar('\n'); 70422514Sdarrenr } 70522514Sdarrenr 70622514Sdarrenr if (!ptest || (ptest == 7)) { 70722514Sdarrenr /* 70822514Sdarrenr * Type 3;9-10;13-14;17-18 - shorter packets 70922514Sdarrenr */ 71022514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp) / 2; 71122514Sdarrenr for (i = 0; ict2[i]; i++) { 71222514Sdarrenr icp->icmp_type = ict1[i]; 71322514Sdarrenr icp->icmp_code = 0; 71422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 71522514Sdarrenr PAUSE(); 71622514Sdarrenr printf("3.5.%d ICMP type %d code 0 (all 0's)\r", 71722514Sdarrenr i * 4, icp->icmp_type); 71822514Sdarrenr icp->icmp_code = 127; 71922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72022514Sdarrenr PAUSE(); 72122514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 72222514Sdarrenr i * 4 + 1, icp->icmp_type); 72322514Sdarrenr icp->icmp_code = 128; 72422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72522514Sdarrenr PAUSE(); 72622514Sdarrenr printf("3.5.%d ICMP type %d code 128 (all 0's)\r", 72722514Sdarrenr i * 4 + 2, icp->icmp_type); 72822514Sdarrenr icp->icmp_code = 255; 72922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 73022514Sdarrenr PAUSE(); 73122514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 73222514Sdarrenr i * 4 + 3, icp->icmp_type); 73322514Sdarrenr } 73422514Sdarrenr putchar('\n'); 73522514Sdarrenr } 73622514Sdarrenr} 73722514Sdarrenr 73822514Sdarrenr 73922514Sdarrenr/* Perform test 4 (UDP) */ 74022514Sdarrenr 74122514Sdarrenrvoid ip_test4(dev, mtu, ip, gwip, ptest) 74222514Sdarrenrchar *dev; 74322514Sdarrenrint mtu; 74422514Sdarrenrip_t *ip; 74522514Sdarrenrstruct in_addr gwip; 74622514Sdarrenrint ptest; 74722514Sdarrenr{ 748110920Sdarrenr#ifdef USE_NANOSLEEP 749110920Sdarrenr struct timespec ts; 750110920Sdarrenr#else 75122514Sdarrenr struct timeval tv; 752110920Sdarrenr#endif 75331183Speter udphdr_t *u; 75422514Sdarrenr int nfd, i; 75522514Sdarrenr 75622514Sdarrenr 75722514Sdarrenr ip->ip_hl = sizeof(*ip) >> 2; 75822514Sdarrenr ip->ip_v = IPVERSION; 75922514Sdarrenr ip->ip_tos = 0; 76022514Sdarrenr ip->ip_off = 0; 76122514Sdarrenr ip->ip_ttl = 60; 76222514Sdarrenr ip->ip_p = IPPROTO_UDP; 76322514Sdarrenr ip->ip_sum = 0; 76422514Sdarrenr u = (udphdr_t *)((char *)ip + (ip->ip_hl << 2)); 76537074Speter u->uh_sport = htons(1); 76637074Speter u->uh_dport = htons(1); 76737074Speter u->uh_ulen = htons(sizeof(*u) + 4); 76822514Sdarrenr nfd = initdevice(dev, u->uh_sport, 1); 76922514Sdarrenr 77022514Sdarrenr if (!ptest || (ptest == 1)) { 77122514Sdarrenr /* 77222514Sdarrenr * Test 1. ulen > packet 77322514Sdarrenr */ 77437074Speter u->uh_ulen = htons(sizeof(*u) + 4); 77537074Speter ip->ip_len = (ip->ip_hl << 2) + ntohs(u->uh_ulen); 77622514Sdarrenr printf("4.1 UDP uh_ulen > packet size - short packets\n"); 77737074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 77837074Speter u->uh_ulen = htons(i); 77922514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 78022514Sdarrenr printf("%d\r", i); 78122514Sdarrenr fflush(stdout); 78222514Sdarrenr PAUSE(); 78322514Sdarrenr } 78422514Sdarrenr putchar('\n'); 78522514Sdarrenr } 78622514Sdarrenr 78722514Sdarrenr if (!ptest || (ptest == 2)) { 78822514Sdarrenr /* 78922514Sdarrenr * Test 2. ulen < packet 79022514Sdarrenr */ 79137074Speter u->uh_ulen = htons(sizeof(*u) + 4); 79237074Speter ip->ip_len = (ip->ip_hl << 2) + ntohs(u->uh_ulen); 79322514Sdarrenr printf("4.2 UDP uh_ulen < packet size - short packets\n"); 79437074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 79522514Sdarrenr ip->ip_len = i; 79622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 79722514Sdarrenr printf("%d\r", i); 79822514Sdarrenr fflush(stdout); 79922514Sdarrenr PAUSE(); 80022514Sdarrenr } 80122514Sdarrenr putchar('\n'); 80222514Sdarrenr } 80322514Sdarrenr 80422514Sdarrenr if (!ptest || (ptest == 3)) { 80522514Sdarrenr /* 80622514Sdarrenr * Test 3: sport = 0, sport = 1, sport = 32767 80722514Sdarrenr * sport = 32768, sport = 65535 80822514Sdarrenr */ 80922514Sdarrenr u->uh_ulen = sizeof(*u) + 4; 81037074Speter ip->ip_len = (ip->ip_hl << 2) + ntohs(u->uh_ulen); 81122514Sdarrenr printf("4.3.1 UDP sport = 0\n"); 81222514Sdarrenr u->uh_sport = 0; 81322514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 81422514Sdarrenr printf("0\n"); 81522514Sdarrenr fflush(stdout); 81622514Sdarrenr PAUSE(); 81722514Sdarrenr printf("4.3.2 UDP sport = 1\n"); 81837074Speter u->uh_sport = htons(1); 81922514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 82022514Sdarrenr printf("1\n"); 82122514Sdarrenr fflush(stdout); 82222514Sdarrenr PAUSE(); 82322514Sdarrenr printf("4.3.3 UDP sport = 32767\n"); 82437074Speter u->uh_sport = htons(32767); 82522514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 82622514Sdarrenr printf("32767\n"); 82722514Sdarrenr fflush(stdout); 82822514Sdarrenr PAUSE(); 82922514Sdarrenr printf("4.3.4 UDP sport = 32768\n"); 83037074Speter u->uh_sport = htons(32768); 83122514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 83222514Sdarrenr printf("32768\n"); 83322514Sdarrenr putchar('\n'); 83422514Sdarrenr fflush(stdout); 83522514Sdarrenr PAUSE(); 83622514Sdarrenr printf("4.3.5 UDP sport = 65535\n"); 83737074Speter u->uh_sport = htons(65535); 83822514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 83922514Sdarrenr printf("65535\n"); 84022514Sdarrenr fflush(stdout); 84122514Sdarrenr PAUSE(); 84222514Sdarrenr } 84322514Sdarrenr 84422514Sdarrenr if (!ptest || (ptest == 4)) { 84522514Sdarrenr /* 84622514Sdarrenr * Test 4: dport = 0, dport = 1, dport = 32767 84722514Sdarrenr * dport = 32768, dport = 65535 84822514Sdarrenr */ 84937074Speter u->uh_ulen = ntohs(sizeof(*u) + 4); 85037074Speter u->uh_sport = htons(1); 85137074Speter ip->ip_len = (ip->ip_hl << 2) + ntohs(u->uh_ulen); 85222514Sdarrenr printf("4.4.1 UDP dport = 0\n"); 85322514Sdarrenr u->uh_dport = 0; 85422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 85522514Sdarrenr printf("0\n"); 85622514Sdarrenr fflush(stdout); 85722514Sdarrenr PAUSE(); 85822514Sdarrenr printf("4.4.2 UDP dport = 1\n"); 85937074Speter u->uh_dport = htons(1); 86022514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86122514Sdarrenr printf("1\n"); 86222514Sdarrenr fflush(stdout); 86322514Sdarrenr PAUSE(); 86422514Sdarrenr printf("4.4.3 UDP dport = 32767\n"); 86537074Speter u->uh_dport = htons(32767); 86622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86722514Sdarrenr printf("32767\n"); 86822514Sdarrenr fflush(stdout); 86922514Sdarrenr PAUSE(); 87022514Sdarrenr printf("4.4.4 UDP dport = 32768\n"); 87137074Speter u->uh_dport = htons(32768); 87222514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 87322514Sdarrenr printf("32768\n"); 87422514Sdarrenr fflush(stdout); 87522514Sdarrenr PAUSE(); 87622514Sdarrenr printf("4.4.5 UDP dport = 65535\n"); 87737074Speter u->uh_dport = htons(65535); 87822514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 87922514Sdarrenr printf("65535\n"); 88022514Sdarrenr fflush(stdout); 88122514Sdarrenr PAUSE(); 88222514Sdarrenr } 88322514Sdarrenr 88431183Speter if (!ptest || (ptest == 5)) { 88522514Sdarrenr /* 88631183Speter * Test 5: sizeof(ip_t) <= MTU <= sizeof(udphdr_t) + 88731183Speter * sizeof(ip_t) 88822514Sdarrenr */ 88922514Sdarrenr printf("4.5 UDP 20 <= MTU <= 32\n"); 89037074Speter for (i = sizeof(*ip); i <= ntohs(u->uh_ulen); i++) { 89122514Sdarrenr (void) send_udp(nfd, i, ip, gwip); 89222514Sdarrenr printf("%d\r", i); 89322514Sdarrenr fflush(stdout); 89422514Sdarrenr PAUSE(); 89522514Sdarrenr } 89622514Sdarrenr putchar('\n'); 89722514Sdarrenr } 89822514Sdarrenr} 89922514Sdarrenr 90022514Sdarrenr 90122514Sdarrenr/* Perform test 5 (TCP) */ 90222514Sdarrenr 90322514Sdarrenrvoid ip_test5(dev, mtu, ip, gwip, ptest) 90422514Sdarrenrchar *dev; 90522514Sdarrenrint mtu; 90622514Sdarrenrip_t *ip; 90722514Sdarrenrstruct in_addr gwip; 90822514Sdarrenrint ptest; 90922514Sdarrenr{ 910110920Sdarrenr#ifdef USE_NANOSLEEP 911110920Sdarrenr struct timespec ts; 912110920Sdarrenr#else 91322514Sdarrenr struct timeval tv; 914110920Sdarrenr#endif 91522514Sdarrenr tcphdr_t *t; 91622514Sdarrenr int nfd, i; 91722514Sdarrenr 91822514Sdarrenr t = (tcphdr_t *)((char *)ip + (ip->ip_hl << 2)); 91931183Speter#ifndef linux 92022514Sdarrenr t->th_x2 = 0; 92131183Speter#endif 92222514Sdarrenr t->th_off = 0; 92337074Speter t->th_sport = htons(1); 92437074Speter t->th_dport = htons(1); 92537074Speter t->th_win = htons(4096); 92622514Sdarrenr t->th_urp = 0; 92722514Sdarrenr t->th_sum = 0; 92837074Speter t->th_seq = htonl(1); 92922514Sdarrenr t->th_ack = 0; 93034739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 93122514Sdarrenr nfd = initdevice(dev, t->th_sport, 1); 93222514Sdarrenr 93322514Sdarrenr if (!ptest || (ptest == 1)) { 93422514Sdarrenr /* 93522514Sdarrenr * Test 1: flags variations, 0 - 3f 93622514Sdarrenr */ 93722514Sdarrenr t->th_off = sizeof(*t) >> 2; 93822514Sdarrenr printf("5.1 Test TCP flag combinations\n"); 93922514Sdarrenr for (i = 0; i <= (TH_URG|TH_ACK|TH_PUSH|TH_RST|TH_SYN|TH_FIN); 94022514Sdarrenr i++) { 94122514Sdarrenr t->th_flags = i; 94222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 94322514Sdarrenr printf("%d\r", i); 94422514Sdarrenr fflush(stdout); 94522514Sdarrenr PAUSE(); 94622514Sdarrenr } 94722514Sdarrenr putchar('\n'); 94822514Sdarrenr } 94922514Sdarrenr 95022514Sdarrenr if (!ptest || (ptest == 2)) { 95122514Sdarrenr t->th_flags = TH_SYN; 95222514Sdarrenr /* 95322514Sdarrenr * Test 2: seq = 0, seq = 1, seq = 0x7fffffff, seq=0x80000000, 95422514Sdarrenr * seq = 0xa000000, seq = 0xffffffff 95522514Sdarrenr */ 95622514Sdarrenr printf("5.2.1 TCP seq = 0\n"); 95737074Speter t->th_seq = htonl(0); 95822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 95922514Sdarrenr fflush(stdout); 96022514Sdarrenr PAUSE(); 96122514Sdarrenr 96222514Sdarrenr printf("5.2.2 TCP seq = 1\n"); 96337074Speter t->th_seq = htonl(1); 96422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 96522514Sdarrenr fflush(stdout); 96622514Sdarrenr PAUSE(); 96722514Sdarrenr 96822514Sdarrenr printf("5.2.3 TCP seq = 0x7fffffff\n"); 96937074Speter t->th_seq = htonl(0x7fffffff); 97022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 97122514Sdarrenr fflush(stdout); 97222514Sdarrenr PAUSE(); 97322514Sdarrenr 97422514Sdarrenr printf("5.2.4 TCP seq = 0x80000000\n"); 97537074Speter t->th_seq = htonl(0x80000000); 97622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 97722514Sdarrenr fflush(stdout); 97822514Sdarrenr PAUSE(); 97922514Sdarrenr 98022514Sdarrenr printf("5.2.5 TCP seq = 0xc0000000\n"); 98137074Speter t->th_seq = htonl(0xc0000000); 98222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 98322514Sdarrenr fflush(stdout); 98422514Sdarrenr PAUSE(); 98522514Sdarrenr 98622514Sdarrenr printf("5.2.6 TCP seq = 0xffffffff\n"); 98737074Speter t->th_seq = htonl(0xffffffff); 98822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 98922514Sdarrenr fflush(stdout); 99022514Sdarrenr PAUSE(); 99122514Sdarrenr } 99222514Sdarrenr 99322514Sdarrenr if (!ptest || (ptest == 3)) { 99422514Sdarrenr t->th_flags = TH_ACK; 99522514Sdarrenr /* 99622514Sdarrenr * Test 3: ack = 0, ack = 1, ack = 0x7fffffff, ack = 0x8000000 99722514Sdarrenr * ack = 0xa000000, ack = 0xffffffff 99822514Sdarrenr */ 99922514Sdarrenr printf("5.3.1 TCP ack = 0\n"); 100022514Sdarrenr t->th_ack = 0; 100122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 100222514Sdarrenr fflush(stdout); 100322514Sdarrenr PAUSE(); 100422514Sdarrenr 100522514Sdarrenr printf("5.3.2 TCP ack = 1\n"); 100637074Speter t->th_ack = htonl(1); 100722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 100822514Sdarrenr fflush(stdout); 100922514Sdarrenr PAUSE(); 101022514Sdarrenr 101122514Sdarrenr printf("5.3.3 TCP ack = 0x7fffffff\n"); 101237074Speter t->th_ack = htonl(0x7fffffff); 101322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 101422514Sdarrenr fflush(stdout); 101522514Sdarrenr PAUSE(); 101622514Sdarrenr 101722514Sdarrenr printf("5.3.4 TCP ack = 0x80000000\n"); 101837074Speter t->th_ack = htonl(0x80000000); 101922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102022514Sdarrenr fflush(stdout); 102122514Sdarrenr PAUSE(); 102222514Sdarrenr 102322514Sdarrenr printf("5.3.5 TCP ack = 0xc0000000\n"); 102437074Speter t->th_ack = htonl(0xc0000000); 102522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102622514Sdarrenr fflush(stdout); 102722514Sdarrenr PAUSE(); 102822514Sdarrenr 102922514Sdarrenr printf("5.3.6 TCP ack = 0xffffffff\n"); 103037074Speter t->th_ack = htonl(0xffffffff); 103122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 103222514Sdarrenr fflush(stdout); 103322514Sdarrenr PAUSE(); 103422514Sdarrenr } 103522514Sdarrenr 103622514Sdarrenr if (!ptest || (ptest == 4)) { 103722514Sdarrenr t->th_flags = TH_SYN; 103822514Sdarrenr /* 103922514Sdarrenr * Test 4: win = 0, win = 32768, win = 65535 104022514Sdarrenr */ 104122514Sdarrenr printf("5.4.1 TCP win = 0\n"); 104237074Speter t->th_seq = htonl(0); 104322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 104422514Sdarrenr fflush(stdout); 104522514Sdarrenr PAUSE(); 104622514Sdarrenr 104722514Sdarrenr printf("5.4.2 TCP win = 32768\n"); 104837074Speter t->th_seq = htonl(0x7fff); 104922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105022514Sdarrenr fflush(stdout); 105122514Sdarrenr PAUSE(); 105222514Sdarrenr 105322514Sdarrenr printf("5.4.3 TCP win = 65535\n"); 105437074Speter t->th_win = htons(0xffff); 105522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105622514Sdarrenr fflush(stdout); 105722514Sdarrenr PAUSE(); 105822514Sdarrenr } 105922514Sdarrenr 106034739Speter#if !defined(linux) && !defined(__SVR4) && !defined(__svr4__) && \ 106134739Speter !defined(__sgi) 106222514Sdarrenr { 106334739Speter struct tcpcb *tcbp, tcb; 106422514Sdarrenr struct tcpiphdr ti; 106522514Sdarrenr struct sockaddr_in sin; 106622514Sdarrenr int fd, slen; 106722514Sdarrenr 106892691Sdarrenr fd = -1; 106922514Sdarrenr bzero((char *)&sin, sizeof(sin)); 107022514Sdarrenr 107122514Sdarrenr for (i = 1; i < 63; i++) { 107222514Sdarrenr fd = socket(AF_INET, SOCK_STREAM, 0); 107334739Speter bzero((char *)&sin, sizeof(sin)); 107422514Sdarrenr sin.sin_addr.s_addr = ip->ip_dst.s_addr; 107522514Sdarrenr sin.sin_port = htons(i); 107634739Speter sin.sin_family = AF_INET; 107722514Sdarrenr if (!connect(fd, (struct sockaddr *)&sin, sizeof(sin))) 107822514Sdarrenr break; 107934739Speter close(fd); 108022514Sdarrenr } 108122514Sdarrenr 108222514Sdarrenr if (i == 63) { 108322514Sdarrenr printf("Couldn't open a TCP socket between ports 1 and 63\n"); 108422514Sdarrenr printf("to host %s for test 5 and 6 - skipping.\n", 108522514Sdarrenr inet_ntoa(ip->ip_dst)); 108622514Sdarrenr goto skip_five_and_six; 108722514Sdarrenr } 108822514Sdarrenr 108922514Sdarrenr bcopy((char *)ip, (char *)&ti, sizeof(*ip)); 109034739Speter t->th_dport = htons(i); 109122514Sdarrenr slen = sizeof(sin); 109222514Sdarrenr if (!getsockname(fd, (struct sockaddr *)&sin, &slen)) 109334739Speter t->th_sport = sin.sin_port; 109434739Speter if (!(tcbp = find_tcp(fd, &ti))) { 109522514Sdarrenr printf("Can't find PCB\n"); 109622514Sdarrenr goto skip_five_and_six; 109722514Sdarrenr } 109834739Speter KMCPY(&tcb, tcbp, sizeof(tcb)); 109922514Sdarrenr ti.ti_win = tcb.rcv_adv; 110037074Speter ti.ti_seq = htonl(tcb.snd_nxt - 1); 110122514Sdarrenr ti.ti_ack = tcb.rcv_nxt; 110222514Sdarrenr 110322514Sdarrenr if (!ptest || (ptest == 5)) { 110422514Sdarrenr /* 110522514Sdarrenr * Test 5: urp 110622514Sdarrenr */ 110734739Speter t->th_flags = TH_ACK|TH_URG; 110834739Speter printf("5.5.1 TCP Urgent pointer, sport %hu dport %hu\n", 110934739Speter ntohs(t->th_sport), ntohs(t->th_dport)); 111034739Speter t->th_urp = htons(1); 111122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 111222514Sdarrenr PAUSE(); 111334739Speter 111437074Speter t->th_seq = htonl(tcb.snd_nxt); 111534739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t) + 1; 111634739Speter t->th_urp = htons(0x7fff); 111722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 111822514Sdarrenr PAUSE(); 111934739Speter t->th_urp = htons(0x8000); 112022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 112122514Sdarrenr PAUSE(); 112234739Speter t->th_urp = htons(0xffff); 112322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 112422514Sdarrenr PAUSE(); 112537074Speter t->th_urp = 0; 112634739Speter t->th_flags &= ~TH_URG; 112734739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 112822514Sdarrenr } 112922514Sdarrenr 113022514Sdarrenr if (!ptest || (ptest == 6)) { 113122514Sdarrenr /* 113222514Sdarrenr * Test 6: data offset, off = 0, off is inside, off is outside 113322514Sdarrenr */ 113434739Speter t->th_flags = TH_ACK; 113534739Speter printf("5.6.1 TCP off = 1-15, len = 40\n"); 113634739Speter for (i = 1; i < 16; i++) { 113722514Sdarrenr ti.ti_off = ntohs(i); 113822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 113922514Sdarrenr printf("%d\r", i); 114022514Sdarrenr fflush(stdout); 114122514Sdarrenr PAUSE(); 114222514Sdarrenr } 114322514Sdarrenr putchar('\n'); 114434739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 114522514Sdarrenr } 114622514Sdarrenr 114722514Sdarrenr (void) close(fd); 114822514Sdarrenr } 114922514Sdarrenrskip_five_and_six: 115022514Sdarrenr#endif 115137074Speter t->th_seq = htonl(1); 115237074Speter t->th_ack = htonl(1); 115334739Speter t->th_off = 0; 115422514Sdarrenr 115522514Sdarrenr if (!ptest || (ptest == 7)) { 115622514Sdarrenr t->th_flags = TH_SYN; 115722514Sdarrenr /* 115822514Sdarrenr * Test 7: sport = 0, sport = 1, sport = 32767 115922514Sdarrenr * sport = 32768, sport = 65535 116022514Sdarrenr */ 116122514Sdarrenr printf("5.7.1 TCP sport = 0\n"); 116222514Sdarrenr t->th_sport = 0; 116322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 116422514Sdarrenr fflush(stdout); 116522514Sdarrenr PAUSE(); 116622514Sdarrenr 116722514Sdarrenr printf("5.7.2 TCP sport = 1\n"); 116837074Speter t->th_sport = htons(1); 116922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 117022514Sdarrenr fflush(stdout); 117122514Sdarrenr PAUSE(); 117222514Sdarrenr 117322514Sdarrenr printf("5.7.3 TCP sport = 32767\n"); 117437074Speter t->th_sport = htons(32767); 117522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 117622514Sdarrenr fflush(stdout); 117722514Sdarrenr PAUSE(); 117822514Sdarrenr 117922514Sdarrenr printf("5.7.4 TCP sport = 32768\n"); 118037074Speter t->th_sport = htons(32768); 118122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 118222514Sdarrenr fflush(stdout); 118322514Sdarrenr PAUSE(); 118422514Sdarrenr 118522514Sdarrenr printf("5.7.5 TCP sport = 65535\n"); 118637074Speter t->th_sport = htons(65535); 118722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 118822514Sdarrenr fflush(stdout); 118922514Sdarrenr PAUSE(); 119022514Sdarrenr } 119122514Sdarrenr 119222514Sdarrenr if (!ptest || (ptest == 8)) { 119337074Speter t->th_sport = htons(1); 119434739Speter t->th_flags = TH_SYN; 119522514Sdarrenr /* 119622514Sdarrenr * Test 8: dport = 0, dport = 1, dport = 32767 119722514Sdarrenr * dport = 32768, dport = 65535 119822514Sdarrenr */ 119922514Sdarrenr printf("5.8.1 TCP dport = 0\n"); 120022514Sdarrenr t->th_dport = 0; 120122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120222514Sdarrenr fflush(stdout); 120322514Sdarrenr PAUSE(); 120422514Sdarrenr 120522514Sdarrenr printf("5.8.2 TCP dport = 1\n"); 120637074Speter t->th_dport = htons(1); 120722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120822514Sdarrenr fflush(stdout); 120922514Sdarrenr PAUSE(); 121022514Sdarrenr 121122514Sdarrenr printf("5.8.3 TCP dport = 32767\n"); 121237074Speter t->th_dport = htons(32767); 121322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 121422514Sdarrenr fflush(stdout); 121522514Sdarrenr PAUSE(); 121622514Sdarrenr 121722514Sdarrenr printf("5.8.4 TCP dport = 32768\n"); 121837074Speter t->th_dport = htons(32768); 121922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 122022514Sdarrenr fflush(stdout); 122122514Sdarrenr PAUSE(); 122222514Sdarrenr 122322514Sdarrenr printf("5.8.5 TCP dport = 65535\n"); 122437074Speter t->th_dport = htons(65535); 122522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 122622514Sdarrenr fflush(stdout); 122722514Sdarrenr PAUSE(); 122822514Sdarrenr } 122934739Speter 123034739Speter /* LAND attack - self connect, so make src & dst ip/port the same */ 123134739Speter if (!ptest || (ptest == 9)) { 123234739Speter printf("5.9 TCP LAND attack. sport = 25, dport = 25\n"); 123334739Speter /* chose SMTP port 25 */ 123434739Speter t->th_sport = htons(25); 123534739Speter t->th_dport = htons(25); 123634739Speter t->th_flags = TH_SYN; 123734739Speter ip->ip_src = ip->ip_dst; 123834739Speter (void) send_tcp(nfd, mtu, ip, gwip); 123934739Speter fflush(stdout); 124034739Speter PAUSE(); 124134739Speter } 124234739Speter 124322514Sdarrenr /* TCP options header checking */ 124422514Sdarrenr /* 0 length options, etc */ 124522514Sdarrenr} 124622514Sdarrenr 124722514Sdarrenr 124822514Sdarrenr/* Perform test 6 (exhaust mbuf test) */ 124922514Sdarrenr 125022514Sdarrenrvoid ip_test6(dev, mtu, ip, gwip, ptest) 125122514Sdarrenrchar *dev; 125222514Sdarrenrint mtu; 125322514Sdarrenrip_t *ip; 125422514Sdarrenrstruct in_addr gwip; 125522514Sdarrenrint ptest; 125622514Sdarrenr{ 1257110920Sdarrenr#ifdef USE_NANOSLEEP 1258110920Sdarrenr struct timespec ts; 1259110920Sdarrenr#else 126022514Sdarrenr struct timeval tv; 1261110920Sdarrenr#endif 126222514Sdarrenr udphdr_t *u; 126322514Sdarrenr int nfd, i, j, k; 126422514Sdarrenr 126522514Sdarrenr ip->ip_v = IPVERSION; 126622514Sdarrenr ip->ip_tos = 0; 126722514Sdarrenr ip->ip_off = 0; 126822514Sdarrenr ip->ip_ttl = 60; 126922514Sdarrenr ip->ip_p = IPPROTO_UDP; 127022514Sdarrenr ip->ip_sum = 0; 127122514Sdarrenr u = (udphdr_t *)(ip + 1); 127237074Speter u->uh_sport = htons(1); 127337074Speter u->uh_dport = htons(9); 127422514Sdarrenr u->uh_sum = 0; 127522514Sdarrenr 127622514Sdarrenr nfd = initdevice(dev, u->uh_sport, 1); 127737074Speter u->uh_ulen = htons(7168); 127822514Sdarrenr 127934739Speter printf("6. Exhaustive mbuf test.\n"); 128034739Speter printf(" Send 7k packet in 768 & 128 byte fragments, 128 times.\n"); 128134739Speter printf(" Total of around 8,900 packets\n"); 128222514Sdarrenr for (i = 0; i < 128; i++) { 128322514Sdarrenr /* 128422514Sdarrenr * First send the entire packet in 768 byte chunks. 128522514Sdarrenr */ 128622514Sdarrenr ip->ip_len = sizeof(*ip) + 768 + sizeof(*u); 128722514Sdarrenr ip->ip_hl = sizeof(*ip) >> 2; 128837074Speter ip->ip_off = htons(IP_MF); 128922514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 129022514Sdarrenr printf("%d %d\r", i, 0); 129122514Sdarrenr fflush(stdout); 129222514Sdarrenr PAUSE(); 129322514Sdarrenr /* 129422514Sdarrenr * And again using 128 byte chunks. 129522514Sdarrenr */ 129622514Sdarrenr ip->ip_len = sizeof(*ip) + 128 + sizeof(*u); 129737074Speter ip->ip_off = htons(IP_MF); 129822514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 129922514Sdarrenr printf("%d %d\r", i, 0); 130022514Sdarrenr fflush(stdout); 130122514Sdarrenr PAUSE(); 130222514Sdarrenr 130322514Sdarrenr for (j = 768; j < 3584; j += 768) { 130422514Sdarrenr ip->ip_len = sizeof(*ip) + 768; 130592691Sdarrenr ip->ip_off = htons(IP_MF|((j>>3) & 0x1fff)); 130622514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 130722514Sdarrenr printf("%d %d\r", i, j); 130822514Sdarrenr fflush(stdout); 130922514Sdarrenr PAUSE(); 131022514Sdarrenr 131122514Sdarrenr ip->ip_len = sizeof(*ip) + 128; 131222514Sdarrenr for (k = j - 768; k < j; k += 128) { 131392691Sdarrenr ip->ip_off = htons(IP_MF|((k>>3) & 0x1fff)); 131422514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 131522514Sdarrenr printf("%d %d\r", i, k); 131622514Sdarrenr fflush(stdout); 131722514Sdarrenr PAUSE(); 131822514Sdarrenr } 131922514Sdarrenr } 132022514Sdarrenr } 132122514Sdarrenr putchar('\n'); 132222514Sdarrenr} 132322514Sdarrenr 132422514Sdarrenr 132522514Sdarrenr/* Perform test 7 (random packets) */ 132622514Sdarrenr 132722514Sdarrenrstatic u_long tbuf[64]; 132822514Sdarrenr 132922514Sdarrenrvoid ip_test7(dev, mtu, ip, gwip, ptest) 133022514Sdarrenrchar *dev; 133122514Sdarrenrint mtu; 133222514Sdarrenrip_t *ip; 133322514Sdarrenrstruct in_addr gwip; 133422514Sdarrenrint ptest; 133522514Sdarrenr{ 1336110920Sdarrenr#ifdef USE_NANOSLEEP 1337110920Sdarrenr struct timespec ts; 1338110920Sdarrenr#else 1339110920Sdarrenr struct timeval tv; 1340110920Sdarrenr#endif 134122514Sdarrenr ip_t *pip; 134222514Sdarrenr int nfd, i, j; 134322514Sdarrenr u_char *s; 134422514Sdarrenr 134522514Sdarrenr nfd = initdevice(dev, 0, 1); 134622514Sdarrenr pip = (ip_t *)tbuf; 134722514Sdarrenr 134822514Sdarrenr srand(time(NULL) ^ (getpid() * getppid())); 134922514Sdarrenr 135022514Sdarrenr printf("7. send 1024 random IP packets.\n"); 135122514Sdarrenr 135222514Sdarrenr for (i = 0; i < 512; i++) { 135322514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 135422514Sdarrenr *s = (rand() >> 13) & 0xff; 135522514Sdarrenr pip->ip_v = IPVERSION; 135622514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 135722514Sdarrenr sizeof(struct in_addr)); 135822514Sdarrenr pip->ip_sum = 0; 135922514Sdarrenr pip->ip_len &= 0xff; 136022514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 136122514Sdarrenr printf("%d\r", i); 136222514Sdarrenr fflush(stdout); 136322514Sdarrenr PAUSE(); 136422514Sdarrenr } 136522514Sdarrenr putchar('\n'); 136622514Sdarrenr 136722514Sdarrenr for (i = 0; i < 512; i++) { 136822514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 136922514Sdarrenr *s = (rand() >> 13) & 0xff; 137022514Sdarrenr pip->ip_v = IPVERSION; 137137074Speter pip->ip_off &= htons(0xc000); 137222514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 137322514Sdarrenr sizeof(struct in_addr)); 137422514Sdarrenr pip->ip_sum = 0; 137522514Sdarrenr pip->ip_len &= 0xff; 137622514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 137722514Sdarrenr printf("%d\r", i); 137822514Sdarrenr fflush(stdout); 137922514Sdarrenr PAUSE(); 138022514Sdarrenr } 138122514Sdarrenr putchar('\n'); 138222514Sdarrenr} 1383