1145519Sdarrenr/* $FreeBSD$ */ 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"; 11172776Sdarrenrstatic const char rcsid[] = "@(#)$Id: iptests.c,v 2.8.2.9 2007/09/13 07:19:34 darrenr Exp $"; 1292691Sdarrenr#endif 13145519Sdarrenr#include <sys/param.h> 1422514Sdarrenr#include <sys/types.h> 15161357Sguido#if defined(__NetBSD__) && defined(__vax__) 16161357Sguido/* 17161357Sguido * XXX need to declare boolean_t for _KERNEL <sys/files.h> 18161357Sguido * which ends up including <sys/device.h> for vax. See PR#32907 19161357Sguido * for further details. 20161357Sguido */ 21161357Sguidotypedef int boolean_t; 22161357Sguido#endif 2322514Sdarrenr#include <sys/time.h> 24145519Sdarrenr#if !defined(__osf__) 25172776Sdarrenr# ifdef __NetBSD__ 26172776Sdarrenr# include <machine/lock.h> 27180778Sdarrenr# include <machine/mutex.h> 28172776Sdarrenr# endif 29145519Sdarrenr# define _KERNEL 30145519Sdarrenr# define KERNEL 31145519Sdarrenr# if !defined(solaris) && !defined(linux) && !defined(__sgi) && !defined(hpux) 32145519Sdarrenr# include <sys/file.h> 33145519Sdarrenr# else 34145519Sdarrenr# ifdef solaris 35145519Sdarrenr# include <sys/dditypes.h> 36145519Sdarrenr# endif 3753024Sguido# endif 38145519Sdarrenr# undef _KERNEL 39145519Sdarrenr# undef KERNEL 4053024Sguido#endif 4153024Sguido#if !defined(solaris) && !defined(linux) && !defined(__sgi) 4222514Sdarrenr# include <nlist.h> 4322514Sdarrenr# include <sys/user.h> 4422514Sdarrenr# include <sys/proc.h> 4522514Sdarrenr#endif 46145519Sdarrenr#if !defined(ultrix) && !defined(hpux) && !defined(linux) && \ 47153881Sguido !defined(__sgi) && !defined(__osf__) && !defined(_AIX51) 4831183Speter# include <kvm.h> 4931183Speter#endif 5031183Speter#ifndef ultrix 5131183Speter# include <sys/socket.h> 5231183Speter#endif 5326119Sdarrenr#if defined(solaris) 5426119Sdarrenr# include <sys/stream.h> 5526119Sdarrenr#endif 5622514Sdarrenr#include <sys/socketvar.h> 5722514Sdarrenr#ifdef sun 5822514Sdarrenr#include <sys/systm.h> 5922514Sdarrenr#include <sys/session.h> 6022514Sdarrenr#endif 6122514Sdarrenr#if BSD >= 199103 6231183Speter# include <sys/sysctl.h> 6331183Speter# include <sys/filedesc.h> 6431183Speter# include <paths.h> 6522514Sdarrenr#endif 6622514Sdarrenr#include <netinet/in_systm.h> 6722514Sdarrenr#include <sys/socket.h> 68145519Sdarrenr#ifdef __hpux 69145519Sdarrenr# define _NET_ROUTE_INCLUDED 70145519Sdarrenr#endif 71170268Sdarrenr#ifdef __osf__ 72170268Sdarrenr# include "radix_ipf_local.h" 73170268Sdarrenr#endif 7422514Sdarrenr#include <net/if.h> 7531183Speter#if defined(linux) && (LINUX >= 0200) 7631183Speter# include <asm/atomic.h> 7731183Speter#endif 7831183Speter#if !defined(linux) 79145519Sdarrenr# if defined(__FreeBSD__) 80145519Sdarrenr# include "radix_ipf.h" 81145519Sdarrenr# endif 8231183Speter# include <net/route.h> 8331183Speter#else 8431183Speter# define __KERNEL__ /* because there's a macro not wrapped by this */ 8531183Speter# include <net/route.h> /* in this file :-/ */ 8631183Speter#endif 8722514Sdarrenr#include <netinet/in.h> 8822514Sdarrenr#include <arpa/inet.h> 8922514Sdarrenr#include <netinet/ip.h> 90145519Sdarrenr#if !defined(linux) 9131183Speter# include <netinet/ip_var.h> 92145519Sdarrenr# if !defined(__hpux) 93145519Sdarrenr# include <netinet/in_pcb.h> 94145519Sdarrenr# endif 9531183Speter#endif 9631183Speter#if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 9731183Speter# include <sys/sysmacros.h> 9831183Speter#endif 99145519Sdarrenr#include <stdio.h> 100145519Sdarrenr#include <unistd.h> 101145519Sdarrenr#include <stdlib.h> 102145519Sdarrenr#include <string.h> 103145519Sdarrenr#ifdef __hpux 104145519Sdarrenr# undef _NET_ROUTE_INCLUDED 105110920Sdarrenr#endif 10624583Sdarrenr#include "ipsend.h" 107145519Sdarrenr#if !defined(linux) && !defined(__hpux) 108145519Sdarrenr# include <netinet/tcp_timer.h> 109145519Sdarrenr# include <netinet/tcp_var.h> 11080490Sdarrenr#endif 111145519Sdarrenr#if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 106000000) 112145519Sdarrenr# define USE_NANOSLEEP 11384843Sbde#endif 11424583Sdarrenr 11580490Sdarrenr 116145519Sdarrenr#ifdef USE_NANOSLEEP 117145519Sdarrenr# define PAUSE() ts.tv_sec = 0; ts.tv_nsec = 10000000; \ 118110920Sdarrenr (void) nanosleep(&ts, NULL) 119110920Sdarrenr#else 120110920Sdarrenr# define PAUSE() tv.tv_sec = 0; tv.tv_usec = 10000; \ 121145519Sdarrenr (void) select(0, NULL, NULL, NULL, &tv) 122110920Sdarrenr#endif 12322514Sdarrenr 12422514Sdarrenr 12522514Sdarrenrvoid ip_test1(dev, mtu, ip, gwip, ptest) 12622514Sdarrenrchar *dev; 12722514Sdarrenrint mtu; 12822514Sdarrenrip_t *ip; 12922514Sdarrenrstruct in_addr gwip; 13022514Sdarrenrint ptest; 13122514Sdarrenr{ 132145519Sdarrenr#ifdef USE_NANOSLEEP 133110920Sdarrenr struct timespec ts; 134110920Sdarrenr#else 13522514Sdarrenr struct timeval tv; 136110920Sdarrenr#endif 13722514Sdarrenr udphdr_t *u; 13831183Speter int nfd, i = 0, len, id = getpid(); 13922514Sdarrenr 140145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 141145519Sdarrenr IP_V_A(ip, IPVERSION); 14222514Sdarrenr ip->ip_tos = 0; 14322514Sdarrenr ip->ip_off = 0; 14422514Sdarrenr ip->ip_ttl = 60; 14522514Sdarrenr ip->ip_p = IPPROTO_UDP; 14622514Sdarrenr ip->ip_sum = 0; 14722514Sdarrenr u = (udphdr_t *)(ip + 1); 14837074Speter u->uh_sport = htons(1); 14937074Speter u->uh_dport = htons(9); 15022514Sdarrenr u->uh_sum = 0; 15137074Speter u->uh_ulen = htons(sizeof(*u) + 4); 15237074Speter ip->ip_len = sizeof(*ip) + ntohs(u->uh_ulen); 15322514Sdarrenr len = ip->ip_len; 154161357Sguido 155145519Sdarrenr nfd = initdevice(dev, 1); 156161357Sguido if (nfd == -1) 157161357Sguido return; 15822514Sdarrenr 15922514Sdarrenr if (!ptest || (ptest == 1)) { 16022514Sdarrenr /* 16122514Sdarrenr * Part1: hl < len 16222514Sdarrenr */ 16322514Sdarrenr ip->ip_id = 0; 16422514Sdarrenr printf("1.1. sending packets with ip_hl < ip_len\n"); 16537074Speter for (i = 0; i < ((sizeof(*ip) + ntohs(u->uh_ulen)) >> 2); i++) { 166145519Sdarrenr IP_HL_A(ip, i >> 2); 16722514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 16822514Sdarrenr printf("%d\r", i); 16922514Sdarrenr fflush(stdout); 17022514Sdarrenr PAUSE(); 17122514Sdarrenr } 17222514Sdarrenr putchar('\n'); 17322514Sdarrenr } 17422514Sdarrenr 17522514Sdarrenr if (!ptest || (ptest == 2)) { 17622514Sdarrenr /* 17722514Sdarrenr * Part2: hl > len 17822514Sdarrenr */ 17922514Sdarrenr ip->ip_id = 0; 18022514Sdarrenr printf("1.2. sending packets with ip_hl > ip_len\n"); 18137074Speter for (; i < ((sizeof(*ip) * 2 + ntohs(u->uh_ulen)) >> 2); i++) { 182145519Sdarrenr IP_HL_A(ip, i >> 2); 18322514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 18422514Sdarrenr printf("%d\r", i); 18522514Sdarrenr fflush(stdout); 18622514Sdarrenr PAUSE(); 18722514Sdarrenr } 18822514Sdarrenr putchar('\n'); 18922514Sdarrenr } 19022514Sdarrenr 19122514Sdarrenr if (!ptest || (ptest == 3)) { 19222514Sdarrenr /* 19322514Sdarrenr * Part3: v < 4 19422514Sdarrenr */ 19522514Sdarrenr ip->ip_id = 0; 19622514Sdarrenr printf("1.3. ip_v < 4\n"); 197145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 19822514Sdarrenr for (i = 0; i < 4; i++) { 199145519Sdarrenr IP_V_A(ip, i); 20022514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 20122514Sdarrenr printf("%d\r", i); 20222514Sdarrenr fflush(stdout); 20322514Sdarrenr PAUSE(); 20422514Sdarrenr } 20522514Sdarrenr putchar('\n'); 20622514Sdarrenr } 20722514Sdarrenr 20822514Sdarrenr if (!ptest || (ptest == 4)) { 20922514Sdarrenr /* 21022514Sdarrenr * Part4: v > 4 21122514Sdarrenr */ 21222514Sdarrenr ip->ip_id = 0; 21322514Sdarrenr printf("1.4. ip_v > 4\n"); 21422514Sdarrenr for (i = 5; i < 16; i++) { 215145519Sdarrenr IP_V_A(ip, i); 21622514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 21722514Sdarrenr printf("%d\r", i); 21822514Sdarrenr fflush(stdout); 21922514Sdarrenr PAUSE(); 22022514Sdarrenr } 22122514Sdarrenr putchar('\n'); 22222514Sdarrenr } 22322514Sdarrenr 22422514Sdarrenr if (!ptest || (ptest == 5)) { 22522514Sdarrenr /* 22622514Sdarrenr * Part5: len < packet 22722514Sdarrenr */ 22822514Sdarrenr ip->ip_id = 0; 229145519Sdarrenr IP_V_A(ip, IPVERSION); 23022514Sdarrenr i = ip->ip_len + 1; 23122514Sdarrenr printf("1.5.0 ip_len < packet size (size++, long packets)\n"); 23237074Speter for (; i < (ip->ip_len * 2); i++) { 23322514Sdarrenr ip->ip_id = htons(id++); 23422514Sdarrenr ip->ip_sum = 0; 235145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 23624583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 23722514Sdarrenr printf("%d\r", i); 23822514Sdarrenr fflush(stdout); 23922514Sdarrenr PAUSE(); 24022514Sdarrenr } 24122514Sdarrenr putchar('\n'); 24222514Sdarrenr printf("1.5.1 ip_len < packet size (ip_len-, short packets)\n"); 24322514Sdarrenr for (i = len; i > 0; i--) { 24422514Sdarrenr ip->ip_id = htons(id++); 24537074Speter ip->ip_len = i; 24622514Sdarrenr ip->ip_sum = 0; 247145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 24824583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 24922514Sdarrenr printf("%d\r", i); 25022514Sdarrenr fflush(stdout); 25122514Sdarrenr PAUSE(); 25222514Sdarrenr } 25322514Sdarrenr putchar('\n'); 25422514Sdarrenr } 25522514Sdarrenr 25622514Sdarrenr if (!ptest || (ptest == 6)) { 25722514Sdarrenr /* 25822514Sdarrenr * Part6: len > packet 25922514Sdarrenr */ 26022514Sdarrenr ip->ip_id = 0; 26122514Sdarrenr printf("1.6.0 ip_len > packet size (increase ip_len)\n"); 26222514Sdarrenr for (i = len + 1; i < (len * 2); i++) { 26322514Sdarrenr ip->ip_id = htons(id++); 26437074Speter ip->ip_len = i; 26522514Sdarrenr ip->ip_sum = 0; 266145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 26724583Sdarrenr (void) send_ether(nfd, (char *)ip, len, gwip); 26822514Sdarrenr printf("%d\r", i); 26922514Sdarrenr fflush(stdout); 27022514Sdarrenr PAUSE(); 27122514Sdarrenr } 27222514Sdarrenr putchar('\n'); 27337074Speter ip->ip_len = len; 27422514Sdarrenr printf("1.6.1 ip_len > packet size (size--, short packets)\n"); 27522514Sdarrenr for (i = len; i > 0; i--) { 27622514Sdarrenr ip->ip_id = htons(id++); 27722514Sdarrenr ip->ip_sum = 0; 278145519Sdarrenr ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2); 27924583Sdarrenr (void) send_ether(nfd, (char *)ip, i, gwip); 28022514Sdarrenr printf("%d\r", i); 28122514Sdarrenr fflush(stdout); 28222514Sdarrenr PAUSE(); 28322514Sdarrenr } 28422514Sdarrenr putchar('\n'); 28522514Sdarrenr } 28622514Sdarrenr 28722514Sdarrenr if (!ptest || (ptest == 7)) { 28822514Sdarrenr /* 28922514Sdarrenr * Part7: 0 length fragment 29022514Sdarrenr */ 29122514Sdarrenr printf("1.7.0 Zero length fragments (ip_off = 0x2000)\n"); 29222514Sdarrenr ip->ip_id = 0; 29322514Sdarrenr ip->ip_len = sizeof(*ip); 29422514Sdarrenr ip->ip_off = htons(IP_MF); 29522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 29622514Sdarrenr fflush(stdout); 29722514Sdarrenr PAUSE(); 29822514Sdarrenr 29922514Sdarrenr printf("1.7.1 Zero length fragments (ip_off = 0x3000)\n"); 30022514Sdarrenr ip->ip_id = 0; 30122514Sdarrenr ip->ip_len = sizeof(*ip); 30222514Sdarrenr ip->ip_off = htons(IP_MF); 30322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 30422514Sdarrenr fflush(stdout); 30522514Sdarrenr PAUSE(); 30622514Sdarrenr 30722514Sdarrenr printf("1.7.2 Zero length fragments (ip_off = 0xa000)\n"); 30822514Sdarrenr ip->ip_id = 0; 30922514Sdarrenr ip->ip_len = sizeof(*ip); 31022514Sdarrenr ip->ip_off = htons(0xa000); 31122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 31222514Sdarrenr fflush(stdout); 31322514Sdarrenr PAUSE(); 31422514Sdarrenr 31522514Sdarrenr printf("1.7.3 Zero length fragments (ip_off = 0x0100)\n"); 31622514Sdarrenr ip->ip_id = 0; 31722514Sdarrenr ip->ip_len = sizeof(*ip); 31822514Sdarrenr ip->ip_off = htons(0x0100); 31922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 32022514Sdarrenr fflush(stdout); 32122514Sdarrenr PAUSE(); 32222514Sdarrenr } 32322514Sdarrenr 32422514Sdarrenr if (!ptest || (ptest == 8)) { 32522514Sdarrenr struct timeval tv; 32622514Sdarrenr 32722514Sdarrenr gettimeofday(&tv, NULL); 32822514Sdarrenr srand(tv.tv_sec ^ getpid() ^ tv.tv_usec); 32922514Sdarrenr /* 33022514Sdarrenr * Part8.1: 63k packet + 1k fragment at offset 0x1ffe 33122514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 33222514Sdarrenr * don't bother about the ICMP header, we're not worrying 33322514Sdarrenr * about that here. 33422514Sdarrenr */ 33522514Sdarrenr ip->ip_p = IPPROTO_ICMP; 33637074Speter ip->ip_off = htons(IP_MF); 33722514Sdarrenr u->uh_dport = htons(9); 33822514Sdarrenr ip->ip_id = htons(id++); 33922514Sdarrenr printf("1.8.1 63k packet + 1k fragment at offset 0x1ffe\n"); 34022514Sdarrenr ip->ip_len = 768 + 20 + 8; 34122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 34222514Sdarrenr printf("%d\r", i); 34322514Sdarrenr 34422514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 34522514Sdarrenr i = 512; 34622514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 347145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 34822514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 34922514Sdarrenr printf("%d\r", i); 35022514Sdarrenr fflush(stdout); 35122514Sdarrenr PAUSE(); 35222514Sdarrenr } 35322514Sdarrenr ip->ip_len = 896 + 20; 354145519Sdarrenr ip->ip_off = htons(i >> 3); 35522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 35622514Sdarrenr printf("%d\r", i); 35722514Sdarrenr putchar('\n'); 35822514Sdarrenr fflush(stdout); 35922514Sdarrenr 36022514Sdarrenr /* 36122514Sdarrenr * Part8.2: 63k packet + 1k fragment at offset 0x1ffe 36222514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 36322514Sdarrenr * don't bother about the ICMP header, we're not worrying 36422514Sdarrenr * about that here. (Lossage here) 36522514Sdarrenr */ 36622514Sdarrenr ip->ip_p = IPPROTO_ICMP; 36737074Speter ip->ip_off = htons(IP_MF); 36822514Sdarrenr u->uh_dport = htons(9); 36922514Sdarrenr ip->ip_id = htons(id++); 37022514Sdarrenr printf("1.8.2 63k packet + 1k fragment at offset 0x1ffe\n"); 37122514Sdarrenr ip->ip_len = 768 + 20 + 8; 37222514Sdarrenr if ((rand() & 0x1f) != 0) { 37322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 37422514Sdarrenr printf("%d\r", i); 37522514Sdarrenr } else 37622514Sdarrenr printf("skip 0\n"); 37722514Sdarrenr 37822514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 37922514Sdarrenr i = 512; 38022514Sdarrenr for (; i < (63 * 1024 + 768); i += 768) { 381145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 38222514Sdarrenr if ((rand() & 0x1f) != 0) { 38322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 38422514Sdarrenr printf("%d\r", i); 38522514Sdarrenr } else 38622514Sdarrenr printf("skip %d\n", i); 38722514Sdarrenr fflush(stdout); 38822514Sdarrenr PAUSE(); 38922514Sdarrenr } 39022514Sdarrenr ip->ip_len = 896 + 20; 391145519Sdarrenr ip->ip_off = htons(i >> 3); 39222514Sdarrenr if ((rand() & 0x1f) != 0) { 39322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 39422514Sdarrenr printf("%d\r", i); 39522514Sdarrenr } else 39622514Sdarrenr printf("skip\n"); 39722514Sdarrenr putchar('\n'); 39822514Sdarrenr fflush(stdout); 39922514Sdarrenr 40022514Sdarrenr /* 40122514Sdarrenr * Part8.3: 33k packet - test for not dealing with -ve length 40222514Sdarrenr * Mark it as being ICMP (so it doesn't get junked), but 40322514Sdarrenr * don't bother about the ICMP header, we're not worrying 40422514Sdarrenr * about that here. 40522514Sdarrenr */ 40622514Sdarrenr ip->ip_p = IPPROTO_ICMP; 40737074Speter ip->ip_off = htons(IP_MF); 40822514Sdarrenr u->uh_dport = htons(9); 40922514Sdarrenr ip->ip_id = htons(id++); 41022514Sdarrenr printf("1.8.3 33k packet\n"); 41122514Sdarrenr ip->ip_len = 768 + 20 + 8; 41222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 41322514Sdarrenr printf("%d\r", i); 41422514Sdarrenr 41522514Sdarrenr ip->ip_len = MIN(768 + 20, mtu - 68); 41622514Sdarrenr i = 512; 41722514Sdarrenr for (; i < (32 * 1024 + 768); i += 768) { 418145519Sdarrenr ip->ip_off = htons(IP_MF | (i >> 3)); 41922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 42022514Sdarrenr printf("%d\r", i); 42122514Sdarrenr fflush(stdout); 42222514Sdarrenr PAUSE(); 42322514Sdarrenr } 42422514Sdarrenr ip->ip_len = 896 + 20; 425145519Sdarrenr ip->ip_off = htons(i >> 3); 42622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 42722514Sdarrenr printf("%d\r", i); 42822514Sdarrenr putchar('\n'); 42922514Sdarrenr fflush(stdout); 43022514Sdarrenr } 43122514Sdarrenr 43222514Sdarrenr ip->ip_len = len; 43322514Sdarrenr ip->ip_off = 0; 43422514Sdarrenr if (!ptest || (ptest == 9)) { 43522514Sdarrenr /* 43622514Sdarrenr * Part9: off & 0x8000 == 0x8000 43722514Sdarrenr */ 43822514Sdarrenr ip->ip_id = 0; 43937074Speter ip->ip_off = htons(0x8000); 44022514Sdarrenr printf("1.9. ip_off & 0x8000 == 0x8000\n"); 44122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 44222514Sdarrenr fflush(stdout); 44322514Sdarrenr PAUSE(); 44422514Sdarrenr } 44522514Sdarrenr 44622514Sdarrenr ip->ip_off = 0; 44722514Sdarrenr 44822514Sdarrenr if (!ptest || (ptest == 10)) { 44922514Sdarrenr /* 45022514Sdarrenr * Part10: ttl = 255 45122514Sdarrenr */ 45222514Sdarrenr ip->ip_id = 0; 45322514Sdarrenr ip->ip_ttl = 255; 45422514Sdarrenr printf("1.10.0 ip_ttl = 255\n"); 45522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 45622514Sdarrenr fflush(stdout); 45722514Sdarrenr PAUSE(); 45822514Sdarrenr 45922514Sdarrenr ip->ip_ttl = 128; 46022514Sdarrenr printf("1.10.1 ip_ttl = 128\n"); 46122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 46222514Sdarrenr fflush(stdout); 46322514Sdarrenr PAUSE(); 46422514Sdarrenr 46522514Sdarrenr ip->ip_ttl = 0; 46622514Sdarrenr printf("1.10.2 ip_ttl = 0\n"); 46722514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 46822514Sdarrenr fflush(stdout); 46922514Sdarrenr PAUSE(); 47022514Sdarrenr } 47122514Sdarrenr 47222514Sdarrenr (void) close(nfd); 47322514Sdarrenr} 47422514Sdarrenr 47522514Sdarrenr 47622514Sdarrenrvoid ip_test2(dev, mtu, ip, gwip, ptest) 47722514Sdarrenrchar *dev; 47822514Sdarrenrint mtu; 47922514Sdarrenrip_t *ip; 48022514Sdarrenrstruct in_addr gwip; 48122514Sdarrenrint ptest; 48222514Sdarrenr{ 483145519Sdarrenr#ifdef USE_NANOSLEEP 484110920Sdarrenr struct timespec ts; 485110920Sdarrenr#else 48622514Sdarrenr struct timeval tv; 487110920Sdarrenr#endif 48822514Sdarrenr int nfd; 48922514Sdarrenr u_char *s; 49022514Sdarrenr 491161357Sguido 492145519Sdarrenr nfd = initdevice(dev, 1); 493161357Sguido if (nfd == -1) 494161357Sguido return; 49522514Sdarrenr 496145519Sdarrenr IP_HL_A(ip, 6); 497145519Sdarrenr ip->ip_len = IP_HL(ip) << 2; 498161357Sguido s = (u_char *)(ip + 1); 49922514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_NOP; 50022514Sdarrenr s++; 50122514Sdarrenr if (!ptest || (ptest == 1)) { 50222514Sdarrenr /* 50322514Sdarrenr * Test 1: option length > packet length, 50422514Sdarrenr * header length == packet length 50522514Sdarrenr */ 50622514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 50722514Sdarrenr s[IPOPT_OLEN] = 4; 50822514Sdarrenr s[IPOPT_OFFSET] = IPOPT_MINOFF; 50922514Sdarrenr ip->ip_p = IPPROTO_IP; 51022514Sdarrenr printf("2.1 option length > packet length\n"); 51122514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 51222514Sdarrenr fflush(stdout); 51322514Sdarrenr PAUSE(); 51422514Sdarrenr } 51522514Sdarrenr 516145519Sdarrenr IP_HL_A(ip, 7); 517145519Sdarrenr ip->ip_len = IP_HL(ip) << 2; 51822514Sdarrenr if (!ptest || (ptest == 1)) { 51922514Sdarrenr /* 52022514Sdarrenr * Test 2: options have length = 0 52122514Sdarrenr */ 52222514Sdarrenr printf("2.2.1 option length = 0, RR\n"); 52322514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_RR; 52422514Sdarrenr s[IPOPT_OLEN] = 0; 52522514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 52622514Sdarrenr fflush(stdout); 52722514Sdarrenr PAUSE(); 52822514Sdarrenr 52922514Sdarrenr printf("2.2.2 option length = 0, TS\n"); 53022514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_TS; 53122514Sdarrenr s[IPOPT_OLEN] = 0; 53222514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 53322514Sdarrenr fflush(stdout); 53422514Sdarrenr PAUSE(); 53522514Sdarrenr 53622514Sdarrenr printf("2.2.3 option length = 0, SECURITY\n"); 53722514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SECURITY; 53822514Sdarrenr s[IPOPT_OLEN] = 0; 53922514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 54022514Sdarrenr fflush(stdout); 54122514Sdarrenr PAUSE(); 54222514Sdarrenr 54322514Sdarrenr printf("2.2.4 option length = 0, LSRR\n"); 54422514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_LSRR; 54522514Sdarrenr s[IPOPT_OLEN] = 0; 54622514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 54722514Sdarrenr fflush(stdout); 54822514Sdarrenr PAUSE(); 54922514Sdarrenr 55022514Sdarrenr printf("2.2.5 option length = 0, SATID\n"); 55122514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SATID; 55222514Sdarrenr s[IPOPT_OLEN] = 0; 55322514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 55422514Sdarrenr fflush(stdout); 55522514Sdarrenr PAUSE(); 55622514Sdarrenr 55722514Sdarrenr printf("2.2.6 option length = 0, SSRR\n"); 55822514Sdarrenr s[IPOPT_OPTVAL] = IPOPT_SSRR; 55922514Sdarrenr s[IPOPT_OLEN] = 0; 56022514Sdarrenr (void) send_ip(nfd, mtu, ip, gwip, 1); 56122514Sdarrenr fflush(stdout); 56222514Sdarrenr PAUSE(); 56322514Sdarrenr } 56422514Sdarrenr 56522514Sdarrenr (void) close(nfd); 56622514Sdarrenr} 56722514Sdarrenr 56822514Sdarrenr 56922514Sdarrenr/* 57022514Sdarrenr * test 3 (ICMP) 57122514Sdarrenr */ 57222514Sdarrenrvoid ip_test3(dev, mtu, ip, gwip, ptest) 57322514Sdarrenrchar *dev; 57422514Sdarrenrint mtu; 57522514Sdarrenrip_t *ip; 57622514Sdarrenrstruct in_addr gwip; 57722514Sdarrenrint ptest; 57822514Sdarrenr{ 57922514Sdarrenr static int ict1[10] = { 8, 9, 10, 13, 14, 15, 16, 17, 18, 0 }; 58022514Sdarrenr static int ict2[8] = { 3, 9, 10, 13, 14, 17, 18, 0 }; 581145519Sdarrenr#ifdef USE_NANOSLEEP 582110920Sdarrenr struct timespec ts; 583110920Sdarrenr#else 58422514Sdarrenr struct timeval tv; 585110920Sdarrenr#endif 58622514Sdarrenr struct icmp *icp; 58722514Sdarrenr int nfd, i; 58822514Sdarrenr 589145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 590145519Sdarrenr IP_V_A(ip, IPVERSION); 59122514Sdarrenr ip->ip_tos = 0; 59222514Sdarrenr ip->ip_off = 0; 59322514Sdarrenr ip->ip_ttl = 60; 59422514Sdarrenr ip->ip_p = IPPROTO_ICMP; 59522514Sdarrenr ip->ip_sum = 0; 59622514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp); 597145519Sdarrenr icp = (struct icmp *)((char *)ip + (IP_HL(ip) << 2)); 598161357Sguido 599145519Sdarrenr nfd = initdevice(dev, 1); 600161357Sguido if (nfd == -1) 601161357Sguido return; 60222514Sdarrenr 60322514Sdarrenr if (!ptest || (ptest == 1)) { 60422514Sdarrenr /* 60522514Sdarrenr * Type 0 - 31, 255, code = 0 60622514Sdarrenr */ 60722514Sdarrenr bzero((char *)icp, sizeof(*icp)); 60822514Sdarrenr for (i = 0; i < 32; i++) { 60922514Sdarrenr icp->icmp_type = i; 61022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 61122514Sdarrenr PAUSE(); 61222514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, i); 61322514Sdarrenr } 61422514Sdarrenr icp->icmp_type = 255; 61522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 61622514Sdarrenr PAUSE(); 61722514Sdarrenr printf("3.1.%d ICMP type %d code 0 (all 0's)\r", i, 255); 61822514Sdarrenr putchar('\n'); 61922514Sdarrenr } 62022514Sdarrenr 62122514Sdarrenr if (!ptest || (ptest == 2)) { 62222514Sdarrenr /* 62322514Sdarrenr * Type 3, code = 0 - 31 62422514Sdarrenr */ 62522514Sdarrenr icp->icmp_type = 3; 62622514Sdarrenr for (i = 0; i < 32; i++) { 62722514Sdarrenr icp->icmp_code = i; 62822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 62922514Sdarrenr PAUSE(); 63022514Sdarrenr printf("3.2.%d ICMP type 3 code %d (all 0's)\r", i, i); 63122514Sdarrenr } 63222514Sdarrenr } 63322514Sdarrenr 63422514Sdarrenr if (!ptest || (ptest == 3)) { 63522514Sdarrenr /* 63622514Sdarrenr * Type 4, code = 0,127,128,255 63722514Sdarrenr */ 63822514Sdarrenr icp->icmp_type = 4; 63922514Sdarrenr icp->icmp_code = 0; 64022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64122514Sdarrenr PAUSE(); 64222514Sdarrenr printf("3.3.1 ICMP type 4 code 0 (all 0's)\r"); 64322514Sdarrenr icp->icmp_code = 127; 64422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64522514Sdarrenr PAUSE(); 64622514Sdarrenr printf("3.3.2 ICMP type 4 code 127 (all 0's)\r"); 64722514Sdarrenr icp->icmp_code = 128; 64822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 64922514Sdarrenr PAUSE(); 65022514Sdarrenr printf("3.3.3 ICMP type 4 code 128 (all 0's)\r"); 65122514Sdarrenr icp->icmp_code = 255; 65222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 65322514Sdarrenr PAUSE(); 65422514Sdarrenr printf("3.3.4 ICMP type 4 code 255 (all 0's)\r"); 65522514Sdarrenr } 65622514Sdarrenr 65722514Sdarrenr if (!ptest || (ptest == 4)) { 65822514Sdarrenr /* 65922514Sdarrenr * Type 5, code = 0,127,128,255 66022514Sdarrenr */ 66122514Sdarrenr icp->icmp_type = 5; 66222514Sdarrenr icp->icmp_code = 0; 66322514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66422514Sdarrenr PAUSE(); 66522514Sdarrenr printf("3.4.1 ICMP type 5 code 0 (all 0's)\r"); 66622514Sdarrenr icp->icmp_code = 127; 66722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 66822514Sdarrenr PAUSE(); 66922514Sdarrenr printf("3.4.2 ICMP type 5 code 127 (all 0's)\r"); 67022514Sdarrenr icp->icmp_code = 128; 67122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 67222514Sdarrenr PAUSE(); 67322514Sdarrenr printf("3.4.3 ICMP type 5 code 128 (all 0's)\r"); 67422514Sdarrenr icp->icmp_code = 255; 67522514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 67622514Sdarrenr PAUSE(); 67722514Sdarrenr printf("3.4.4 ICMP type 5 code 255 (all 0's)\r"); 67822514Sdarrenr } 67922514Sdarrenr 68022514Sdarrenr if (!ptest || (ptest == 5)) { 68122514Sdarrenr /* 68222514Sdarrenr * Type 8-10;13-18, code - 0,127,128,255 68322514Sdarrenr */ 68422514Sdarrenr for (i = 0; ict1[i]; i++) { 68522514Sdarrenr icp->icmp_type = ict1[i]; 68622514Sdarrenr icp->icmp_code = 0; 68722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 68822514Sdarrenr PAUSE(); 68922514Sdarrenr printf("3.5.%d ICMP type 5 code 0 (all 0's)\r", 69022514Sdarrenr i * 4); 69122514Sdarrenr icp->icmp_code = 127; 69222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69322514Sdarrenr PAUSE(); 69422514Sdarrenr printf("3.5.%d ICMP type 5 code 127 (all 0's)\r", 69522514Sdarrenr i * 4 + 1); 69622514Sdarrenr icp->icmp_code = 128; 69722514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 69822514Sdarrenr PAUSE(); 69922514Sdarrenr printf("3.5.%d ICMP type 5 code 128 (all 0's)\r", 70022514Sdarrenr i * 4 + 2); 70122514Sdarrenr icp->icmp_code = 255; 70222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 70322514Sdarrenr PAUSE(); 70422514Sdarrenr printf("3.5.%d ICMP type 5 code 255 (all 0's)\r", 70522514Sdarrenr i * 4 + 3); 70622514Sdarrenr } 70722514Sdarrenr putchar('\n'); 70822514Sdarrenr } 70922514Sdarrenr 71022514Sdarrenr if (!ptest || (ptest == 6)) { 71122514Sdarrenr /* 71222514Sdarrenr * Type 12, code - 0,127,128,129,255 71322514Sdarrenr */ 71422514Sdarrenr icp->icmp_type = 12; 71522514Sdarrenr icp->icmp_code = 0; 71622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 71722514Sdarrenr PAUSE(); 71822514Sdarrenr printf("3.6.1 ICMP type 12 code 0 (all 0's)\r"); 71922514Sdarrenr icp->icmp_code = 127; 72022514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72122514Sdarrenr PAUSE(); 72222514Sdarrenr printf("3.6.2 ICMP type 12 code 127 (all 0's)\r"); 72322514Sdarrenr icp->icmp_code = 128; 72422514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72522514Sdarrenr PAUSE(); 72622514Sdarrenr printf("3.6.3 ICMP type 12 code 128 (all 0's)\r"); 72722514Sdarrenr icp->icmp_code = 129; 72822514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 72922514Sdarrenr PAUSE(); 73022514Sdarrenr printf("3.6.4 ICMP type 12 code 129 (all 0's)\r"); 73122514Sdarrenr icp->icmp_code = 255; 73222514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 73322514Sdarrenr PAUSE(); 73422514Sdarrenr printf("3.6.5 ICMP type 12 code 255 (all 0's)\r"); 73522514Sdarrenr putchar('\n'); 73622514Sdarrenr } 73722514Sdarrenr 73822514Sdarrenr if (!ptest || (ptest == 7)) { 73922514Sdarrenr /* 74022514Sdarrenr * Type 3;9-10;13-14;17-18 - shorter packets 74122514Sdarrenr */ 74222514Sdarrenr ip->ip_len = sizeof(*ip) + sizeof(*icp) / 2; 74322514Sdarrenr for (i = 0; ict2[i]; i++) { 74422514Sdarrenr icp->icmp_type = ict1[i]; 74522514Sdarrenr icp->icmp_code = 0; 74622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 74722514Sdarrenr PAUSE(); 74822514Sdarrenr printf("3.5.%d ICMP type %d code 0 (all 0's)\r", 74922514Sdarrenr i * 4, icp->icmp_type); 75022514Sdarrenr icp->icmp_code = 127; 75122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 75222514Sdarrenr PAUSE(); 75322514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 75422514Sdarrenr i * 4 + 1, icp->icmp_type); 75522514Sdarrenr icp->icmp_code = 128; 75622514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 75722514Sdarrenr PAUSE(); 75822514Sdarrenr printf("3.5.%d ICMP type %d code 128 (all 0's)\r", 75922514Sdarrenr i * 4 + 2, icp->icmp_type); 76022514Sdarrenr icp->icmp_code = 255; 76122514Sdarrenr (void) send_icmp(nfd, mtu, ip, gwip); 76222514Sdarrenr PAUSE(); 76322514Sdarrenr printf("3.5.%d ICMP type %d code 127 (all 0's)\r", 76422514Sdarrenr i * 4 + 3, icp->icmp_type); 76522514Sdarrenr } 76622514Sdarrenr putchar('\n'); 76722514Sdarrenr } 76822514Sdarrenr} 76922514Sdarrenr 77022514Sdarrenr 77122514Sdarrenr/* Perform test 4 (UDP) */ 77222514Sdarrenr 77322514Sdarrenrvoid ip_test4(dev, mtu, ip, gwip, ptest) 77422514Sdarrenrchar *dev; 77522514Sdarrenrint mtu; 77622514Sdarrenrip_t *ip; 77722514Sdarrenrstruct in_addr gwip; 77822514Sdarrenrint ptest; 77922514Sdarrenr{ 780145519Sdarrenr#ifdef USE_NANOSLEEP 781110920Sdarrenr struct timespec ts; 782110920Sdarrenr#else 78322514Sdarrenr struct timeval tv; 784110920Sdarrenr#endif 78531183Speter udphdr_t *u; 78622514Sdarrenr int nfd, i; 78722514Sdarrenr 78822514Sdarrenr 789145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 790145519Sdarrenr IP_V_A(ip, IPVERSION); 79122514Sdarrenr ip->ip_tos = 0; 79222514Sdarrenr ip->ip_off = 0; 79322514Sdarrenr ip->ip_ttl = 60; 79422514Sdarrenr ip->ip_p = IPPROTO_UDP; 79522514Sdarrenr ip->ip_sum = 0; 796145519Sdarrenr u = (udphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 79737074Speter u->uh_sport = htons(1); 79837074Speter u->uh_dport = htons(1); 79937074Speter u->uh_ulen = htons(sizeof(*u) + 4); 800161357Sguido 801145519Sdarrenr nfd = initdevice(dev, 1); 802161357Sguido if (nfd == -1) 803161357Sguido return; 80422514Sdarrenr 80522514Sdarrenr if (!ptest || (ptest == 1)) { 80622514Sdarrenr /* 80722514Sdarrenr * Test 1. ulen > packet 80822514Sdarrenr */ 80937074Speter u->uh_ulen = htons(sizeof(*u) + 4); 810145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 81122514Sdarrenr printf("4.1 UDP uh_ulen > packet size - short packets\n"); 81237074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 81337074Speter u->uh_ulen = htons(i); 81422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 81522514Sdarrenr printf("%d\r", i); 81622514Sdarrenr fflush(stdout); 81722514Sdarrenr PAUSE(); 81822514Sdarrenr } 81922514Sdarrenr putchar('\n'); 82022514Sdarrenr } 82122514Sdarrenr 82222514Sdarrenr if (!ptest || (ptest == 2)) { 82322514Sdarrenr /* 82422514Sdarrenr * Test 2. ulen < packet 82522514Sdarrenr */ 82637074Speter u->uh_ulen = htons(sizeof(*u) + 4); 827145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 82822514Sdarrenr printf("4.2 UDP uh_ulen < packet size - short packets\n"); 82937074Speter for (i = ntohs(u->uh_ulen) * 2; i > sizeof(*u) + 4; i--) { 83022514Sdarrenr ip->ip_len = i; 83122514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 83222514Sdarrenr printf("%d\r", i); 83322514Sdarrenr fflush(stdout); 83422514Sdarrenr PAUSE(); 83522514Sdarrenr } 83622514Sdarrenr putchar('\n'); 83722514Sdarrenr } 83822514Sdarrenr 83922514Sdarrenr if (!ptest || (ptest == 3)) { 84022514Sdarrenr /* 84122514Sdarrenr * Test 3: sport = 0, sport = 1, sport = 32767 84222514Sdarrenr * sport = 32768, sport = 65535 84322514Sdarrenr */ 84422514Sdarrenr u->uh_ulen = sizeof(*u) + 4; 845145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 84622514Sdarrenr printf("4.3.1 UDP sport = 0\n"); 84722514Sdarrenr u->uh_sport = 0; 84822514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 84922514Sdarrenr printf("0\n"); 85022514Sdarrenr fflush(stdout); 85122514Sdarrenr PAUSE(); 85222514Sdarrenr printf("4.3.2 UDP sport = 1\n"); 85337074Speter u->uh_sport = htons(1); 85422514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 85522514Sdarrenr printf("1\n"); 85622514Sdarrenr fflush(stdout); 85722514Sdarrenr PAUSE(); 85822514Sdarrenr printf("4.3.3 UDP sport = 32767\n"); 85937074Speter u->uh_sport = htons(32767); 86022514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86122514Sdarrenr printf("32767\n"); 86222514Sdarrenr fflush(stdout); 86322514Sdarrenr PAUSE(); 86422514Sdarrenr printf("4.3.4 UDP sport = 32768\n"); 86537074Speter u->uh_sport = htons(32768); 86622514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 86722514Sdarrenr printf("32768\n"); 86822514Sdarrenr putchar('\n'); 86922514Sdarrenr fflush(stdout); 87022514Sdarrenr PAUSE(); 87122514Sdarrenr printf("4.3.5 UDP sport = 65535\n"); 87237074Speter u->uh_sport = htons(65535); 87322514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 87422514Sdarrenr printf("65535\n"); 87522514Sdarrenr fflush(stdout); 87622514Sdarrenr PAUSE(); 87722514Sdarrenr } 87822514Sdarrenr 87922514Sdarrenr if (!ptest || (ptest == 4)) { 88022514Sdarrenr /* 88122514Sdarrenr * Test 4: dport = 0, dport = 1, dport = 32767 88222514Sdarrenr * dport = 32768, dport = 65535 88322514Sdarrenr */ 88437074Speter u->uh_ulen = ntohs(sizeof(*u) + 4); 88537074Speter u->uh_sport = htons(1); 886145519Sdarrenr ip->ip_len = (IP_HL(ip) << 2) + ntohs(u->uh_ulen); 88722514Sdarrenr printf("4.4.1 UDP dport = 0\n"); 88822514Sdarrenr u->uh_dport = 0; 88922514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 89022514Sdarrenr printf("0\n"); 89122514Sdarrenr fflush(stdout); 89222514Sdarrenr PAUSE(); 89322514Sdarrenr printf("4.4.2 UDP dport = 1\n"); 89437074Speter u->uh_dport = htons(1); 89522514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 89622514Sdarrenr printf("1\n"); 89722514Sdarrenr fflush(stdout); 89822514Sdarrenr PAUSE(); 89922514Sdarrenr printf("4.4.3 UDP dport = 32767\n"); 90037074Speter u->uh_dport = htons(32767); 90122514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 90222514Sdarrenr printf("32767\n"); 90322514Sdarrenr fflush(stdout); 90422514Sdarrenr PAUSE(); 90522514Sdarrenr printf("4.4.4 UDP dport = 32768\n"); 90637074Speter u->uh_dport = htons(32768); 90722514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 90822514Sdarrenr printf("32768\n"); 90922514Sdarrenr fflush(stdout); 91022514Sdarrenr PAUSE(); 91122514Sdarrenr printf("4.4.5 UDP dport = 65535\n"); 91237074Speter u->uh_dport = htons(65535); 91322514Sdarrenr (void) send_udp(nfd, 1500, ip, gwip); 91422514Sdarrenr printf("65535\n"); 91522514Sdarrenr fflush(stdout); 91622514Sdarrenr PAUSE(); 91722514Sdarrenr } 91822514Sdarrenr 91931183Speter if (!ptest || (ptest == 5)) { 92022514Sdarrenr /* 92131183Speter * Test 5: sizeof(ip_t) <= MTU <= sizeof(udphdr_t) + 92231183Speter * sizeof(ip_t) 92322514Sdarrenr */ 92422514Sdarrenr printf("4.5 UDP 20 <= MTU <= 32\n"); 92537074Speter for (i = sizeof(*ip); i <= ntohs(u->uh_ulen); i++) { 92622514Sdarrenr (void) send_udp(nfd, i, ip, gwip); 92722514Sdarrenr printf("%d\r", i); 92822514Sdarrenr fflush(stdout); 92922514Sdarrenr PAUSE(); 93022514Sdarrenr } 93122514Sdarrenr putchar('\n'); 93222514Sdarrenr } 93322514Sdarrenr} 93422514Sdarrenr 93522514Sdarrenr 93622514Sdarrenr/* Perform test 5 (TCP) */ 93722514Sdarrenr 93822514Sdarrenrvoid ip_test5(dev, mtu, ip, gwip, ptest) 93922514Sdarrenrchar *dev; 94022514Sdarrenrint mtu; 94122514Sdarrenrip_t *ip; 94222514Sdarrenrstruct in_addr gwip; 94322514Sdarrenrint ptest; 94422514Sdarrenr{ 945145519Sdarrenr#ifdef USE_NANOSLEEP 946110920Sdarrenr struct timespec ts; 947110920Sdarrenr#else 94822514Sdarrenr struct timeval tv; 949110920Sdarrenr#endif 95022514Sdarrenr tcphdr_t *t; 95122514Sdarrenr int nfd, i; 95222514Sdarrenr 953145519Sdarrenr t = (tcphdr_t *)((char *)ip + (IP_HL(ip) << 2)); 954145519Sdarrenr#if !defined(linux) && !defined(__osf__) 95522514Sdarrenr t->th_x2 = 0; 95631183Speter#endif 957145519Sdarrenr TCP_OFF_A(t, 0); 95837074Speter t->th_sport = htons(1); 95937074Speter t->th_dport = htons(1); 96037074Speter t->th_win = htons(4096); 96122514Sdarrenr t->th_urp = 0; 96222514Sdarrenr t->th_sum = 0; 96337074Speter t->th_seq = htonl(1); 96422514Sdarrenr t->th_ack = 0; 96534739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 966161357Sguido 967145519Sdarrenr nfd = initdevice(dev, 1); 968161357Sguido if (nfd == -1) 969161357Sguido return; 97022514Sdarrenr 97122514Sdarrenr if (!ptest || (ptest == 1)) { 97222514Sdarrenr /* 97322514Sdarrenr * Test 1: flags variations, 0 - 3f 97422514Sdarrenr */ 975145519Sdarrenr TCP_OFF_A(t, sizeof(*t) >> 2); 97622514Sdarrenr printf("5.1 Test TCP flag combinations\n"); 97722514Sdarrenr for (i = 0; i <= (TH_URG|TH_ACK|TH_PUSH|TH_RST|TH_SYN|TH_FIN); 97822514Sdarrenr i++) { 97922514Sdarrenr t->th_flags = i; 98022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 98122514Sdarrenr printf("%d\r", i); 98222514Sdarrenr fflush(stdout); 98322514Sdarrenr PAUSE(); 98422514Sdarrenr } 98522514Sdarrenr putchar('\n'); 98622514Sdarrenr } 98722514Sdarrenr 98822514Sdarrenr if (!ptest || (ptest == 2)) { 98922514Sdarrenr t->th_flags = TH_SYN; 99022514Sdarrenr /* 99122514Sdarrenr * Test 2: seq = 0, seq = 1, seq = 0x7fffffff, seq=0x80000000, 99222514Sdarrenr * seq = 0xa000000, seq = 0xffffffff 99322514Sdarrenr */ 99422514Sdarrenr printf("5.2.1 TCP seq = 0\n"); 99537074Speter t->th_seq = htonl(0); 99622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 99722514Sdarrenr fflush(stdout); 99822514Sdarrenr PAUSE(); 99922514Sdarrenr 100022514Sdarrenr printf("5.2.2 TCP seq = 1\n"); 100137074Speter t->th_seq = htonl(1); 100222514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 100322514Sdarrenr fflush(stdout); 100422514Sdarrenr PAUSE(); 100522514Sdarrenr 100622514Sdarrenr printf("5.2.3 TCP seq = 0x7fffffff\n"); 100737074Speter t->th_seq = htonl(0x7fffffff); 100822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 100922514Sdarrenr fflush(stdout); 101022514Sdarrenr PAUSE(); 101122514Sdarrenr 101222514Sdarrenr printf("5.2.4 TCP seq = 0x80000000\n"); 101337074Speter t->th_seq = htonl(0x80000000); 101422514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 101522514Sdarrenr fflush(stdout); 101622514Sdarrenr PAUSE(); 101722514Sdarrenr 101822514Sdarrenr printf("5.2.5 TCP seq = 0xc0000000\n"); 101937074Speter t->th_seq = htonl(0xc0000000); 102022514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102122514Sdarrenr fflush(stdout); 102222514Sdarrenr PAUSE(); 102322514Sdarrenr 102422514Sdarrenr printf("5.2.6 TCP seq = 0xffffffff\n"); 102537074Speter t->th_seq = htonl(0xffffffff); 102622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 102722514Sdarrenr fflush(stdout); 102822514Sdarrenr PAUSE(); 102922514Sdarrenr } 103022514Sdarrenr 103122514Sdarrenr if (!ptest || (ptest == 3)) { 103222514Sdarrenr t->th_flags = TH_ACK; 103322514Sdarrenr /* 103422514Sdarrenr * Test 3: ack = 0, ack = 1, ack = 0x7fffffff, ack = 0x8000000 103522514Sdarrenr * ack = 0xa000000, ack = 0xffffffff 103622514Sdarrenr */ 103722514Sdarrenr printf("5.3.1 TCP ack = 0\n"); 103822514Sdarrenr t->th_ack = 0; 103922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 104022514Sdarrenr fflush(stdout); 104122514Sdarrenr PAUSE(); 104222514Sdarrenr 104322514Sdarrenr printf("5.3.2 TCP ack = 1\n"); 104437074Speter t->th_ack = htonl(1); 104522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 104622514Sdarrenr fflush(stdout); 104722514Sdarrenr PAUSE(); 104822514Sdarrenr 104922514Sdarrenr printf("5.3.3 TCP ack = 0x7fffffff\n"); 105037074Speter t->th_ack = htonl(0x7fffffff); 105122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105222514Sdarrenr fflush(stdout); 105322514Sdarrenr PAUSE(); 105422514Sdarrenr 105522514Sdarrenr printf("5.3.4 TCP ack = 0x80000000\n"); 105637074Speter t->th_ack = htonl(0x80000000); 105722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 105822514Sdarrenr fflush(stdout); 105922514Sdarrenr PAUSE(); 106022514Sdarrenr 106122514Sdarrenr printf("5.3.5 TCP ack = 0xc0000000\n"); 106237074Speter t->th_ack = htonl(0xc0000000); 106322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 106422514Sdarrenr fflush(stdout); 106522514Sdarrenr PAUSE(); 106622514Sdarrenr 106722514Sdarrenr printf("5.3.6 TCP ack = 0xffffffff\n"); 106837074Speter t->th_ack = htonl(0xffffffff); 106922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 107022514Sdarrenr fflush(stdout); 107122514Sdarrenr PAUSE(); 107222514Sdarrenr } 107322514Sdarrenr 107422514Sdarrenr if (!ptest || (ptest == 4)) { 107522514Sdarrenr t->th_flags = TH_SYN; 107622514Sdarrenr /* 107722514Sdarrenr * Test 4: win = 0, win = 32768, win = 65535 107822514Sdarrenr */ 107922514Sdarrenr printf("5.4.1 TCP win = 0\n"); 108037074Speter t->th_seq = htonl(0); 108122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 108222514Sdarrenr fflush(stdout); 108322514Sdarrenr PAUSE(); 108422514Sdarrenr 108522514Sdarrenr printf("5.4.2 TCP win = 32768\n"); 108637074Speter t->th_seq = htonl(0x7fff); 108722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 108822514Sdarrenr fflush(stdout); 108922514Sdarrenr PAUSE(); 109022514Sdarrenr 109122514Sdarrenr printf("5.4.3 TCP win = 65535\n"); 109237074Speter t->th_win = htons(0xffff); 109322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 109422514Sdarrenr fflush(stdout); 109522514Sdarrenr PAUSE(); 109622514Sdarrenr } 109722514Sdarrenr 109834739Speter#if !defined(linux) && !defined(__SVR4) && !defined(__svr4__) && \ 1099145519Sdarrenr !defined(__sgi) && !defined(__hpux) && !defined(__osf__) 110022514Sdarrenr { 110134739Speter struct tcpcb *tcbp, tcb; 110222514Sdarrenr struct tcpiphdr ti; 110322514Sdarrenr struct sockaddr_in sin; 1104172776Sdarrenr int fd; 1105172776Sdarrenr socklen_t slen; 110622514Sdarrenr 110722514Sdarrenr bzero((char *)&sin, sizeof(sin)); 110822514Sdarrenr 110922514Sdarrenr for (i = 1; i < 63; i++) { 111022514Sdarrenr fd = socket(AF_INET, SOCK_STREAM, 0); 111134739Speter bzero((char *)&sin, sizeof(sin)); 111222514Sdarrenr sin.sin_addr.s_addr = ip->ip_dst.s_addr; 111322514Sdarrenr sin.sin_port = htons(i); 111434739Speter sin.sin_family = AF_INET; 111522514Sdarrenr if (!connect(fd, (struct sockaddr *)&sin, sizeof(sin))) 111622514Sdarrenr break; 111734739Speter close(fd); 111822514Sdarrenr } 111922514Sdarrenr 112022514Sdarrenr if (i == 63) { 112122514Sdarrenr printf("Couldn't open a TCP socket between ports 1 and 63\n"); 112222514Sdarrenr printf("to host %s for test 5 and 6 - skipping.\n", 112322514Sdarrenr inet_ntoa(ip->ip_dst)); 112422514Sdarrenr goto skip_five_and_six; 112522514Sdarrenr } 112622514Sdarrenr 112722514Sdarrenr bcopy((char *)ip, (char *)&ti, sizeof(*ip)); 112834739Speter t->th_dport = htons(i); 112922514Sdarrenr slen = sizeof(sin); 113022514Sdarrenr if (!getsockname(fd, (struct sockaddr *)&sin, &slen)) 113134739Speter t->th_sport = sin.sin_port; 113234739Speter if (!(tcbp = find_tcp(fd, &ti))) { 113322514Sdarrenr printf("Can't find PCB\n"); 113422514Sdarrenr goto skip_five_and_six; 113522514Sdarrenr } 113634739Speter KMCPY(&tcb, tcbp, sizeof(tcb)); 113722514Sdarrenr ti.ti_win = tcb.rcv_adv; 113837074Speter ti.ti_seq = htonl(tcb.snd_nxt - 1); 113922514Sdarrenr ti.ti_ack = tcb.rcv_nxt; 114022514Sdarrenr 114122514Sdarrenr if (!ptest || (ptest == 5)) { 114222514Sdarrenr /* 114322514Sdarrenr * Test 5: urp 114422514Sdarrenr */ 114534739Speter t->th_flags = TH_ACK|TH_URG; 114634739Speter printf("5.5.1 TCP Urgent pointer, sport %hu dport %hu\n", 114734739Speter ntohs(t->th_sport), ntohs(t->th_dport)); 114834739Speter t->th_urp = htons(1); 114922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 115022514Sdarrenr PAUSE(); 115134739Speter 115237074Speter t->th_seq = htonl(tcb.snd_nxt); 115334739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t) + 1; 115434739Speter t->th_urp = htons(0x7fff); 115522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 115622514Sdarrenr PAUSE(); 115734739Speter t->th_urp = htons(0x8000); 115822514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 115922514Sdarrenr PAUSE(); 116034739Speter t->th_urp = htons(0xffff); 116122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 116222514Sdarrenr PAUSE(); 116337074Speter t->th_urp = 0; 116434739Speter t->th_flags &= ~TH_URG; 116534739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 116622514Sdarrenr } 116722514Sdarrenr 116822514Sdarrenr if (!ptest || (ptest == 6)) { 116922514Sdarrenr /* 117022514Sdarrenr * Test 6: data offset, off = 0, off is inside, off is outside 117122514Sdarrenr */ 117234739Speter t->th_flags = TH_ACK; 117334739Speter printf("5.6.1 TCP off = 1-15, len = 40\n"); 117434739Speter for (i = 1; i < 16; i++) { 1175145519Sdarrenr TCP_OFF_A(t, ntohs(i)); 117622514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 117722514Sdarrenr printf("%d\r", i); 117822514Sdarrenr fflush(stdout); 117922514Sdarrenr PAUSE(); 118022514Sdarrenr } 118122514Sdarrenr putchar('\n'); 118234739Speter ip->ip_len = sizeof(ip_t) + sizeof(tcphdr_t); 118322514Sdarrenr } 118422514Sdarrenr 118522514Sdarrenr (void) close(fd); 118622514Sdarrenr } 118722514Sdarrenrskip_five_and_six: 118822514Sdarrenr#endif 118937074Speter t->th_seq = htonl(1); 119037074Speter t->th_ack = htonl(1); 1191145519Sdarrenr TCP_OFF_A(t, 0); 119222514Sdarrenr 119322514Sdarrenr if (!ptest || (ptest == 7)) { 119422514Sdarrenr t->th_flags = TH_SYN; 119522514Sdarrenr /* 119622514Sdarrenr * Test 7: sport = 0, sport = 1, sport = 32767 119722514Sdarrenr * sport = 32768, sport = 65535 119822514Sdarrenr */ 119922514Sdarrenr printf("5.7.1 TCP sport = 0\n"); 120022514Sdarrenr t->th_sport = 0; 120122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120222514Sdarrenr fflush(stdout); 120322514Sdarrenr PAUSE(); 120422514Sdarrenr 120522514Sdarrenr printf("5.7.2 TCP sport = 1\n"); 120637074Speter t->th_sport = htons(1); 120722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 120822514Sdarrenr fflush(stdout); 120922514Sdarrenr PAUSE(); 121022514Sdarrenr 121122514Sdarrenr printf("5.7.3 TCP sport = 32767\n"); 121237074Speter t->th_sport = htons(32767); 121322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 121422514Sdarrenr fflush(stdout); 121522514Sdarrenr PAUSE(); 121622514Sdarrenr 121722514Sdarrenr printf("5.7.4 TCP sport = 32768\n"); 121837074Speter t->th_sport = htons(32768); 121922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 122022514Sdarrenr fflush(stdout); 122122514Sdarrenr PAUSE(); 122222514Sdarrenr 122322514Sdarrenr printf("5.7.5 TCP sport = 65535\n"); 122437074Speter t->th_sport = htons(65535); 122522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 122622514Sdarrenr fflush(stdout); 122722514Sdarrenr PAUSE(); 122822514Sdarrenr } 122922514Sdarrenr 123022514Sdarrenr if (!ptest || (ptest == 8)) { 123137074Speter t->th_sport = htons(1); 123234739Speter t->th_flags = TH_SYN; 123322514Sdarrenr /* 123422514Sdarrenr * Test 8: dport = 0, dport = 1, dport = 32767 123522514Sdarrenr * dport = 32768, dport = 65535 123622514Sdarrenr */ 123722514Sdarrenr printf("5.8.1 TCP dport = 0\n"); 123822514Sdarrenr t->th_dport = 0; 123922514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 124022514Sdarrenr fflush(stdout); 124122514Sdarrenr PAUSE(); 124222514Sdarrenr 124322514Sdarrenr printf("5.8.2 TCP dport = 1\n"); 124437074Speter t->th_dport = htons(1); 124522514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 124622514Sdarrenr fflush(stdout); 124722514Sdarrenr PAUSE(); 124822514Sdarrenr 124922514Sdarrenr printf("5.8.3 TCP dport = 32767\n"); 125037074Speter t->th_dport = htons(32767); 125122514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 125222514Sdarrenr fflush(stdout); 125322514Sdarrenr PAUSE(); 125422514Sdarrenr 125522514Sdarrenr printf("5.8.4 TCP dport = 32768\n"); 125637074Speter t->th_dport = htons(32768); 125722514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 125822514Sdarrenr fflush(stdout); 125922514Sdarrenr PAUSE(); 126022514Sdarrenr 126122514Sdarrenr printf("5.8.5 TCP dport = 65535\n"); 126237074Speter t->th_dport = htons(65535); 126322514Sdarrenr (void) send_tcp(nfd, mtu, ip, gwip); 126422514Sdarrenr fflush(stdout); 126522514Sdarrenr PAUSE(); 126622514Sdarrenr } 126734739Speter 126834739Speter /* LAND attack - self connect, so make src & dst ip/port the same */ 126934739Speter if (!ptest || (ptest == 9)) { 127034739Speter printf("5.9 TCP LAND attack. sport = 25, dport = 25\n"); 127134739Speter /* chose SMTP port 25 */ 127234739Speter t->th_sport = htons(25); 127334739Speter t->th_dport = htons(25); 127434739Speter t->th_flags = TH_SYN; 127534739Speter ip->ip_src = ip->ip_dst; 127634739Speter (void) send_tcp(nfd, mtu, ip, gwip); 127734739Speter fflush(stdout); 127834739Speter PAUSE(); 127934739Speter } 128034739Speter 128122514Sdarrenr /* TCP options header checking */ 128222514Sdarrenr /* 0 length options, etc */ 128322514Sdarrenr} 128422514Sdarrenr 128522514Sdarrenr 128622514Sdarrenr/* Perform test 6 (exhaust mbuf test) */ 128722514Sdarrenr 128822514Sdarrenrvoid ip_test6(dev, mtu, ip, gwip, ptest) 128922514Sdarrenrchar *dev; 129022514Sdarrenrint mtu; 129122514Sdarrenrip_t *ip; 129222514Sdarrenrstruct in_addr gwip; 129322514Sdarrenrint ptest; 129422514Sdarrenr{ 1295145519Sdarrenr#ifdef USE_NANOSLEEP 1296110920Sdarrenr struct timespec ts; 1297110920Sdarrenr#else 129822514Sdarrenr struct timeval tv; 1299110920Sdarrenr#endif 130022514Sdarrenr udphdr_t *u; 130122514Sdarrenr int nfd, i, j, k; 130222514Sdarrenr 1303145519Sdarrenr IP_V_A(ip, IPVERSION); 130422514Sdarrenr ip->ip_tos = 0; 130522514Sdarrenr ip->ip_off = 0; 130622514Sdarrenr ip->ip_ttl = 60; 130722514Sdarrenr ip->ip_p = IPPROTO_UDP; 130822514Sdarrenr ip->ip_sum = 0; 130922514Sdarrenr u = (udphdr_t *)(ip + 1); 131037074Speter u->uh_sport = htons(1); 131137074Speter u->uh_dport = htons(9); 131222514Sdarrenr u->uh_sum = 0; 131322514Sdarrenr 1314145519Sdarrenr nfd = initdevice(dev, 1); 1315161357Sguido if (nfd == -1) 1316161357Sguido return; 1317161357Sguido 131837074Speter u->uh_ulen = htons(7168); 131922514Sdarrenr 132034739Speter printf("6. Exhaustive mbuf test.\n"); 132134739Speter printf(" Send 7k packet in 768 & 128 byte fragments, 128 times.\n"); 132234739Speter printf(" Total of around 8,900 packets\n"); 132322514Sdarrenr for (i = 0; i < 128; i++) { 132422514Sdarrenr /* 132522514Sdarrenr * First send the entire packet in 768 byte chunks. 132622514Sdarrenr */ 132722514Sdarrenr ip->ip_len = sizeof(*ip) + 768 + sizeof(*u); 1328145519Sdarrenr IP_HL_A(ip, sizeof(*ip) >> 2); 132937074Speter ip->ip_off = htons(IP_MF); 133022514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 133122514Sdarrenr printf("%d %d\r", i, 0); 133222514Sdarrenr fflush(stdout); 133322514Sdarrenr PAUSE(); 133422514Sdarrenr /* 133522514Sdarrenr * And again using 128 byte chunks. 133622514Sdarrenr */ 133722514Sdarrenr ip->ip_len = sizeof(*ip) + 128 + sizeof(*u); 133837074Speter ip->ip_off = htons(IP_MF); 133922514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 134022514Sdarrenr printf("%d %d\r", i, 0); 134122514Sdarrenr fflush(stdout); 134222514Sdarrenr PAUSE(); 134322514Sdarrenr 134422514Sdarrenr for (j = 768; j < 3584; j += 768) { 134522514Sdarrenr ip->ip_len = sizeof(*ip) + 768; 1346145519Sdarrenr ip->ip_off = htons(IP_MF|(j>>3)); 134722514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 134822514Sdarrenr printf("%d %d\r", i, j); 134922514Sdarrenr fflush(stdout); 135022514Sdarrenr PAUSE(); 135122514Sdarrenr 135222514Sdarrenr ip->ip_len = sizeof(*ip) + 128; 135322514Sdarrenr for (k = j - 768; k < j; k += 128) { 1354145519Sdarrenr ip->ip_off = htons(IP_MF|(k>>3)); 135522514Sdarrenr (void) send_ip(nfd, 1500, ip, gwip, 1); 135622514Sdarrenr printf("%d %d\r", i, k); 135722514Sdarrenr fflush(stdout); 135822514Sdarrenr PAUSE(); 135922514Sdarrenr } 136022514Sdarrenr } 136122514Sdarrenr } 136222514Sdarrenr putchar('\n'); 136322514Sdarrenr} 136422514Sdarrenr 136522514Sdarrenr 136622514Sdarrenr/* Perform test 7 (random packets) */ 136722514Sdarrenr 136822514Sdarrenrstatic u_long tbuf[64]; 136922514Sdarrenr 137022514Sdarrenrvoid ip_test7(dev, mtu, ip, gwip, ptest) 137122514Sdarrenrchar *dev; 137222514Sdarrenrint mtu; 137322514Sdarrenrip_t *ip; 137422514Sdarrenrstruct in_addr gwip; 137522514Sdarrenrint ptest; 137622514Sdarrenr{ 1377145519Sdarrenr ip_t *pip; 1378145519Sdarrenr#ifdef USE_NANOSLEEP 1379110920Sdarrenr struct timespec ts; 1380110920Sdarrenr#else 1381110920Sdarrenr struct timeval tv; 1382110920Sdarrenr#endif 138322514Sdarrenr int nfd, i, j; 138422514Sdarrenr u_char *s; 138522514Sdarrenr 1386145519Sdarrenr nfd = initdevice(dev, 1); 1387161357Sguido if (nfd == -1) 1388161357Sguido return; 1389161357Sguido 139022514Sdarrenr pip = (ip_t *)tbuf; 139122514Sdarrenr 139222514Sdarrenr srand(time(NULL) ^ (getpid() * getppid())); 139322514Sdarrenr 139422514Sdarrenr printf("7. send 1024 random IP packets.\n"); 139522514Sdarrenr 139622514Sdarrenr for (i = 0; i < 512; i++) { 139722514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 139822514Sdarrenr *s = (rand() >> 13) & 0xff; 1399145519Sdarrenr IP_V_A(pip, IPVERSION); 140022514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 140122514Sdarrenr sizeof(struct in_addr)); 140222514Sdarrenr pip->ip_sum = 0; 140322514Sdarrenr pip->ip_len &= 0xff; 140422514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 140522514Sdarrenr printf("%d\r", i); 140622514Sdarrenr fflush(stdout); 140722514Sdarrenr PAUSE(); 140822514Sdarrenr } 140922514Sdarrenr putchar('\n'); 141022514Sdarrenr 141122514Sdarrenr for (i = 0; i < 512; i++) { 141222514Sdarrenr for (s = (u_char *)pip, j = 0; j < sizeof(tbuf); j++, s++) 141322514Sdarrenr *s = (rand() >> 13) & 0xff; 1414145519Sdarrenr IP_V_A(pip, IPVERSION); 141537074Speter pip->ip_off &= htons(0xc000); 141622514Sdarrenr bcopy((char *)&ip->ip_dst, (char *)&pip->ip_dst, 141722514Sdarrenr sizeof(struct in_addr)); 141822514Sdarrenr pip->ip_sum = 0; 141922514Sdarrenr pip->ip_len &= 0xff; 142022514Sdarrenr (void) send_ip(nfd, mtu, pip, gwip, 0); 142122514Sdarrenr printf("%d\r", i); 142222514Sdarrenr fflush(stdout); 142322514Sdarrenr PAUSE(); 142422514Sdarrenr } 142522514Sdarrenr putchar('\n'); 142622514Sdarrenr} 1427