iptests.c revision 153881
1145519Sdarrenr/* $FreeBSD: head/contrib/ipfilter/ipsend/iptests.c 153881 2005-12-30 11:52:26Z 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"; 11153881Sguidostatic const char rcsid[] = "@(#)$Id: iptests.c,v 2.8.2.4 2005/06/12 07:18:39 darrenr Exp $"; 1292691Sdarrenr#endif 13145519Sdarrenr#include <sys/param.h> 1422514Sdarrenr#include <sys/types.h> 1522514Sdarrenr#include <sys/time.h> 16145519Sdarrenr#if !defined(__osf__) 17145519Sdarrenr# define _KERNEL 18145519Sdarrenr# define KERNEL 19145519Sdarrenr# if !defined(solaris) && !defined(linux) && !defined(__sgi) && !defined(hpux) 20145519Sdarrenr# include <sys/file.h> 21145519Sdarrenr# else 22145519Sdarrenr# ifdef solaris 23145519Sdarrenr# include <sys/dditypes.h> 24145519Sdarrenr# endif 2553024Sguido# endif 26145519Sdarrenr# undef _KERNEL 27145519Sdarrenr# undef KERNEL 2853024Sguido#endif 2953024Sguido#if !defined(solaris) && !defined(linux) && !defined(__sgi) 3022514Sdarrenr# include <nlist.h> 3122514Sdarrenr# include <sys/user.h> 3222514Sdarrenr# include <sys/proc.h> 3322514Sdarrenr#endif 34145519Sdarrenr#if !defined(ultrix) && !defined(hpux) && !defined(linux) && \ 35153881Sguido !defined(__sgi) && !defined(__osf__) && !defined(_AIX51) 3631183Speter# include <kvm.h> 3731183Speter#endif 3831183Speter#ifndef ultrix 3931183Speter# include <sys/socket.h> 4031183Speter#endif 4126119Sdarrenr#if defined(solaris) 4226119Sdarrenr# include <sys/stream.h> 4326119Sdarrenr#endif 4422514Sdarrenr#include <sys/socketvar.h> 4522514Sdarrenr#ifdef sun 4622514Sdarrenr#include <sys/systm.h> 4722514Sdarrenr#include <sys/session.h> 4822514Sdarrenr#endif 4922514Sdarrenr#if BSD >= 199103 5031183Speter# include <sys/sysctl.h> 5131183Speter# include <sys/filedesc.h> 5231183Speter# include <paths.h> 5322514Sdarrenr#endif 5422514Sdarrenr#include <netinet/in_systm.h> 5522514Sdarrenr#include <sys/socket.h> 56145519Sdarrenr#ifdef __hpux 57145519Sdarrenr# define _NET_ROUTE_INCLUDED 58145519Sdarrenr#endif 5922514Sdarrenr#include <net/if.h> 6031183Speter#if defined(linux) && (LINUX >= 0200) 6131183Speter# include <asm/atomic.h> 6231183Speter#endif 6331183Speter#if !defined(linux) 64145519Sdarrenr# if defined(__FreeBSD__) 65145519Sdarrenr# include "radix_ipf.h" 66145519Sdarrenr# endif 6731183Speter# include <net/route.h> 6831183Speter#else 6931183Speter# define __KERNEL__ /* because there's a macro not wrapped by this */ 7031183Speter# include <net/route.h> /* in this file :-/ */ 7131183Speter#endif 7222514Sdarrenr#include <netinet/in.h> 7322514Sdarrenr#include <arpa/inet.h> 7422514Sdarrenr#include <netinet/ip.h> 75145519Sdarrenr#if !defined(linux) 7631183Speter# include <netinet/ip_var.h> 77145519Sdarrenr# if !defined(__hpux) 78145519Sdarrenr# include <netinet/in_pcb.h> 79145519Sdarrenr# endif 8031183Speter#endif 8131183Speter#if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 8231183Speter# include <sys/sysmacros.h> 8331183Speter#endif 84145519Sdarrenr#include <stdio.h> 85145519Sdarrenr#include <unistd.h> 86145519Sdarrenr#include <stdlib.h> 87145519Sdarrenr#include <string.h> 88145519Sdarrenr#ifdef __hpux 89145519Sdarrenr# undef _NET_ROUTE_INCLUDED 90110920Sdarrenr#endif 9124583Sdarrenr#include "ipsend.h" 92145519Sdarrenr#if !defined(linux) && !defined(__hpux) 93145519Sdarrenr# include <netinet/tcp_timer.h> 94145519Sdarrenr# include <netinet/tcp_var.h> 9580490Sdarrenr#endif 96145519Sdarrenr#if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 106000000) 97145519Sdarrenr# define USE_NANOSLEEP 9884843Sbde#endif 9924583Sdarrenr 10080490Sdarrenr 101145519Sdarrenr#ifdef USE_NANOSLEEP 102145519Sdarrenr# define PAUSE() ts.tv_sec = 0; ts.tv_nsec = 10000000; \ 103110920Sdarrenr (void) nanosleep(&ts, NULL) 104110920Sdarrenr#else 105110920Sdarrenr# define PAUSE() tv.tv_sec = 0; tv.tv_usec = 10000; \ 106145519Sdarrenr (void) select(0, NULL, NULL, NULL, &tv) 107110920Sdarrenr#endif 10822514Sdarrenr 10922514Sdarrenr 11022514Sdarrenrvoid ip_test1(dev, mtu, ip, gwip, ptest) 11122514Sdarrenrchar *dev; 11222514Sdarrenrint mtu; 11322514Sdarrenrip_t *ip; 11422514Sdarrenrstruct in_addr gwip; 11522514Sdarrenrint ptest; 11622514Sdarrenr{ 117145519Sdarrenr#ifdef USE_NANOSLEEP 118110920Sdarrenr struct timespec ts; 119110920Sdarrenr#else 12022514Sdarrenr struct timeval tv; 121110920Sdarrenr#endif 12222514Sdarrenr udphdr_t *u; 12331183Speter int nfd, i = 0, len, id = getpid(); 12422514Sdarrenr 125145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 126145519Sdarrenr IP_V_A(ip, IPVERSION); 12722514Sdarrenr ip->ip_tos = 0; 12822514Sdarrenr ip->ip_off = 0; 12922514Sdarrenr ip->ip_ttl = 60; 13022514Sdarrenr ip->ip_p = IPPROTO_UDP; 13122514Sdarrenr ip->ip_sum = 0; 13222514Sdarrenr u = (udphdr_t *)(ip + 1); 13337074Speter u->uh_sport = htons(1); 13437074Speter u->uh_dport = htons(9); 13522514Sdarrenr u->uh_sum = 0; 13637074Speter u->uh_ulen = htons(sizeof(*u) + 4); 13737074Speter ip->ip_len = sizeof(*ip) + ntohs(u->uh_ulen); 13822514Sdarrenr len = ip->ip_len; 139145519Sdarrenr nfd = initdevice(dev, 1); 14022514Sdarrenr 14122514Sdarrenr if (!ptest || (ptest == 1)) { 14222514Sdarrenr /* 14322514Sdarrenr * Part1: hl < len 14422514Sdarrenr */ 14522514Sdarrenr ip->ip_id = 0; 14622514Sdarrenr printf("1.1. sending packets with ip_hl < ip_len\n"); 14737074Speter for (i = 0; i < ((sizeof(*ip) + ntohs(u->uh_ulen)) >> 2); i++) { 148145519Sdarrenr IP_HL_A(ip, i >> 2); 14922514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 15022514Sdarrenr printf("%d\r", i); 15122514Sdarrenr fflush(stdout); 15222514Sdarrenr PAUSE(); 15322514Sdarrenr } 15422514Sdarrenr putchar('\n'); 15522514Sdarrenr } 15622514Sdarrenr 15722514Sdarrenr if (!ptest || (ptest == 2)) { 15822514Sdarrenr /* 15922514Sdarrenr * Part2: hl > len 16022514Sdarrenr */ 16122514Sdarrenr ip->ip_id = 0; 16222514Sdarrenr printf("1.2. sending packets with ip_hl > ip_len\n"); 16337074Speter for (; i < ((sizeof(*ip) * 2 + ntohs(u->uh_ulen)) >> 2); i++) { 164145519Sdarrenr IP_HL_A(ip, i >> 2); 16522514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 16622514Sdarrenr printf("%d\r", i); 16722514Sdarrenr fflush(stdout); 16822514Sdarrenr PAUSE(); 16922514Sdarrenr } 17022514Sdarrenr putchar('\n'); 17122514Sdarrenr } 17222514Sdarrenr 17322514Sdarrenr if (!ptest || (ptest == 3)) { 17422514Sdarrenr /* 17522514Sdarrenr * Part3: v < 4 17622514Sdarrenr */ 17722514Sdarrenr ip->ip_id = 0; 17822514Sdarrenr printf("1.3. ip_v < 4\n"); 179145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 18022514Sdarrenr for (i = 0; i < 4; i++) { 181145519Sdarrenr IP_V_A(ip, i); 18222514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 18322514Sdarrenr printf("%d\r", i); 18422514Sdarrenr fflush(stdout); 18522514Sdarrenr PAUSE(); 18622514Sdarrenr } 18722514Sdarrenr putchar('\n'); 18822514Sdarrenr } 18922514Sdarrenr 19022514Sdarrenr if (!ptest || (ptest == 4)) { 19122514Sdarrenr /* 19222514Sdarrenr * Part4: v > 4 19322514Sdarrenr */ 19422514Sdarrenr ip->ip_id = 0; 19522514Sdarrenr printf("1.4. ip_v > 4\n"); 19622514Sdarrenr for (i = 5; i < 16; i++) { 197145519Sdarrenr IP_V_A(ip, i); 19822514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 19922514Sdarrenr printf("%d\r", i); 20022514Sdarrenr fflush(stdout); 20122514Sdarrenr PAUSE(); 20222514Sdarrenr } 20322514Sdarrenr putchar('\n'); 20422514Sdarrenr } 20522514Sdarrenr 20622514Sdarrenr if (!ptest || (ptest == 5)) { 20722514Sdarrenr /* 20822514Sdarrenr * Part5: len < packet 20922514Sdarrenr */ 21022514Sdarrenr ip->ip_id = 0; 211145519Sdarrenr IP_V_A(ip, IPVERSION); 21222514Sdarrenr i = ip->ip_len + 1; 21322514Sdarrenr printf("1.5.0 ip_len < packet size (size++, long packets)\n"); 21437074Speter for (; i < (ip->ip_len * 2); i++) { 21522514Sdarrenr ip->ip_id = htons(id++); 21622514Sdarrenr ip->ip_sum = 0; 217145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 21824583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 21922514Sdarrenr printf("%d\r", i); 22022514Sdarrenr fflush(stdout); 22122514Sdarrenr PAUSE(); 22222514Sdarrenr } 22322514Sdarrenr putchar('\n'); 22422514Sdarrenr printf("1.5.1 ip_len < packet size (ip_len-, short packets)\n"); 22522514Sdarrenr for (i = len; i > 0; i--) { 22622514Sdarrenr ip->ip_id = htons(id++); 22737074Speter ip->ip_len = i; 22822514Sdarrenr ip->ip_sum = 0; 229145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 23024583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 23122514Sdarrenr printf("%d\r", i); 23222514Sdarrenr fflush(stdout); 23322514Sdarrenr PAUSE(); 23422514Sdarrenr } 23522514Sdarrenr putchar('\n'); 23622514Sdarrenr } 23722514Sdarrenr 23822514Sdarrenr if (!ptest || (ptest == 6)) { 23922514Sdarrenr /* 24022514Sdarrenr * Part6: len > packet 24122514Sdarrenr */ 24222514Sdarrenr ip->ip_id = 0; 24322514Sdarrenr printf("1.6.0 ip_len > packet size (increase ip_len)\n"); 24422514Sdarrenr for (i = len + 1; i < (len * 2); i++) { 24522514Sdarrenr ip->ip_id = htons(id++); 24637074Speter ip->ip_len = i; 24722514Sdarrenr ip->ip_sum = 0; 248145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 24924583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 25022514Sdarrenr printf("%d\r", i); 25122514Sdarrenr fflush(stdout); 25222514Sdarrenr PAUSE(); 25322514Sdarrenr } 25422514Sdarrenr putchar('\n'); 25537074Speter ip->ip_len = len; 25622514Sdarrenr printf("1.6.1 ip_len > packet size (size--, short packets)\n"); 25722514Sdarrenr for (i = len; i > 0; i--) { 25822514Sdarrenr ip->ip_id = htons(id++); 25922514Sdarrenr ip->ip_sum = 0; 260145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 26124583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 26222514Sdarrenr printf("%d\r", i); 26322514Sdarrenr fflush(stdout); 26422514Sdarrenr PAUSE(); 26522514Sdarrenr } 26622514Sdarrenr putchar('\n'); 26722514Sdarrenr } 26822514Sdarrenr 26922514Sdarrenr if (!ptest || (ptest == 7)) { 27022514Sdarrenr /* 27122514Sdarrenr * Part7: 0 length fragment 27222514Sdarrenr */ 27322514Sdarrenr printf("1.7.0 Zero length fragments (ip_off = 0x2000)\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.1 Zero length fragments (ip_off = 0x3000)\n"); 28222514Sdarrenr ip->ip_id = 0; 28322514Sdarrenr ip->ip_len = sizeof(*ip); 28422514Sdarrenr ip->ip_off = htons(IP_MF); 28522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 28622514Sdarrenr fflush(stdout); 28722514Sdarrenr PAUSE(); 28822514Sdarrenr 28922514Sdarrenr printf("1.7.2 Zero length fragments (ip_off = 0xa000)\n"); 29022514Sdarrenr ip->ip_id = 0; 29122514Sdarrenr ip->ip_len = sizeof(*ip); 29222514Sdarrenr ip->ip_off = htons(0xa000); 29322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 29422514Sdarrenr fflush(stdout); 29522514Sdarrenr PAUSE(); 29622514Sdarrenr 29722514Sdarrenr printf("1.7.3 Zero length fragments (ip_off = 0x0100)\n"); 29822514Sdarrenr ip->ip_id = 0; 29922514Sdarrenr ip->ip_len = sizeof(*ip); 30022514Sdarrenr ip->ip_off = htons(0x0100); 30122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 30222514Sdarrenr fflush(stdout); 30322514Sdarrenr PAUSE(); 30422514Sdarrenr } 30522514Sdarrenr 30622514Sdarrenr if (!ptest || (ptest == 8)) { 30722514Sdarrenr struct timeval tv; 30822514Sdarrenr 30922514Sdarrenr gettimeofday(&tv, NULL); 31022514Sdarrenr srand(tv.tv_sec ^ getpid() ^ tv.tv_usec); 31122514Sdarrenr /* 31222514Sdarrenr * Part8.1: 63k packet + 1k fragment at offset 0x1ffe 31322514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 31422514Sdarrenr * don't bother about the ICMP header, we're not worrying 31522514Sdarrenr * about that here. 31622514Sdarrenr */ 31722514Sdarrenr ip->ip_p = IPPROTO_ICMP; 31837074Speter ip->ip_off = htons(IP_MF); 31922514Sdarrenr u->uh_dport = htons(9); 32022514Sdarrenr ip->ip_id = htons(id++); 32122514Sdarrenr printf("1.8.1 63k packet + 1k fragment at offset 0x1ffe\n"); 32222514Sdarrenr ip->ip_len = 768 + 20 + 8; 32322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 32422514Sdarrenr printf("%d\r", i); 32522514Sdarrenr 32622514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 32722514Sdarrenr i = 512; 32822514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 329145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 33022514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 33122514Sdarrenr printf("%d\r", i); 33222514Sdarrenr fflush(stdout); 33322514Sdarrenr PAUSE(); 33422514Sdarrenr } 33522514Sdarrenr ip->ip_len = 896 + 20; 336145519Sdarrenr ip->ip_off = htons(i >> 3); 33722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 33822514Sdarrenr printf("%d\r", i); 33922514Sdarrenr putchar('\n'); 34022514Sdarrenr fflush(stdout); 34122514Sdarrenr 34222514Sdarrenr /* 34322514Sdarrenr * Part8.2: 63k packet + 1k fragment at offset 0x1ffe 34422514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 34522514Sdarrenr * don't bother about the ICMP header, we're not worrying 34622514Sdarrenr * about that here. (Lossage here) 34722514Sdarrenr */ 34822514Sdarrenr ip->ip_p = IPPROTO_ICMP; 34937074Speter ip->ip_off = htons(IP_MF); 35022514Sdarrenr u->uh_dport = htons(9); 35122514Sdarrenr ip->ip_id = htons(id++); 35222514Sdarrenr printf("1.8.2 63k packet + 1k fragment at offset 0x1ffe\n"); 35322514Sdarrenr ip->ip_len = 768 + 20 + 8; 35422514Sdarrenr if ((rand() & 0x1f) != 0) { 35522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 35622514Sdarrenr printf("%d\r", i); 35722514Sdarrenr } else 35822514Sdarrenr printf("skip 0\n"); 35922514Sdarrenr 36022514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 36122514Sdarrenr i = 512; 36222514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 363145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 36422514Sdarrenr if ((rand() & 0x1f) != 0) { 36522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 36622514Sdarrenr printf("%d\r", i); 36722514Sdarrenr } else 36822514Sdarrenr printf("skip %d\n", i); 36922514Sdarrenr fflush(stdout); 37022514Sdarrenr PAUSE(); 37122514Sdarrenr } 37222514Sdarrenr ip->ip_len = 896 + 20; 373145519Sdarrenr ip->ip_off = htons(i >> 3); 37422514Sdarrenr if ((rand() & 0x1f) != 0) { 37522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 37622514Sdarrenr printf("%d\r", i); 37722514Sdarrenr } else 37822514Sdarrenr printf("skip\n"); 37922514Sdarrenr putchar('\n'); 38022514Sdarrenr fflush(stdout); 38122514Sdarrenr 38222514Sdarrenr /* 38322514Sdarrenr * Part8.3: 33k packet - test for not dealing with -ve length 38422514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 38522514Sdarrenr * don't bother about the ICMP header, we're not worrying 38622514Sdarrenr * about that here. 38722514Sdarrenr */ 38822514Sdarrenr ip->ip_p = IPPROTO_ICMP; 38937074Speter ip->ip_off = htons(IP_MF); 39022514Sdarrenr u->uh_dport = htons(9); 39122514Sdarrenr ip->ip_id = htons(id++); 39222514Sdarrenr printf("1.8.3 33k packet\n"); 39322514Sdarrenr ip->ip_len = 768 + 20 + 8; 39422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 39522514Sdarrenr printf("%d\r", i); 39622514Sdarrenr 39722514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 39822514Sdarrenr i = 512; 39922514Sdarrenr for (; i < (32 * 1024 + 768); i += 768) { 400145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 40122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 40222514Sdarrenr printf("%d\r", i); 40322514Sdarrenr fflush(stdout); 40422514Sdarrenr PAUSE(); 40522514Sdarrenr } 40622514Sdarrenr ip->ip_len = 896 + 20; 407145519Sdarrenr ip->ip_off = htons(i >> 3); 40822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 40922514Sdarrenr printf("%d\r", i); 41022514Sdarrenr putchar('\n'); 41122514Sdarrenr fflush(stdout); 41222514Sdarrenr } 41322514Sdarrenr 41422514Sdarrenr ip->ip_len = len; 41522514Sdarrenr ip->ip_off = 0; 41622514Sdarrenr if (!ptest || (ptest == 9)) { 41722514Sdarrenr /* 41822514Sdarrenr * Part9: off & 0x8000 == 0x8000 41922514Sdarrenr */ 42022514Sdarrenr ip->ip_id = 0; 42137074Speter ip->ip_off = htons(0x8000); 42222514Sdarrenr printf("1.9. ip_off & 0x8000 == 0x8000\n"); 42322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 42422514Sdarrenr fflush(stdout); 42522514Sdarrenr PAUSE(); 42622514Sdarrenr } 42722514Sdarrenr 42822514Sdarrenr ip->ip_off = 0; 42922514Sdarrenr 43022514Sdarrenr if (!ptest || (ptest == 10)) { 43122514Sdarrenr /* 43222514Sdarrenr * Part10: ttl = 255 43322514Sdarrenr */ 43422514Sdarrenr ip->ip_id = 0; 43522514Sdarrenr ip->ip_ttl = 255; 43622514Sdarrenr printf("1.10.0 ip_ttl = 255\n"); 43722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 43822514Sdarrenr fflush(stdout); 43922514Sdarrenr PAUSE(); 44022514Sdarrenr 44122514Sdarrenr ip->ip_ttl = 128; 44222514Sdarrenr printf("1.10.1 ip_ttl = 128\n"); 44322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 44422514Sdarrenr fflush(stdout); 44522514Sdarrenr PAUSE(); 44622514Sdarrenr 44722514Sdarrenr ip->ip_ttl = 0; 44822514Sdarrenr printf("1.10.2 ip_ttl = 0\n"); 44922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 45022514Sdarrenr fflush(stdout); 45122514Sdarrenr PAUSE(); 45222514Sdarrenr } 45322514Sdarrenr 45422514Sdarrenr (void) close(nfd); 45522514Sdarrenr} 45622514Sdarrenr 45722514Sdarrenr 45822514Sdarrenrvoid ip_test2(dev, mtu, ip, gwip, ptest) 45922514Sdarrenrchar *dev; 46022514Sdarrenrint mtu; 46122514Sdarrenrip_t *ip; 46222514Sdarrenrstruct in_addr gwip; 46322514Sdarrenrint ptest; 46422514Sdarrenr{ 465145519Sdarrenr#ifdef USE_NANOSLEEP 466110920Sdarrenr struct timespec ts; 467110920Sdarrenr#else 46822514Sdarrenr struct timeval tv; 469110920Sdarrenr#endif 47022514Sdarrenr int nfd; 47122514Sdarrenr u_char *s; 47222514Sdarrenr 47322514Sdarrenr s = (u_char *)(ip + 1); 474145519Sdarrenr nfd = initdevice(dev, 1); 47522514Sdarrenr 476145519Sdarrenr IP_HL_A(ip, 6); 477145519Sdarrenr ip->ip_len = IP_HL(ip) << 2; 47822514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_NOP; 47922514Sdarrenr s++; 48022514Sdarrenr if (!ptest || (ptest == 1)) { 48122514Sdarrenr /* 48222514Sdarrenr * Test 1: option length > packet length, 48322514Sdarrenr * header length == packet length 48422514Sdarrenr */ 48522514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 48622514Sdarrenr s[IPOPT_OLEN] = 4; 48722514Sdarrenr s[IPOPT_OFFSET] = IPOPT_MINOFF; 48822514Sdarrenr ip->ip_p = IPPROTO_IP; 48922514Sdarrenr printf("2.1 option length > packet length\n"); 49022514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 49122514Sdarrenr fflush(stdout); 49222514Sdarrenr PAUSE(); 49322514Sdarrenr } 49422514Sdarrenr 495145519Sdarrenr IP_HL_A(ip, 7); 496145519Sdarrenr ip->ip_len = IP_HL(ip) << 2; 49722514Sdarrenr if (!ptest || (ptest == 1)) { 49822514Sdarrenr /* 49922514Sdarrenr * Test 2: options have length = 0 50022514Sdarrenr */ 50122514Sdarrenr printf("2.2.1 option length = 0, RR\n"); 50222514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_RR; 50322514Sdarrenr s[IPOPT_OLEN] = 0; 50422514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 50522514Sdarrenr fflush(stdout); 50622514Sdarrenr PAUSE(); 50722514Sdarrenr 50822514Sdarrenr printf("2.2.2 option length = 0, TS\n"); 50922514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 51022514Sdarrenr s[IPOPT_OLEN] = 0; 51122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 51222514Sdarrenr fflush(stdout); 51322514Sdarrenr PAUSE(); 51422514Sdarrenr 51522514Sdarrenr printf("2.2.3 option length = 0, SECURITY\n"); 51622514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SECURITY; 51722514Sdarrenr s[IPOPT_OLEN] = 0; 51822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 51922514Sdarrenr fflush(stdout); 52022514Sdarrenr PAUSE(); 52122514Sdarrenr 52222514Sdarrenr printf("2.2.4 option length = 0, LSRR\n"); 52322514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_LSRR; 52422514Sdarrenr s[IPOPT_OLEN] = 0; 52522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 52622514Sdarrenr fflush(stdout); 52722514Sdarrenr PAUSE(); 52822514Sdarrenr 52922514Sdarrenr printf("2.2.5 option length = 0, SATID\n"); 53022514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SATID; 53122514Sdarrenr s[IPOPT_OLEN] = 0; 53222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 53322514Sdarrenr fflush(stdout); 53422514Sdarrenr PAUSE(); 53522514Sdarrenr 53622514Sdarrenr printf("2.2.6 option length = 0, SSRR\n"); 53722514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SSRR; 53822514Sdarrenr s[IPOPT_OLEN] = 0; 53922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 54022514Sdarrenr fflush(stdout); 54122514Sdarrenr PAUSE(); 54222514Sdarrenr } 54322514Sdarrenr 54422514Sdarrenr (void) close(nfd); 54522514Sdarrenr} 54622514Sdarrenr 54722514Sdarrenr 54822514Sdarrenr/* 54922514Sdarrenr * test 3 (ICMP) 55022514Sdarrenr */ 55122514Sdarrenrvoid ip_test3(dev, mtu, ip, gwip, ptest) 55222514Sdarrenrchar *dev; 55322514Sdarrenrint mtu; 55422514Sdarrenrip_t *ip; 55522514Sdarrenrstruct in_addr gwip; 55622514Sdarrenrint ptest; 55722514Sdarrenr{ 55822514Sdarrenr static int ict1[10] = { 8, 9, 10, 13, 14, 15, 16, 17, 18, 0 }; 55922514Sdarrenr static int ict2[8] = { 3, 9, 10, 13, 14, 17, 18, 0 }; 560145519Sdarrenr#ifdef USE_NANOSLEEP 561110920Sdarrenr struct timespec ts; 562110920Sdarrenr#else 56322514Sdarrenr struct timeval tv; 564110920Sdarrenr#endif 56522514Sdarrenr struct icmp *icp; 56622514Sdarrenr int nfd, i; 56722514Sdarrenr 568145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 569145519Sdarrenr IP_V_A(ip, IPVERSION); 57022514Sdarrenr ip->ip_tos = 0; 57122514Sdarrenr ip->ip_off = 0; 57222514Sdarrenr ip->ip_ttl = 60; 57322514Sdarrenr ip->ip_p = IPPROTO_ICMP; 57422514Sdarrenr ip->ip_sum = 0; 57522514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp); 576145519Sdarrenr icp = (struct icmp *)((char *)ip + (IP_HL(ip) << 2)); 577145519Sdarrenr nfd = initdevice(dev, 1); 57822514Sdarrenr 57922514Sdarrenr if (!ptest || (ptest == 1)) { 58022514Sdarrenr /* 58122514Sdarrenr * Type 0 - 31, 255, code = 0 58222514Sdarrenr */ 58322514Sdarrenr bzero((char *)icp, sizeof(*icp)); 58422514Sdarrenr for (i = 0; i < 32; i++) { 58522514Sdarrenr icp->icmp_type = i; 58622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 58722514Sdarrenr PAUSE(); 58822514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, i); 58922514Sdarrenr } 59022514Sdarrenr icp->icmp_type = 255; 59122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 59222514Sdarrenr PAUSE(); 59322514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, 255); 59422514Sdarrenr putchar('\n'); 59522514Sdarrenr } 59622514Sdarrenr 59722514Sdarrenr if (!ptest || (ptest == 2)) { 59822514Sdarrenr /* 59922514Sdarrenr * Type 3, code = 0 - 31 60022514Sdarrenr */ 60122514Sdarrenr icp->icmp_type = 3; 60222514Sdarrenr for (i = 0; i < 32; i++) { 60322514Sdarrenr icp->icmp_code = i; 60422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 60522514Sdarrenr PAUSE(); 60622514Sdarrenr printf("3.2.%d ICMP type 3 code %d (all 0's)\r", i, i); 60722514Sdarrenr } 60822514Sdarrenr } 60922514Sdarrenr 61022514Sdarrenr if (!ptest || (ptest == 3)) { 61122514Sdarrenr /* 61222514Sdarrenr * Type 4, code = 0,127,128,255 61322514Sdarrenr */ 61422514Sdarrenr icp->icmp_type = 4; 61522514Sdarrenr icp->icmp_code = 0; 61622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 61722514Sdarrenr PAUSE(); 61822514Sdarrenr printf("3.3.1 ICMP type 4 code 0 (all 0's)\r"); 61922514Sdarrenr icp->icmp_code = 127; 62022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 62122514Sdarrenr PAUSE(); 62222514Sdarrenr printf("3.3.2 ICMP type 4 code 127 (all 0's)\r"); 62322514Sdarrenr icp->icmp_code = 128; 62422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 62522514Sdarrenr PAUSE(); 62622514Sdarrenr printf("3.3.3 ICMP type 4 code 128 (all 0's)\r"); 62722514Sdarrenr icp->icmp_code = 255; 62822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 62922514Sdarrenr PAUSE(); 63022514Sdarrenr printf("3.3.4 ICMP type 4 code 255 (all 0's)\r"); 63122514Sdarrenr } 63222514Sdarrenr 63322514Sdarrenr if (!ptest || (ptest == 4)) { 63422514Sdarrenr /* 63522514Sdarrenr * Type 5, code = 0,127,128,255 63622514Sdarrenr */ 63722514Sdarrenr icp->icmp_type = 5; 63822514Sdarrenr icp->icmp_code = 0; 63922514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64022514Sdarrenr PAUSE(); 64122514Sdarrenr printf("3.4.1 ICMP type 5 code 0 (all 0's)\r"); 64222514Sdarrenr icp->icmp_code = 127; 64322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64422514Sdarrenr PAUSE(); 64522514Sdarrenr printf("3.4.2 ICMP type 5 code 127 (all 0's)\r"); 64622514Sdarrenr icp->icmp_code = 128; 64722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64822514Sdarrenr PAUSE(); 64922514Sdarrenr printf("3.4.3 ICMP type 5 code 128 (all 0's)\r"); 65022514Sdarrenr icp->icmp_code = 255; 65122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 65222514Sdarrenr PAUSE(); 65322514Sdarrenr printf("3.4.4 ICMP type 5 code 255 (all 0's)\r"); 65422514Sdarrenr } 65522514Sdarrenr 65622514Sdarrenr if (!ptest || (ptest == 5)) { 65722514Sdarrenr /* 65822514Sdarrenr * Type 8-10;13-18, code - 0,127,128,255 65922514Sdarrenr */ 66022514Sdarrenr for (i = 0; ict1[i]; i++) { 66122514Sdarrenr icp->icmp_type = ict1[i]; 66222514Sdarrenr icp->icmp_code = 0; 66322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66422514Sdarrenr PAUSE(); 66522514Sdarrenr printf("3.5.%d ICMP type 5 code 0 (all 0's)\r", 66622514Sdarrenr i * 4); 66722514Sdarrenr icp->icmp_code = 127; 66822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66922514Sdarrenr PAUSE(); 67022514Sdarrenr printf("3.5.%d ICMP type 5 code 127 (all 0's)\r", 67122514Sdarrenr i * 4 + 1); 67222514Sdarrenr icp->icmp_code = 128; 67322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 67422514Sdarrenr PAUSE(); 67522514Sdarrenr printf("3.5.%d ICMP type 5 code 128 (all 0's)\r", 67622514Sdarrenr i * 4 + 2); 67722514Sdarrenr icp->icmp_code = 255; 67822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 67922514Sdarrenr PAUSE(); 68022514Sdarrenr printf("3.5.%d ICMP type 5 code 255 (all 0's)\r", 68122514Sdarrenr i * 4 + 3); 68222514Sdarrenr } 68322514Sdarrenr putchar('\n'); 68422514Sdarrenr } 68522514Sdarrenr 68622514Sdarrenr if (!ptest || (ptest == 6)) { 68722514Sdarrenr /* 68822514Sdarrenr * Type 12, code - 0,127,128,129,255 68922514Sdarrenr */ 69022514Sdarrenr icp->icmp_type = 12; 69122514Sdarrenr icp->icmp_code = 0; 69222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69322514Sdarrenr PAUSE(); 69422514Sdarrenr printf("3.6.1 ICMP type 12 code 0 (all 0's)\r"); 69522514Sdarrenr icp->icmp_code = 127; 69622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69722514Sdarrenr PAUSE(); 69822514Sdarrenr printf("3.6.2 ICMP type 12 code 127 (all 0's)\r"); 69922514Sdarrenr icp->icmp_code = 128; 70022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 70122514Sdarrenr PAUSE(); 70222514Sdarrenr printf("3.6.3 ICMP type 12 code 128 (all 0's)\r"); 70322514Sdarrenr icp->icmp_code = 129; 70422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 70522514Sdarrenr PAUSE(); 70622514Sdarrenr printf("3.6.4 ICMP type 12 code 129 (all 0's)\r"); 70722514Sdarrenr icp->icmp_code = 255; 70822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 70922514Sdarrenr PAUSE(); 71022514Sdarrenr printf("3.6.5 ICMP type 12 code 255 (all 0's)\r"); 71122514Sdarrenr putchar('\n'); 71222514Sdarrenr } 71322514Sdarrenr 71422514Sdarrenr if (!ptest || (ptest == 7)) { 71522514Sdarrenr /* 71622514Sdarrenr * Type 3;9-10;13-14;17-18 - shorter packets 71722514Sdarrenr */ 71822514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp) / 2; 71922514Sdarrenr for (i = 0; ict2[i]; i++) { 72022514Sdarrenr icp->icmp_type = ict1[i]; 72122514Sdarrenr icp->icmp_code = 0; 72222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72322514Sdarrenr PAUSE(); 72422514Sdarrenr printf("3.5.%d ICMP type %d code 0 (all 0's)\r", 72522514Sdarrenr i * 4, icp->icmp_type); 72622514Sdarrenr icp->icmp_code = 127; 72722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72822514Sdarrenr PAUSE(); 72922514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 73022514Sdarrenr i * 4 + 1, icp->icmp_type); 73122514Sdarrenr icp->icmp_code = 128; 73222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 73322514Sdarrenr PAUSE(); 73422514Sdarrenr printf("3.5.%d ICMP type %d code 128 (all 0's)\r", 73522514Sdarrenr i * 4 + 2, icp->icmp_type); 73622514Sdarrenr icp->icmp_code = 255; 73722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 73822514Sdarrenr PAUSE(); 73922514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 74022514Sdarrenr i * 4 + 3, icp->icmp_type); 74122514Sdarrenr } 74222514Sdarrenr putchar('\n'); 74322514Sdarrenr } 74422514Sdarrenr} 74522514Sdarrenr 74622514Sdarrenr 74722514Sdarrenr/* Perform test 4 (UDP) */ 74822514Sdarrenr 74922514Sdarrenrvoid ip_test4(dev, mtu, ip, gwip, ptest) 75022514Sdarrenrchar *dev; 75122514Sdarrenrint mtu; 75222514Sdarrenrip_t *ip; 75322514Sdarrenrstruct in_addr gwip; 75422514Sdarrenrint ptest; 75522514Sdarrenr{ 756145519Sdarrenr#ifdef USE_NANOSLEEP 757110920Sdarrenr struct timespec ts; 758110920Sdarrenr#else 75922514Sdarrenr struct timeval tv; 760110920Sdarrenr#endif 76131183Speter udphdr_t *u; 76222514Sdarrenr int nfd, i; 76322514Sdarrenr 76422514Sdarrenr 765145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 766145519Sdarrenr IP_V_A(ip, IPVERSION); 76722514Sdarrenr ip->ip_tos = 0; 76822514Sdarrenr ip->ip_off = 0; 76922514Sdarrenr ip->ip_ttl = 60; 77022514Sdarrenr ip->ip_p = IPPROTO_UDP; 77122514Sdarrenr ip->ip_sum = 0; 772145519Sdarrenr u = (udphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 77337074Speter u->uh_sport = htons(1); 77437074Speter u->uh_dport = htons(1); 77537074Speter u->uh_ulen = htons(sizeof(*u) + 4); 776145519Sdarrenr nfd = initdevice(dev, 1); 77722514Sdarrenr 77822514Sdarrenr if (!ptest || (ptest == 1)) { 77922514Sdarrenr /* 78022514Sdarrenr * Test 1. ulen > packet 78122514Sdarrenr */ 78237074Speter u->uh_ulen = htons(sizeof(*u) + 4); 783145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 78422514Sdarrenr printf("4.1 UDP uh_ulen > packet size - short packets\n"); 78537074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 78637074Speter u->uh_ulen = htons(i); 78722514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 78822514Sdarrenr printf("%d\r", i); 78922514Sdarrenr fflush(stdout); 79022514Sdarrenr PAUSE(); 79122514Sdarrenr } 79222514Sdarrenr putchar('\n'); 79322514Sdarrenr } 79422514Sdarrenr 79522514Sdarrenr if (!ptest || (ptest == 2)) { 79622514Sdarrenr /* 79722514Sdarrenr * Test 2. ulen < packet 79822514Sdarrenr */ 79937074Speter u->uh_ulen = htons(sizeof(*u) + 4); 800145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 80122514Sdarrenr printf("4.2 UDP uh_ulen < packet size - short packets\n"); 80237074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 80322514Sdarrenr ip->ip_len = i; 80422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 80522514Sdarrenr printf("%d\r", i); 80622514Sdarrenr fflush(stdout); 80722514Sdarrenr PAUSE(); 80822514Sdarrenr } 80922514Sdarrenr putchar('\n'); 81022514Sdarrenr } 81122514Sdarrenr 81222514Sdarrenr if (!ptest || (ptest == 3)) { 81322514Sdarrenr /* 81422514Sdarrenr * Test 3: sport = 0, sport = 1, sport = 32767 81522514Sdarrenr * sport = 32768, sport = 65535 81622514Sdarrenr */ 81722514Sdarrenr u->uh_ulen = sizeof(*u) + 4; 818145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 81922514Sdarrenr printf("4.3.1 UDP sport = 0\n"); 82022514Sdarrenr u->uh_sport = 0; 82122514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 82222514Sdarrenr printf("0\n"); 82322514Sdarrenr fflush(stdout); 82422514Sdarrenr PAUSE(); 82522514Sdarrenr printf("4.3.2 UDP sport = 1\n"); 82637074Speter u->uh_sport = htons(1); 82722514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 82822514Sdarrenr printf("1\n"); 82922514Sdarrenr fflush(stdout); 83022514Sdarrenr PAUSE(); 83122514Sdarrenr printf("4.3.3 UDP sport = 32767\n"); 83237074Speter u->uh_sport = htons(32767); 83322514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 83422514Sdarrenr printf("32767\n"); 83522514Sdarrenr fflush(stdout); 83622514Sdarrenr PAUSE(); 83722514Sdarrenr printf("4.3.4 UDP sport = 32768\n"); 83837074Speter u->uh_sport = htons(32768); 83922514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 84022514Sdarrenr printf("32768\n"); 84122514Sdarrenr putchar('\n'); 84222514Sdarrenr fflush(stdout); 84322514Sdarrenr PAUSE(); 84422514Sdarrenr printf("4.3.5 UDP sport = 65535\n"); 84537074Speter u->uh_sport = htons(65535); 84622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 84722514Sdarrenr printf("65535\n"); 84822514Sdarrenr fflush(stdout); 84922514Sdarrenr PAUSE(); 85022514Sdarrenr } 85122514Sdarrenr 85222514Sdarrenr if (!ptest || (ptest == 4)) { 85322514Sdarrenr /* 85422514Sdarrenr * Test 4: dport = 0, dport = 1, dport = 32767 85522514Sdarrenr * dport = 32768, dport = 65535 85622514Sdarrenr */ 85737074Speter u->uh_ulen = ntohs(sizeof(*u) + 4); 85837074Speter u->uh_sport = htons(1); 859145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 86022514Sdarrenr printf("4.4.1 UDP dport = 0\n"); 86122514Sdarrenr u->uh_dport = 0; 86222514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86322514Sdarrenr printf("0\n"); 86422514Sdarrenr fflush(stdout); 86522514Sdarrenr PAUSE(); 86622514Sdarrenr printf("4.4.2 UDP dport = 1\n"); 86737074Speter u->uh_dport = htons(1); 86822514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86922514Sdarrenr printf("1\n"); 87022514Sdarrenr fflush(stdout); 87122514Sdarrenr PAUSE(); 87222514Sdarrenr printf("4.4.3 UDP dport = 32767\n"); 87337074Speter u->uh_dport = htons(32767); 87422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 87522514Sdarrenr printf("32767\n"); 87622514Sdarrenr fflush(stdout); 87722514Sdarrenr PAUSE(); 87822514Sdarrenr printf("4.4.4 UDP dport = 32768\n"); 87937074Speter u->uh_dport = htons(32768); 88022514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 88122514Sdarrenr printf("32768\n"); 88222514Sdarrenr fflush(stdout); 88322514Sdarrenr PAUSE(); 88422514Sdarrenr printf("4.4.5 UDP dport = 65535\n"); 88537074Speter u->uh_dport = htons(65535); 88622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 88722514Sdarrenr printf("65535\n"); 88822514Sdarrenr fflush(stdout); 88922514Sdarrenr PAUSE(); 89022514Sdarrenr } 89122514Sdarrenr 89231183Speter if (!ptest || (ptest == 5)) { 89322514Sdarrenr /* 89431183Speter * Test 5: sizeof(ip_t) <= MTU <= sizeof(udphdr_t) + 89531183Speter * sizeof(ip_t) 89622514Sdarrenr */ 89722514Sdarrenr printf("4.5 UDP 20 <= MTU <= 32\n"); 89837074Speter for (i = sizeof(*ip); i <= ntohs(u->uh_ulen); i++) { 89922514Sdarrenr (void) send_udp(nfd, i, ip, gwip); 90022514Sdarrenr printf("%d\r", i); 90122514Sdarrenr fflush(stdout); 90222514Sdarrenr PAUSE(); 90322514Sdarrenr } 90422514Sdarrenr putchar('\n'); 90522514Sdarrenr } 90622514Sdarrenr} 90722514Sdarrenr 90822514Sdarrenr 90922514Sdarrenr/* Perform test 5 (TCP) */ 91022514Sdarrenr 91122514Sdarrenrvoid ip_test5(dev, mtu, ip, gwip, ptest) 91222514Sdarrenrchar *dev; 91322514Sdarrenrint mtu; 91422514Sdarrenrip_t *ip; 91522514Sdarrenrstruct in_addr gwip; 91622514Sdarrenrint ptest; 91722514Sdarrenr{ 918145519Sdarrenr#ifdef USE_NANOSLEEP 919110920Sdarrenr struct timespec ts; 920110920Sdarrenr#else 92122514Sdarrenr struct timeval tv; 922110920Sdarrenr#endif 92322514Sdarrenr tcphdr_t *t; 92422514Sdarrenr int nfd, i; 92522514Sdarrenr 926145519Sdarrenr t = (tcphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 927145519Sdarrenr#if !defined(linux) && !defined(__osf__) 92822514Sdarrenr t->th_x2 = 0; 92931183Speter#endif 930145519Sdarrenr TCP_OFF_A(t, 0); 93137074Speter t->th_sport = htons(1); 93237074Speter t->th_dport = htons(1); 93337074Speter t->th_win = htons(4096); 93422514Sdarrenr t->th_urp = 0; 93522514Sdarrenr t->th_sum = 0; 93637074Speter t->th_seq = htonl(1); 93722514Sdarrenr t->th_ack = 0; 93834739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 939145519Sdarrenr nfd = initdevice(dev, 1); 94022514Sdarrenr 94122514Sdarrenr if (!ptest || (ptest == 1)) { 94222514Sdarrenr /* 94322514Sdarrenr * Test 1: flags variations, 0 - 3f 94422514Sdarrenr */ 945145519Sdarrenr TCP_OFF_A(t, sizeof(*t) >> 2); 94622514Sdarrenr printf("5.1 Test TCP flag combinations\n"); 94722514Sdarrenr for (i = 0; i <= (TH_URG|TH_ACK|TH_PUSH|TH_RST|TH_SYN|TH_FIN); 94822514Sdarrenr i++) { 94922514Sdarrenr t->th_flags = i; 95022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 95122514Sdarrenr printf("%d\r", i); 95222514Sdarrenr fflush(stdout); 95322514Sdarrenr PAUSE(); 95422514Sdarrenr } 95522514Sdarrenr putchar('\n'); 95622514Sdarrenr } 95722514Sdarrenr 95822514Sdarrenr if (!ptest || (ptest == 2)) { 95922514Sdarrenr t->th_flags = TH_SYN; 96022514Sdarrenr /* 96122514Sdarrenr * Test 2: seq = 0, seq = 1, seq = 0x7fffffff, seq=0x80000000, 96222514Sdarrenr * seq = 0xa000000, seq = 0xffffffff 96322514Sdarrenr */ 96422514Sdarrenr printf("5.2.1 TCP seq = 0\n"); 96537074Speter t->th_seq = htonl(0); 96622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 96722514Sdarrenr fflush(stdout); 96822514Sdarrenr PAUSE(); 96922514Sdarrenr 97022514Sdarrenr printf("5.2.2 TCP seq = 1\n"); 97137074Speter t->th_seq = htonl(1); 97222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 97322514Sdarrenr fflush(stdout); 97422514Sdarrenr PAUSE(); 97522514Sdarrenr 97622514Sdarrenr printf("5.2.3 TCP seq = 0x7fffffff\n"); 97737074Speter t->th_seq = htonl(0x7fffffff); 97822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 97922514Sdarrenr fflush(stdout); 98022514Sdarrenr PAUSE(); 98122514Sdarrenr 98222514Sdarrenr printf("5.2.4 TCP seq = 0x80000000\n"); 98337074Speter t->th_seq = htonl(0x80000000); 98422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 98522514Sdarrenr fflush(stdout); 98622514Sdarrenr PAUSE(); 98722514Sdarrenr 98822514Sdarrenr printf("5.2.5 TCP seq = 0xc0000000\n"); 98937074Speter t->th_seq = htonl(0xc0000000); 99022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 99122514Sdarrenr fflush(stdout); 99222514Sdarrenr PAUSE(); 99322514Sdarrenr 99422514Sdarrenr printf("5.2.6 TCP seq = 0xffffffff\n"); 99537074Speter t->th_seq = htonl(0xffffffff); 99622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 99722514Sdarrenr fflush(stdout); 99822514Sdarrenr PAUSE(); 99922514Sdarrenr } 100022514Sdarrenr 100122514Sdarrenr if (!ptest || (ptest == 3)) { 100222514Sdarrenr t->th_flags = TH_ACK; 100322514Sdarrenr /* 100422514Sdarrenr * Test 3: ack = 0, ack = 1, ack = 0x7fffffff, ack = 0x8000000 100522514Sdarrenr * ack = 0xa000000, ack = 0xffffffff 100622514Sdarrenr */ 100722514Sdarrenr printf("5.3.1 TCP ack = 0\n"); 100822514Sdarrenr t->th_ack = 0; 100922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 101022514Sdarrenr fflush(stdout); 101122514Sdarrenr PAUSE(); 101222514Sdarrenr 101322514Sdarrenr printf("5.3.2 TCP ack = 1\n"); 101437074Speter t->th_ack = htonl(1); 101522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 101622514Sdarrenr fflush(stdout); 101722514Sdarrenr PAUSE(); 101822514Sdarrenr 101922514Sdarrenr printf("5.3.3 TCP ack = 0x7fffffff\n"); 102037074Speter t->th_ack = htonl(0x7fffffff); 102122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102222514Sdarrenr fflush(stdout); 102322514Sdarrenr PAUSE(); 102422514Sdarrenr 102522514Sdarrenr printf("5.3.4 TCP ack = 0x80000000\n"); 102637074Speter t->th_ack = htonl(0x80000000); 102722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102822514Sdarrenr fflush(stdout); 102922514Sdarrenr PAUSE(); 103022514Sdarrenr 103122514Sdarrenr printf("5.3.5 TCP ack = 0xc0000000\n"); 103237074Speter t->th_ack = htonl(0xc0000000); 103322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 103422514Sdarrenr fflush(stdout); 103522514Sdarrenr PAUSE(); 103622514Sdarrenr 103722514Sdarrenr printf("5.3.6 TCP ack = 0xffffffff\n"); 103837074Speter t->th_ack = htonl(0xffffffff); 103922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 104022514Sdarrenr fflush(stdout); 104122514Sdarrenr PAUSE(); 104222514Sdarrenr } 104322514Sdarrenr 104422514Sdarrenr if (!ptest || (ptest == 4)) { 104522514Sdarrenr t->th_flags = TH_SYN; 104622514Sdarrenr /* 104722514Sdarrenr * Test 4: win = 0, win = 32768, win = 65535 104822514Sdarrenr */ 104922514Sdarrenr printf("5.4.1 TCP win = 0\n"); 105037074Speter t->th_seq = htonl(0); 105122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105222514Sdarrenr fflush(stdout); 105322514Sdarrenr PAUSE(); 105422514Sdarrenr 105522514Sdarrenr printf("5.4.2 TCP win = 32768\n"); 105637074Speter t->th_seq = htonl(0x7fff); 105722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105822514Sdarrenr fflush(stdout); 105922514Sdarrenr PAUSE(); 106022514Sdarrenr 106122514Sdarrenr printf("5.4.3 TCP win = 65535\n"); 106237074Speter t->th_win = htons(0xffff); 106322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 106422514Sdarrenr fflush(stdout); 106522514Sdarrenr PAUSE(); 106622514Sdarrenr } 106722514Sdarrenr 106834739Speter#if !defined(linux) && !defined(__SVR4) && !defined(__svr4__) && \ 1069145519Sdarrenr !defined(__sgi) && !defined(__hpux) && !defined(__osf__) 107022514Sdarrenr { 107134739Speter struct tcpcb *tcbp, tcb; 107222514Sdarrenr struct tcpiphdr ti; 107322514Sdarrenr struct sockaddr_in sin; 107422514Sdarrenr int fd, slen; 107522514Sdarrenr 107622514Sdarrenr bzero((char *)&sin, sizeof(sin)); 107722514Sdarrenr 107822514Sdarrenr for (i = 1; i < 63; i++) { 107922514Sdarrenr fd = socket(AF_INET, SOCK_STREAM, 0); 108034739Speter bzero((char *)&sin, sizeof(sin)); 108122514Sdarrenr sin.sin_addr.s_addr = ip->ip_dst.s_addr; 108222514Sdarrenr sin.sin_port = htons(i); 108334739Speter sin.sin_family = AF_INET; 108422514Sdarrenr if (!connect(fd, (struct sockaddr *)&sin, sizeof(sin))) 108522514Sdarrenr break; 108634739Speter close(fd); 108722514Sdarrenr } 108822514Sdarrenr 108922514Sdarrenr if (i == 63) { 109022514Sdarrenr printf("Couldn't open a TCP socket between ports 1 and 63\n"); 109122514Sdarrenr printf("to host %s for test 5 and 6 - skipping.\n", 109222514Sdarrenr inet_ntoa(ip->ip_dst)); 109322514Sdarrenr goto skip_five_and_six; 109422514Sdarrenr } 109522514Sdarrenr 109622514Sdarrenr bcopy((char *)ip, (char *)&ti, sizeof(*ip)); 109734739Speter t->th_dport = htons(i); 109822514Sdarrenr slen = sizeof(sin); 109922514Sdarrenr if (!getsockname(fd, (struct sockaddr *)&sin, &slen)) 110034739Speter t->th_sport = sin.sin_port; 110134739Speter if (!(tcbp = find_tcp(fd, &ti))) { 110222514Sdarrenr printf("Can't find PCB\n"); 110322514Sdarrenr goto skip_five_and_six; 110422514Sdarrenr } 110534739Speter KMCPY(&tcb, tcbp, sizeof(tcb)); 110622514Sdarrenr ti.ti_win = tcb.rcv_adv; 110737074Speter ti.ti_seq = htonl(tcb.snd_nxt - 1); 110822514Sdarrenr ti.ti_ack = tcb.rcv_nxt; 110922514Sdarrenr 111022514Sdarrenr if (!ptest || (ptest == 5)) { 111122514Sdarrenr /* 111222514Sdarrenr * Test 5: urp 111322514Sdarrenr */ 111434739Speter t->th_flags = TH_ACK|TH_URG; 111534739Speter printf("5.5.1 TCP Urgent pointer, sport %hu dport %hu\n", 111634739Speter ntohs(t->th_sport), ntohs(t->th_dport)); 111734739Speter t->th_urp = htons(1); 111822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 111922514Sdarrenr PAUSE(); 112034739Speter 112137074Speter t->th_seq = htonl(tcb.snd_nxt); 112234739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t) + 1; 112334739Speter t->th_urp = htons(0x7fff); 112422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 112522514Sdarrenr PAUSE(); 112634739Speter t->th_urp = htons(0x8000); 112722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 112822514Sdarrenr PAUSE(); 112934739Speter t->th_urp = htons(0xffff); 113022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 113122514Sdarrenr PAUSE(); 113237074Speter t->th_urp = 0; 113334739Speter t->th_flags &= ~TH_URG; 113434739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 113522514Sdarrenr } 113622514Sdarrenr 113722514Sdarrenr if (!ptest || (ptest == 6)) { 113822514Sdarrenr /* 113922514Sdarrenr * Test 6: data offset, off = 0, off is inside, off is outside 114022514Sdarrenr */ 114134739Speter t->th_flags = TH_ACK; 114234739Speter printf("5.6.1 TCP off = 1-15, len = 40\n"); 114334739Speter for (i = 1; i < 16; i++) { 1144145519Sdarrenr TCP_OFF_A(t, ntohs(i)); 114522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 114622514Sdarrenr printf("%d\r", i); 114722514Sdarrenr fflush(stdout); 114822514Sdarrenr PAUSE(); 114922514Sdarrenr } 115022514Sdarrenr putchar('\n'); 115134739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 115222514Sdarrenr } 115322514Sdarrenr 115422514Sdarrenr (void) close(fd); 115522514Sdarrenr } 115622514Sdarrenrskip_five_and_six: 115722514Sdarrenr#endif 115837074Speter t->th_seq = htonl(1); 115937074Speter t->th_ack = htonl(1); 1160145519Sdarrenr TCP_OFF_A(t, 0); 116122514Sdarrenr 116222514Sdarrenr if (!ptest || (ptest == 7)) { 116322514Sdarrenr t->th_flags = TH_SYN; 116422514Sdarrenr /* 116522514Sdarrenr * Test 7: sport = 0, sport = 1, sport = 32767 116622514Sdarrenr * sport = 32768, sport = 65535 116722514Sdarrenr */ 116822514Sdarrenr printf("5.7.1 TCP sport = 0\n"); 116922514Sdarrenr t->th_sport = 0; 117022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 117122514Sdarrenr fflush(stdout); 117222514Sdarrenr PAUSE(); 117322514Sdarrenr 117422514Sdarrenr printf("5.7.2 TCP sport = 1\n"); 117537074Speter t->th_sport = htons(1); 117622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 117722514Sdarrenr fflush(stdout); 117822514Sdarrenr PAUSE(); 117922514Sdarrenr 118022514Sdarrenr printf("5.7.3 TCP sport = 32767\n"); 118137074Speter t->th_sport = htons(32767); 118222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 118322514Sdarrenr fflush(stdout); 118422514Sdarrenr PAUSE(); 118522514Sdarrenr 118622514Sdarrenr printf("5.7.4 TCP sport = 32768\n"); 118737074Speter t->th_sport = htons(32768); 118822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 118922514Sdarrenr fflush(stdout); 119022514Sdarrenr PAUSE(); 119122514Sdarrenr 119222514Sdarrenr printf("5.7.5 TCP sport = 65535\n"); 119337074Speter t->th_sport = htons(65535); 119422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 119522514Sdarrenr fflush(stdout); 119622514Sdarrenr PAUSE(); 119722514Sdarrenr } 119822514Sdarrenr 119922514Sdarrenr if (!ptest || (ptest == 8)) { 120037074Speter t->th_sport = htons(1); 120134739Speter t->th_flags = TH_SYN; 120222514Sdarrenr /* 120322514Sdarrenr * Test 8: dport = 0, dport = 1, dport = 32767 120422514Sdarrenr * dport = 32768, dport = 65535 120522514Sdarrenr */ 120622514Sdarrenr printf("5.8.1 TCP dport = 0\n"); 120722514Sdarrenr t->th_dport = 0; 120822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120922514Sdarrenr fflush(stdout); 121022514Sdarrenr PAUSE(); 121122514Sdarrenr 121222514Sdarrenr printf("5.8.2 TCP dport = 1\n"); 121337074Speter t->th_dport = htons(1); 121422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 121522514Sdarrenr fflush(stdout); 121622514Sdarrenr PAUSE(); 121722514Sdarrenr 121822514Sdarrenr printf("5.8.3 TCP dport = 32767\n"); 121937074Speter t->th_dport = htons(32767); 122022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 122122514Sdarrenr fflush(stdout); 122222514Sdarrenr PAUSE(); 122322514Sdarrenr 122422514Sdarrenr printf("5.8.4 TCP dport = 32768\n"); 122537074Speter t->th_dport = htons(32768); 122622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 122722514Sdarrenr fflush(stdout); 122822514Sdarrenr PAUSE(); 122922514Sdarrenr 123022514Sdarrenr printf("5.8.5 TCP dport = 65535\n"); 123137074Speter t->th_dport = htons(65535); 123222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 123322514Sdarrenr fflush(stdout); 123422514Sdarrenr PAUSE(); 123522514Sdarrenr } 123634739Speter 123734739Speter /* LAND attack - self connect, so make src & dst ip/port the same */ 123834739Speter if (!ptest || (ptest == 9)) { 123934739Speter printf("5.9 TCP LAND attack. sport = 25, dport = 25\n"); 124034739Speter /* chose SMTP port 25 */ 124134739Speter t->th_sport = htons(25); 124234739Speter t->th_dport = htons(25); 124334739Speter t->th_flags = TH_SYN; 124434739Speter ip->ip_src = ip->ip_dst; 124534739Speter (void) send_tcp(nfd, mtu, ip, gwip); 124634739Speter fflush(stdout); 124734739Speter PAUSE(); 124834739Speter } 124934739Speter 125022514Sdarrenr /* TCP options header checking */ 125122514Sdarrenr /* 0 length options, etc */ 125222514Sdarrenr} 125322514Sdarrenr 125422514Sdarrenr 125522514Sdarrenr/* Perform test 6 (exhaust mbuf test) */ 125622514Sdarrenr 125722514Sdarrenrvoid ip_test6(dev, mtu, ip, gwip, ptest) 125822514Sdarrenrchar *dev; 125922514Sdarrenrint mtu; 126022514Sdarrenrip_t *ip; 126122514Sdarrenrstruct in_addr gwip; 126222514Sdarrenrint ptest; 126322514Sdarrenr{ 1264145519Sdarrenr#ifdef USE_NANOSLEEP 1265110920Sdarrenr struct timespec ts; 1266110920Sdarrenr#else 126722514Sdarrenr struct timeval tv; 1268110920Sdarrenr#endif 126922514Sdarrenr udphdr_t *u; 127022514Sdarrenr int nfd, i, j, k; 127122514Sdarrenr 1272145519Sdarrenr IP_V_A(ip, IPVERSION); 127322514Sdarrenr ip->ip_tos = 0; 127422514Sdarrenr ip->ip_off = 0; 127522514Sdarrenr ip->ip_ttl = 60; 127622514Sdarrenr ip->ip_p = IPPROTO_UDP; 127722514Sdarrenr ip->ip_sum = 0; 127822514Sdarrenr u = (udphdr_t *)(ip + 1); 127937074Speter u->uh_sport = htons(1); 128037074Speter u->uh_dport = htons(9); 128122514Sdarrenr u->uh_sum = 0; 128222514Sdarrenr 1283145519Sdarrenr nfd = initdevice(dev, 1); 128437074Speter u->uh_ulen = htons(7168); 128522514Sdarrenr 128634739Speter printf("6. Exhaustive mbuf test.\n"); 128734739Speter printf(" Send 7k packet in 768 & 128 byte fragments, 128 times.\n"); 128834739Speter printf(" Total of around 8,900 packets\n"); 128922514Sdarrenr for (i = 0; i < 128; i++) { 129022514Sdarrenr /* 129122514Sdarrenr * First send the entire packet in 768 byte chunks. 129222514Sdarrenr */ 129322514Sdarrenr ip->ip_len = sizeof(*ip) + 768 + sizeof(*u); 1294145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 129537074Speter ip->ip_off = htons(IP_MF); 129622514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 129722514Sdarrenr printf("%d %d\r", i, 0); 129822514Sdarrenr fflush(stdout); 129922514Sdarrenr PAUSE(); 130022514Sdarrenr /* 130122514Sdarrenr * And again using 128 byte chunks. 130222514Sdarrenr */ 130322514Sdarrenr ip->ip_len = sizeof(*ip) + 128 + sizeof(*u); 130437074Speter ip->ip_off = htons(IP_MF); 130522514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 130622514Sdarrenr printf("%d %d\r", i, 0); 130722514Sdarrenr fflush(stdout); 130822514Sdarrenr PAUSE(); 130922514Sdarrenr 131022514Sdarrenr for (j = 768; j < 3584; j += 768) { 131122514Sdarrenr ip->ip_len = sizeof(*ip) + 768; 1312145519Sdarrenr ip->ip_off = htons(IP_MF|(j>>3)); 131322514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 131422514Sdarrenr printf("%d %d\r", i, j); 131522514Sdarrenr fflush(stdout); 131622514Sdarrenr PAUSE(); 131722514Sdarrenr 131822514Sdarrenr ip->ip_len = sizeof(*ip) + 128; 131922514Sdarrenr for (k = j - 768; k < j; k += 128) { 1320145519Sdarrenr ip->ip_off = htons(IP_MF|(k>>3)); 132122514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 132222514Sdarrenr printf("%d %d\r", i, k); 132322514Sdarrenr fflush(stdout); 132422514Sdarrenr PAUSE(); 132522514Sdarrenr } 132622514Sdarrenr } 132722514Sdarrenr } 132822514Sdarrenr putchar('\n'); 132922514Sdarrenr} 133022514Sdarrenr 133122514Sdarrenr 133222514Sdarrenr/* Perform test 7 (random packets) */ 133322514Sdarrenr 133422514Sdarrenrstatic u_long tbuf[64]; 133522514Sdarrenr 133622514Sdarrenrvoid ip_test7(dev, mtu, ip, gwip, ptest) 133722514Sdarrenrchar *dev; 133822514Sdarrenrint mtu; 133922514Sdarrenrip_t *ip; 134022514Sdarrenrstruct in_addr gwip; 134122514Sdarrenrint ptest; 134222514Sdarrenr{ 1343145519Sdarrenr ip_t *pip; 1344145519Sdarrenr#ifdef USE_NANOSLEEP 1345110920Sdarrenr struct timespec ts; 1346110920Sdarrenr#else 1347110920Sdarrenr struct timeval tv; 1348110920Sdarrenr#endif 134922514Sdarrenr int nfd, i, j; 135022514Sdarrenr u_char *s; 135122514Sdarrenr 1352145519Sdarrenr nfd = initdevice(dev, 1); 135322514Sdarrenr pip = (ip_t *)tbuf; 135422514Sdarrenr 135522514Sdarrenr srand(time(NULL) ^ (getpid() * getppid())); 135622514Sdarrenr 135722514Sdarrenr printf("7. send 1024 random IP packets.\n"); 135822514Sdarrenr 135922514Sdarrenr for (i = 0; i < 512; i++) { 136022514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 136122514Sdarrenr *s = (rand() >> 13) & 0xff; 1362145519Sdarrenr IP_V_A(pip, IPVERSION); 136322514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 136422514Sdarrenr sizeof(struct in_addr)); 136522514Sdarrenr pip->ip_sum = 0; 136622514Sdarrenr pip->ip_len &= 0xff; 136722514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 136822514Sdarrenr printf("%d\r", i); 136922514Sdarrenr fflush(stdout); 137022514Sdarrenr PAUSE(); 137122514Sdarrenr } 137222514Sdarrenr putchar('\n'); 137322514Sdarrenr 137422514Sdarrenr for (i = 0; i < 512; i++) { 137522514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 137622514Sdarrenr *s = (rand() >> 13) & 0xff; 1377145519Sdarrenr IP_V_A(pip, IPVERSION); 137837074Speter pip->ip_off &= htons(0xc000); 137922514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 138022514Sdarrenr sizeof(struct in_addr)); 138122514Sdarrenr pip->ip_sum = 0; 138222514Sdarrenr pip->ip_len &= 0xff; 138322514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 138422514Sdarrenr printf("%d\r", i); 138522514Sdarrenr fflush(stdout); 138622514Sdarrenr PAUSE(); 138722514Sdarrenr } 138822514Sdarrenr putchar('\n'); 138922514Sdarrenr} 1390