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