1 /*-
2 * Copyright (c) 2007 Bruce M. Simpson
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 /*
28 * Regression test utility for RFC 3678 Advanced Multicast API in FreeBSD.
29 *
30 * TODO: Test the SSM paths.
31 * TODO: Support INET6. The code has been written to facilitate this later.
32 * TODO: Merge multicast socket option tests from ipsockopt.
33 */
34
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD: stable/9/tools/regression/netinet/ipmulticast/ipmulticast.c 170614 2007-06-12 16:29:22Z bms $");
37
38 #include <sys/param.h>
39 #include <sys/types.h>
40 #include <sys/ioctl.h>
41 #include <sys/socket.h>
42
43 #include <net/if.h>
44 #include <net/if_dl.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
47 #include <netdb.h>
48
49 #include <assert.h>
50 #include <err.h>
51 #include <errno.h>
52 #include <getopt.h>
53 #include <libgen.h>
54 #include <pwd.h>
55 #include <setjmp.h>
56 #include <signal.h>
57 #include <stddef.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <sysexits.h>
62 #include <time.h>
63 #include <unistd.h>
64
65 #ifndef __SOCKUNION_DECLARED
66 union sockunion {
67 struct sockaddr_storage ss;
68 struct sockaddr sa;
69 struct sockaddr_dl sdl;
70 struct sockaddr_in sin;
71 #ifdef INET6
72 struct sockaddr_in6 sin6;
73 #endif
74 };
75 typedef union sockunion sockunion_t;
76 #define __SOCKUNION_DECLARED
77 #endif /* __SOCKUNION_DECLARED */
78
79 #define ADDRBUF_LEN 16
80 #define DEFAULT_GROUP_STR "238.1.1.0"
81 #define DEFAULT_IFNAME "lo0"
82 #define DEFAULT_IFADDR_STR "127.0.0.1"
83 #define DEFAULT_PORT 6698
84 #define DEFAULT_TIMEOUT 0 /* don't wait for traffic */
85 #define RXBUFSIZE 2048
86
87 static sockunion_t basegroup;
88 static const char *basegroup_str = NULL;
89 static int dobindaddr = 0;
90 static int dodebug = 1;
91 static int doipv4 = 0;
92 static int domiscopts = 0;
93 static int dorandom = 0;
94 static int doreuseport = 0;
95 static int dossm = 0;
96 static int dossf = 0;
97 static int doverbose = 0;
98 static sockunion_t ifaddr;
99 static const char *ifaddr_str = NULL;
100 static uint32_t ifindex = 0;
101 static const char *ifname = NULL;
102 struct in_addr *ipv4_sources = NULL;
103 static jmp_buf jmpbuf;
104 static size_t nmcastgroups = IP_MAX_MEMBERSHIPS;
105 static size_t nmcastsources = 0;
106 static uint16_t portno = DEFAULT_PORT;
107 static char *progname = NULL;
108 struct sockaddr_storage *ss_sources = NULL;
109 static uint32_t timeout = 0;
110
111 static int do_asm_ipv4(void);
112 static int do_asm_pim(void);
113 #ifdef notyet
114 static int do_misc_opts(void);
115 #endif
116 static int do_ssf_ipv4(void);
117 static int do_ssf_pim(void);
118 static int do_ssm_ipv4(void);
119 static int do_ssm_pim(void);
120 static int open_and_bind_socket(sockunion_t *);
121 static int recv_loop_with_match(int, sockunion_t *, sockunion_t *);
122 static void signal_handler(int);
123 static void usage(void);
124
125 /*
126 * Test the IPv4 set/getipv4sourcefilter() libc API functions.
127 * Build a single socket.
128 * Join a source group.
129 * Repeatedly change the source filters via setipv4sourcefilter.
130 * Read it back with getipv4sourcefilter up to IP_MAX_SOURCES
131 * and check for inconsistency.
132 */
133 static int
do_ssf_ipv4(void)134 do_ssf_ipv4(void)
135 {
136
137 fprintf(stderr, "not yet implemented\n");
138 return (0);
139 }
140
141 /*
142 * Test the protocol-independent set/getsourcefilter() functions.
143 */
144 static int
do_ssf_pim(void)145 do_ssf_pim(void)
146 {
147
148 fprintf(stderr, "not yet implemented\n");
149 return (0);
150 }
151
152 /*
153 * Test the IPv4 ASM API.
154 * Repeatedly join, block sources, unblock and leave groups.
155 */
156 static int
do_asm_ipv4(void)157 do_asm_ipv4(void)
158 {
159 int error;
160 char gaddrbuf[ADDRBUF_LEN];
161 int i;
162 sockunion_t laddr;
163 struct ip_mreq mreq;
164 struct ip_mreq_source mreqs;
165 in_addr_t ngroupbase;
166 char saddrbuf[ADDRBUF_LEN];
167 int sock;
168 sockunion_t tmpgroup;
169 sockunion_t tmpsource;
170
171 memset(&mreq, 0, sizeof(struct ip_mreq));
172 memset(&mreqs, 0, sizeof(struct ip_mreq_source));
173 memset(&laddr, 0, sizeof(sockunion_t));
174
175 if (dobindaddr) {
176 laddr = ifaddr;
177 } else {
178 laddr.sin.sin_family = AF_INET;
179 laddr.sin.sin_len = sizeof(struct sockaddr_in);
180 laddr.sin.sin_addr.s_addr = INADDR_ANY;
181 }
182 laddr.sin.sin_port = htons(portno);
183
184 tmpgroup = basegroup;
185 ngroupbase = ntohl(basegroup.sin.sin_addr.s_addr) + 1; /* XXX */
186 tmpgroup.sin.sin_addr.s_addr = htonl(ngroupbase);
187
188 sock = open_and_bind_socket(&laddr);
189 if (sock == -1)
190 return (EX_OSERR);
191
192 for (i = 0; i < (signed)nmcastgroups; i++) {
193 mreq.imr_multiaddr.s_addr = htonl((ngroupbase + i));
194 mreq.imr_interface = ifaddr.sin.sin_addr;
195 if (doverbose) {
196 inet_ntop(AF_INET, &mreq.imr_multiaddr, gaddrbuf,
197 sizeof(gaddrbuf));
198 fprintf(stderr, "IP_ADD_MEMBERSHIP %s %s\n",
199 gaddrbuf, inet_ntoa(mreq.imr_interface));
200 }
201 error = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
202 &mreq, sizeof(struct ip_mreq));
203 if (error < 0) {
204 warn("setsockopt IP_ADD_MEMBERSHIP");
205 close(sock);
206 return (EX_OSERR);
207 }
208 }
209
210 /*
211 * If no test sources auto-generated or specified on command line,
212 * skip source filter portion of ASM test.
213 */
214 if (nmcastsources == 0)
215 goto skipsources;
216
217 /*
218 * Begin blocking sources on the first group chosen.
219 */
220 for (i = 0; i < (signed)nmcastsources; i++) {
221 mreqs.imr_multiaddr = tmpgroup.sin.sin_addr;
222 mreqs.imr_interface = ifaddr.sin.sin_addr;
223 mreqs.imr_sourceaddr = ipv4_sources[i];
224 if (doverbose) {
225 inet_ntop(AF_INET, &mreqs.imr_multiaddr, gaddrbuf,
226 sizeof(gaddrbuf));
227 inet_ntop(AF_INET, &mreqs.imr_sourceaddr, saddrbuf,
228 sizeof(saddrbuf));
229 fprintf(stderr, "IP_BLOCK_SOURCE %s %s %s\n",
230 gaddrbuf, inet_ntoa(mreqs.imr_interface),
231 saddrbuf);
232 }
233 error = setsockopt(sock, IPPROTO_IP, IP_BLOCK_SOURCE, &mreqs,
234 sizeof(struct ip_mreq_source));
235 if (error < 0) {
236 warn("setsockopt IP_BLOCK_SOURCE");
237 close(sock);
238 return (EX_OSERR);
239 }
240 }
241
242 /*
243 * Choose the first group and source for a match.
244 * Enter the I/O loop.
245 */
246 memset(&tmpsource, 0, sizeof(sockunion_t));
247 tmpsource.sin.sin_family = AF_INET;
248 tmpsource.sin.sin_len = sizeof(struct sockaddr_in);
249 tmpsource.sin.sin_addr = ipv4_sources[0];
250
251 error = recv_loop_with_match(sock, &tmpgroup, &tmpsource);
252
253 /*
254 * Unblock sources.
255 */
256 for (i = nmcastsources-1; i >= 0; i--) {
257 mreqs.imr_multiaddr = tmpgroup.sin.sin_addr;
258 mreqs.imr_interface = ifaddr.sin.sin_addr;
259 mreqs.imr_sourceaddr = ipv4_sources[i];
260 if (doverbose) {
261 inet_ntop(AF_INET, &mreqs.imr_multiaddr, gaddrbuf,
262 sizeof(gaddrbuf));
263 inet_ntop(AF_INET, &mreqs.imr_sourceaddr, saddrbuf,
264 sizeof(saddrbuf));
265 fprintf(stderr, "IP_UNBLOCK_SOURCE %s %s %s\n",
266 gaddrbuf, inet_ntoa(mreqs.imr_interface),
267 saddrbuf);
268 }
269 error = setsockopt(sock, IPPROTO_IP, IP_UNBLOCK_SOURCE, &mreqs,
270 sizeof(struct ip_mreq_source));
271 if (error < 0) {
272 warn("setsockopt IP_UNBLOCK_SOURCE");
273 close(sock);
274 return (EX_OSERR);
275 }
276 }
277
278 skipsources:
279 /*
280 * Leave groups.
281 */
282 for (i = nmcastgroups-1; i >= 0; i--) {
283 mreq.imr_multiaddr.s_addr = htonl((ngroupbase + i));
284 mreq.imr_interface = ifaddr.sin.sin_addr;
285 if (doverbose) {
286 inet_ntop(AF_INET, &mreq.imr_multiaddr, gaddrbuf,
287 sizeof(gaddrbuf));
288 fprintf(stderr, "IP_DROP_MEMBERSHIP %s %s\n",
289 gaddrbuf, inet_ntoa(mreq.imr_interface));
290 }
291 error = setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,
292 &mreq, sizeof(struct ip_mreq));
293 if (error < 0) {
294 warn("setsockopt IP_DROP_MEMBERSHIP");
295 close(sock);
296 return (EX_OSERR);
297 }
298 }
299
300 return (0);
301 }
302
303 static int
do_asm_pim(void)304 do_asm_pim(void)
305 {
306
307 fprintf(stderr, "not yet implemented\n");
308 return (0);
309 }
310
311 #ifdef notyet
312 /*
313 * Test misceallaneous IPv4 options.
314 */
315 static int
do_misc_opts(void)316 do_misc_opts(void)
317 {
318 int sock;
319
320 sock = open_and_bind_socket(NULL);
321 if (sock == -1)
322 return (EX_OSERR);
323 test_ip_uchar(sock, socktypename, IP_MULTICAST_TTL,
324 "IP_MULTICAST_TTL", 1);
325 close(sock);
326
327 sock = open_and_bind_socket(NULL);
328 if (sock == -1)
329 return (EX_OSERR);
330 test_ip_boolean(sock, socktypename, IP_MULTICAST_LOOP,
331 "IP_MULTICAST_LOOP", 1, BOOLEAN_ANYONE);
332 close(sock);
333
334 return (0);
335 }
336 #endif
337
338 /*
339 * Test the IPv4 SSM API.
340 */
341 static int
do_ssm_ipv4(void)342 do_ssm_ipv4(void)
343 {
344
345 fprintf(stderr, "not yet implemented\n");
346 return (0);
347 }
348
349 /*
350 * Test the protocol-independent SSM API with IPv4 addresses.
351 */
352 static int
do_ssm_pim(void)353 do_ssm_pim(void)
354 {
355
356 fprintf(stderr, "not yet implemented\n");
357 return (0);
358 }
359
360 int
main(int argc,char * argv[])361 main(int argc, char *argv[])
362 {
363 struct addrinfo aih;
364 struct addrinfo *aip;
365 int ch;
366 int error;
367 int exitval;
368 size_t i;
369 struct in_addr *pina;
370 struct sockaddr_storage *pbss;
371
372 ifname = DEFAULT_IFNAME;
373 ifaddr_str = DEFAULT_IFADDR_STR;
374 basegroup_str = DEFAULT_GROUP_STR;
375 ifname = DEFAULT_IFNAME;
376 portno = DEFAULT_PORT;
377 basegroup.ss.ss_family = AF_UNSPEC;
378 ifaddr.ss.ss_family = AF_UNSPEC;
379
380 progname = basename(argv[0]);
381 while ((ch = getopt(argc, argv, "4bg:i:I:mM:p:rsS:tT:v")) != -1) {
382 switch (ch) {
383 case '4':
384 doipv4 = 1;
385 break;
386 case 'b':
387 dobindaddr = 1;
388 break;
389 case 'g':
390 basegroup_str = optarg;
391 break;
392 case 'i':
393 ifname = optarg;
394 break;
395 case 'I':
396 ifaddr_str = optarg;
397 break;
398 case 'm':
399 usage(); /* notyet */
400 /*NOTREACHED*/
401 domiscopts = 1;
402 break;
403 case 'M':
404 nmcastgroups = atoi(optarg);
405 break;
406 case 'p':
407 portno = atoi(optarg);
408 break;
409 case 'r':
410 doreuseport = 1;
411 break;
412 case 'S':
413 nmcastsources = atoi(optarg);
414 break;
415 case 's':
416 dossm = 1;
417 break;
418 case 't':
419 dossf = 1;
420 break;
421 case 'T':
422 timeout = atoi(optarg);
423 break;
424 case 'v':
425 doverbose = 1;
426 break;
427 default:
428 usage();
429 break;
430 /*NOTREACHED*/
431 }
432 }
433 argc -= optind;
434 argv += optind;
435
436 memset(&aih, 0, sizeof(struct addrinfo));
437 aih.ai_flags = AI_NUMERICHOST | AI_PASSIVE;
438 aih.ai_family = PF_INET;
439 aih.ai_socktype = SOCK_DGRAM;
440 aih.ai_protocol = IPPROTO_UDP;
441
442 /*
443 * Fill out base group.
444 */
445 aip = NULL;
446 error = getaddrinfo(basegroup_str, NULL, &aih, &aip);
447 if (error != 0) {
448 fprintf(stderr, "%s: getaddrinfo: %s\n", progname,
449 gai_strerror(error));
450 exit(EX_USAGE);
451 }
452 memcpy(&basegroup, aip->ai_addr, aip->ai_addrlen);
453 if (dodebug) {
454 fprintf(stderr, "debug: gai thinks %s is %s\n",
455 basegroup_str, inet_ntoa(basegroup.sin.sin_addr));
456 }
457 freeaddrinfo(aip);
458
459 assert(basegroup.ss.ss_family == AF_INET);
460
461 /*
462 * If user specified interface as an address, and protocol
463 * specific APIs were selected, parse it.
464 * Otherwise, parse interface index from name if protocol
465 * independent APIs were selected (the default).
466 */
467 if (doipv4) {
468 if (ifaddr_str == NULL) {
469 warnx("required argument missing: ifaddr");
470 usage();
471 /* NOTREACHED */
472 }
473 aip = NULL;
474 error = getaddrinfo(ifaddr_str, NULL, &aih, &aip);
475 if (error != 0) {
476 fprintf(stderr, "%s: getaddrinfo: %s\n", progname,
477 gai_strerror(error));
478 exit(EX_USAGE);
479 }
480 memcpy(&ifaddr, aip->ai_addr, aip->ai_addrlen);
481 if (dodebug) {
482 fprintf(stderr, "debug: gai thinks %s is %s\n",
483 ifaddr_str, inet_ntoa(ifaddr.sin.sin_addr));
484 }
485 freeaddrinfo(aip);
486 }
487
488 if (!doipv4) {
489 if (ifname == NULL) {
490 warnx("required argument missing: ifname");
491 usage();
492 /* NOTREACHED */
493 }
494 ifindex = if_nametoindex(ifname);
495 if (ifindex == 0)
496 err(EX_USAGE, "if_nametoindex");
497 }
498
499 /*
500 * Introduce randomness into group base if specified.
501 */
502 if (dorandom) {
503 in_addr_t ngroupbase;
504
505 srandomdev();
506 ngroupbase = ntohl(basegroup.sin.sin_addr.s_addr);
507 ngroupbase |= ((random() % ((1 << 11) - 1)) << 16);
508 basegroup.sin.sin_addr.s_addr = htonl(ngroupbase);
509 }
510
511 if (argc > 0) {
512 nmcastsources = argc;
513 if (doipv4) {
514 ipv4_sources = calloc(nmcastsources,
515 sizeof(struct in_addr));
516 if (ipv4_sources == NULL) {
517 exitval = EX_OSERR;
518 goto out;
519 }
520 } else {
521 ss_sources = calloc(nmcastsources,
522 sizeof(struct sockaddr_storage));
523 if (ss_sources == NULL) {
524 exitval = EX_OSERR;
525 goto out;
526 }
527 }
528 }
529
530 /*
531 * Parse source list, if any were specified on the command line.
532 */
533 assert(aih.ai_family == PF_INET);
534 pbss = ss_sources;
535 pina = ipv4_sources;
536 for (i = 0; i < (size_t)argc; i++) {
537 aip = NULL;
538 error = getaddrinfo(argv[i], NULL, &aih, &aip);
539 if (error != 0) {
540 fprintf(stderr, "getaddrinfo: %s\n",
541 gai_strerror(error));
542 exitval = EX_USAGE;
543 goto out;
544 }
545 if (doipv4) {
546 struct sockaddr_in *sin =
547 (struct sockaddr_in *)aip->ai_addr;
548 *pina++ = sin->sin_addr;
549 } else {
550 memcpy(pbss++, aip->ai_addr, aip->ai_addrlen);
551 }
552 freeaddrinfo(aip);
553 }
554
555 /*
556 * Perform the regression tests which the user requested.
557 */
558 #ifdef notyet
559 if (domiscopts) {
560 exitval = do_misc_opts();
561 if (exitval)
562 goto out;
563 }
564 #endif
565 if (doipv4) {
566 /* IPv4 protocol specific API tests */
567 if (dossm) {
568 /* Source-specific multicast */
569 exitval = do_ssm_ipv4();
570 if (exitval)
571 goto out;
572 if (dossf) {
573 /* Do setipvsourcefilter() too */
574 exitval = do_ssf_ipv4();
575 }
576 } else {
577 /* Any-source multicast */
578 exitval = do_asm_ipv4();
579 }
580 } else {
581 /* Protocol independent API tests */
582 if (dossm) {
583 /* Source-specific multicast */
584 exitval = do_ssm_pim();
585 if (exitval)
586 goto out;
587 if (dossf) {
588 /* Do setsourcefilter() too */
589 exitval = do_ssf_pim();
590 }
591 } else {
592 /* Any-source multicast */
593 exitval = do_asm_pim();
594 }
595 }
596
597 out:
598 if (ipv4_sources != NULL)
599 free(ipv4_sources);
600
601 if (ss_sources != NULL)
602 free(ss_sources);
603
604 exit(exitval);
605 }
606
607 static int
open_and_bind_socket(sockunion_t * bsu)608 open_and_bind_socket(sockunion_t *bsu)
609 {
610 int error, optval, sock;
611
612 sock = -1;
613
614 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
615 if (sock == -1) {
616 warn("socket");
617 return (-1);
618 }
619
620 if (doreuseport) {
621 optval = 1;
622 if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &optval,
623 sizeof(optval)) < 0) {
624 warn("setsockopt SO_REUSEPORT");
625 close(sock);
626 return (-1);
627 }
628 }
629
630 if (bsu != NULL) {
631 error = bind(sock, &bsu->sa, bsu->sa.sa_len);
632 if (error == -1) {
633 warn("bind");
634 close(sock);
635 return (-1);
636 }
637 }
638
639 return (sock);
640 }
641
642 /*
643 * Protocol-agnostic multicast I/O loop.
644 *
645 * Wait for 'timeout' seconds looking for traffic on group, so that manual
646 * or automated regression tests (possibly running on another host) have an
647 * opportunity to transmit within the group to test source filters.
648 *
649 * If the filter failed, this loop will report if we received traffic
650 * from the source we elected to monitor.
651 */
652 static int
recv_loop_with_match(int sock,sockunion_t * group,sockunion_t * source)653 recv_loop_with_match(int sock, sockunion_t *group, sockunion_t *source)
654 {
655 int error;
656 sockunion_t from;
657 char groupname[NI_MAXHOST];
658 ssize_t len;
659 size_t npackets;
660 int jmpretval;
661 char rxbuf[RXBUFSIZE];
662 char sourcename[NI_MAXHOST];
663
664 assert(source->sa.sa_family == AF_INET);
665
666 /*
667 * Return immediately if we don't need to wait for traffic.
668 */
669 if (timeout == 0)
670 return (0);
671
672 error = getnameinfo(&group->sa, group->sa.sa_len, groupname,
673 NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
674 if (error) {
675 fprintf(stderr, "getnameinfo: %s\n", gai_strerror(error));
676 return (error);
677 }
678
679 error = getnameinfo(&source->sa, source->sa.sa_len, sourcename,
680 NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
681 if (error) {
682 fprintf(stderr, "getnameinfo: %s\n", gai_strerror(error));
683 return (error);
684 }
685
686 fprintf(stdout,
687 "Waiting %d seconds for inbound traffic on group %s\n"
688 "Expecting no traffic from blocked source: %s\n",
689 (int)timeout, groupname, sourcename);
690
691 signal(SIGINT, signal_handler);
692 signal(SIGALRM, signal_handler);
693
694 error = 0;
695 npackets = 0;
696 alarm(timeout);
697 while (0 == (jmpretval = setjmp(jmpbuf))) {
698 len = recvfrom(sock, rxbuf, RXBUFSIZE, 0, &from.sa,
699 (socklen_t *)&from.sa.sa_len);
700 if (dodebug) {
701 fprintf(stderr, "debug: packet received from %s\n",
702 inet_ntoa(from.sin.sin_addr));
703 }
704 if (source &&
705 source->sin.sin_addr.s_addr == from.sin.sin_addr.s_addr)
706 break;
707 npackets++;
708 }
709
710 if (doverbose) {
711 fprintf(stderr, "Number of datagrams received from "
712 "non-blocked sources: %d\n", (int)npackets);
713 }
714
715 switch (jmpretval) {
716 case SIGALRM: /* ok */
717 break;
718 case SIGINT: /* go bye bye */
719 fprintf(stderr, "interrupted\n");
720 error = 20;
721 break;
722 case 0: /* Broke out of loop; saw a bad source. */
723 fprintf(stderr, "FAIL: got packet from blocked source\n");
724 error = EX_IOERR;
725 break;
726 default:
727 warnx("recvfrom");
728 error = EX_OSERR;
729 break;
730 }
731
732 signal(SIGINT, SIG_DFL);
733 signal(SIGALRM, SIG_DFL);
734
735 return (error);
736 }
737
738 static void
signal_handler(int signo)739 signal_handler(int signo)
740 {
741
742 longjmp(jmpbuf, signo);
743 }
744
745 static void
usage(void)746 usage(void)
747 {
748
749 fprintf(stderr, "\nIP multicast regression test utility\n");
750 fprintf(stderr,
751 "usage: %s [-4] [-b] [-g groupaddr] [-i ifname] [-I ifaddr] [-m]\n"
752 " [-M ngroups] [-p portno] [-r] [-R] [-s] [-S nsources] [-t] [-T timeout]\n"
753 " [-v] [blockaddr ...]\n\n", progname);
754 fprintf(stderr, "-4: Use IPv4 API "
755 "(default: Use protocol-independent API)\n");
756 fprintf(stderr, "-b: bind listening socket to ifaddr "
757 "(default: INADDR_ANY)\n");
758 fprintf(stderr, "-g: Base IPv4 multicast group to join (default: %s)\n",
759 DEFAULT_GROUP_STR);
760 fprintf(stderr, "-i: interface for multicast joins (default: %s)\n",
761 DEFAULT_IFNAME);
762 fprintf(stderr, "-I: IPv4 address to join groups on, if using IPv4 "
763 "API\n (default: %s)\n", DEFAULT_IFADDR_STR);
764 #ifdef notyet
765 fprintf(stderr, "-m: Test misc IPv4 multicast socket options "
766 "(default: off)\n");
767 #endif
768 fprintf(stderr, "-M: Number of multicast groups to join "
769 "(default: %d)\n", (int)nmcastgroups);
770 fprintf(stderr, "-p: Set local and remote port (default: %d)\n",
771 DEFAULT_PORT);
772 fprintf(stderr, "-r: Set SO_REUSEPORT on (default: off)\n");
773 fprintf(stderr, "-R: Randomize groups/sources (default: off)\n");
774 fprintf(stderr, "-s: Test source-specific API "
775 "(default: test any-source API)\n");
776 fprintf(stderr, "-S: Number of multicast sources to generate if\n"
777 " none specified on command line (default: %d)\n",
778 (int)nmcastsources);
779 fprintf(stderr, "-t: Test get/setNsourcefilter() (default: off)\n");
780 fprintf(stderr, "-T: Timeout to wait for blocked traffic on first "
781 "group (default: %d)\n", DEFAULT_TIMEOUT);
782 fprintf(stderr, "-v: Be verbose (default: off)\n");
783 fprintf(stderr, "\nRemaining arguments are treated as a list of IPv4 "
784 "sources to filter.\n\n");
785
786 exit(EX_USAGE);
787 }
788