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$"); 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 66union 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}; 75typedef 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 87static sockunion_t basegroup; 88static const char *basegroup_str = NULL; 89static int dobindaddr = 0; 90static int dodebug = 1; 91static int doipv4 = 0; 92static int domiscopts = 0; 93static int dorandom = 0; 94static int doreuseport = 0; 95static int dossm = 0; 96static int dossf = 0; 97static int doverbose = 0; 98static sockunion_t ifaddr; 99static const char *ifaddr_str = NULL; 100static uint32_t ifindex = 0; 101static const char *ifname = NULL; 102struct in_addr *ipv4_sources = NULL; 103static jmp_buf jmpbuf; 104static size_t nmcastgroups = IP_MAX_MEMBERSHIPS; 105static size_t nmcastsources = 0; 106static uint16_t portno = DEFAULT_PORT; 107static char *progname = NULL; 108struct sockaddr_storage *ss_sources = NULL; 109static uint32_t timeout = 0; 110 111static int do_asm_ipv4(void); 112static int do_asm_pim(void); 113#ifdef notyet 114static int do_misc_opts(void); 115#endif 116static int do_ssf_ipv4(void); 117static int do_ssf_pim(void); 118static int do_ssm_ipv4(void); 119static int do_ssm_pim(void); 120static int open_and_bind_socket(sockunion_t *); 121static int recv_loop_with_match(int, sockunion_t *, sockunion_t *); 122static void signal_handler(int); 123static 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 */ 133static int 134do_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 */ 144static int 145do_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 */ 156static int 157do_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 278skipsources: 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 303static int 304do_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 */ 315static int 316do_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 */ 341static int 342do_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 */ 352static int 353do_ssm_pim(void) 354{ 355 356 fprintf(stderr, "not yet implemented\n"); 357 return (0); 358} 359 360int 361main(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 597out: 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 607static int 608open_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 */ 652static int 653recv_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 738static void 739signal_handler(int signo) 740{ 741 742 longjmp(jmpbuf, signo); 743} 744 745static void 746usage(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