Home | History | Annotate | Line # | Download | only in mcast
mcast.c revision 1.2 
      1 /*	$NetBSD: mcast.c,v 1.2 2015/05/28 08:32:53 ozaki-r Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2014 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Christos Zoulas.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 #include <sys/cdefs.h>
     32 #ifdef __RCSID
     33 __RCSID("$NetBSD: mcast.c,v 1.2 2015/05/28 08:32:53 ozaki-r Exp $");
     34 #else
     35 extern const char *__progname;
     36 #define getprogname() __progname
     37 #endif
     38 
     39 #include <sys/types.h>
     40 #include <sys/socket.h>
     41 #include <sys/wait.h>
     42 #include <sys/time.h>
     43 #include <netinet/in.h>
     44 
     45 #include <assert.h>
     46 #include <netdb.h>
     47 #include <time.h>
     48 #include <signal.h>
     49 #include <stdio.h>
     50 #include <string.h>
     51 #include <stdlib.h>
     52 #include <unistd.h>
     53 #include <err.h>
     54 #include <errno.h>
     55 #include <poll.h>
     56 #include <stdbool.h>
     57 
     58 #ifdef ATF
     59 #include <atf-c.h>
     60 
     61 #define ERRX(ev, msg, ...)	ATF_REQUIRE_MSG(0, msg, __VA_ARGS__)
     62 
     63 #define SKIPX(ev, msg, ...)	do {			\
     64 	atf_tc_skip(msg, __VA_ARGS__);			\
     65 	return;						\
     66 } while(/*CONSTCOND*/0)
     67 
     68 #else
     69 #define ERRX(ev, msg, ...)	errx(ev, msg, __VA_ARGS__)
     70 #define SKIPX(ev, msg, ...)	errx(ev, msg, __VA_ARGS__)
     71 #endif
     72 
     73 static int debug;
     74 
     75 #define TOTAL 10
     76 #define PORT_V4MAPPED "6666"
     77 #define HOST_V4MAPPED "::FFFF:239.1.1.1"
     78 #define PORT_V4 "6666"
     79 #define HOST_V4 "239.1.1.1"
     80 #define PORT_V6 "6666"
     81 #define HOST_V6 "FF05:1:0:0:0:0:0:1"
     82 
     83 struct message {
     84 	size_t seq;
     85 	struct timespec ts;
     86 };
     87 
     88 static int
     89 addmc(int s, struct addrinfo *ai, bool bug)
     90 {
     91 	struct ip_mreq m4;
     92 	struct ipv6_mreq m6;
     93 	struct sockaddr_in *s4;
     94 	struct sockaddr_in6 *s6;
     95 	unsigned int ifc;
     96 
     97 	switch (ai->ai_family) {
     98 	case AF_INET:
     99 		s4 = (void *)ai->ai_addr;
    100 		assert(sizeof(*s4) == ai->ai_addrlen);
    101 		m4.imr_multiaddr = s4->sin_addr;
    102 		m4.imr_interface.s_addr = htonl(INADDR_ANY);
    103 		return setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
    104 		    &m4, sizeof(m4));
    105 	case AF_INET6:
    106 		s6 = (void *)ai->ai_addr;
    107 		/*
    108 		 * Linux:	Does not support the v6 ioctls on v4 mapped
    109 		 *		sockets but it does support the v4 ones and
    110 		 *		it works.
    111 		 * MacOS/X:	Supports the v6 ioctls on v4 mapped sockets,
    112 		 *		but does not work and also does not support
    113 		 *		the v4 ioctls. So no way to make multicasting
    114 		 *		work with mapped addresses.
    115 		 * NetBSD:	Supports both and works for both.
    116 		 */
    117 		if (bug && IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr)) {
    118 			memcpy(&m4.imr_multiaddr, &s6->sin6_addr.s6_addr[12],
    119 			    sizeof(m4.imr_multiaddr));
    120 			m4.imr_interface.s_addr = htonl(INADDR_ANY);
    121 			return setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
    122 			    &m4, sizeof(m4));
    123 		}
    124 		assert(sizeof(*s6) == ai->ai_addrlen);
    125 		memset(&m6, 0, sizeof(m6));
    126 #if 0
    127 		ifc = 1;
    128 		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
    129 		    &ifc, sizeof(ifc)) == -1)
    130 			return -1;
    131 		ifc = 224;
    132 		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
    133 		    &ifc, sizeof(ifc)) == -1)
    134 			return -1;
    135 		ifc = 1; /* XXX should pick a proper interface */
    136 		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifc,
    137 		    sizeof(ifc)) == -1)
    138 			return -1;
    139 #else
    140 		ifc = 0; /* Let pick an appropriate interface */
    141 #endif
    142 		m6.ipv6mr_interface = ifc;
    143 		m6.ipv6mr_multiaddr = s6->sin6_addr;
    144 		return setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP,
    145 		    &m6, sizeof(m6));
    146 	default:
    147 		errno = EOPNOTSUPP;
    148 		return -1;
    149 	}
    150 }
    151 
    152 static int
    153 allowv4mapped(int s, struct addrinfo *ai)
    154 {
    155 	struct sockaddr_in6 *s6;
    156 	int zero = 0;
    157 
    158 	if (ai->ai_family != AF_INET6)
    159 		return 0;
    160 
    161 	s6 = (void *)ai->ai_addr;
    162 
    163 	if (!IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr))
    164 		return 0;
    165 	return setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero));
    166 }
    167 
    168 static struct sockaddr_storage ss;
    169 static int
    170 connector(int fd, const struct sockaddr *sa, socklen_t slen)
    171 {
    172 	assert(sizeof(ss) > slen);
    173 	memcpy(&ss, sa, slen);
    174 	return 0;
    175 }
    176 
    177 static void
    178 show(const char *prefix, const struct message *msg)
    179 {
    180 	printf("%10.10s: %zu [%jd.%ld]\n", prefix, msg->seq, (intmax_t)
    181 	    msg->ts.tv_sec, msg->ts.tv_nsec);
    182 }
    183 
    184 static int
    185 getsocket(const char *host, const char *port,
    186     int (*f)(int, const struct sockaddr *, socklen_t), socklen_t *slen,
    187     bool bug)
    188 {
    189 	int e, s, lasterrno = 0;
    190 	struct addrinfo hints, *ai0, *ai;
    191 	const char *cause = "?";
    192 
    193 	memset(&hints, 0, sizeof(hints));
    194 	hints.ai_family = AF_UNSPEC;
    195 	hints.ai_socktype = SOCK_DGRAM;
    196 	e = getaddrinfo(host, port, &hints, &ai0);
    197 	if (e)
    198 		ERRX(EXIT_FAILURE, "Can't resolve %s:%s (%s)", host, port,
    199 		    gai_strerror(e));
    200 
    201 	s = -1;
    202 	for (ai = ai0; ai; ai = ai->ai_next) {
    203 		s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
    204 		if (s == -1) {
    205 			lasterrno = errno;
    206 			cause = "socket";
    207 			continue;
    208 		}
    209 		if (allowv4mapped(s, ai) == -1) {
    210 			cause = "allow v4 mapped";
    211 			goto out;
    212 		}
    213 		if ((*f)(s, ai->ai_addr, ai->ai_addrlen) == -1) {
    214 			cause = f == bind ? "bind" : "connect";
    215 			goto out;
    216 		}
    217 		if ((f == bind || f == connector) && addmc(s, ai, bug) == -1) {
    218 			cause = "join group";
    219 			goto out;
    220 		}
    221 		*slen = ai->ai_addrlen;
    222 		break;
    223 out:
    224 		lasterrno = errno;
    225 		close(s);
    226 		s = -1;
    227 		continue;
    228 	}
    229 	freeaddrinfo(ai0);
    230 	if (s == -1)
    231 		ERRX(EXIT_FAILURE, "%s (%s)", cause, strerror(lasterrno));
    232 	return s;
    233 }
    234 
    235 static void
    236 sender(const char *host, const char *port, size_t n, bool conn, bool bug)
    237 {
    238 	int s;
    239 	ssize_t l;
    240 	struct message msg;
    241 
    242 	socklen_t slen;
    243 
    244 	s = getsocket(host, port, conn ? connect : connector, &slen, bug);
    245 	for (msg.seq = 0; msg.seq < n; msg.seq++) {
    246 #ifdef CLOCK_MONOTONIC
    247 		if (clock_gettime(CLOCK_MONOTONIC, &msg.ts) == -1)
    248 			ERRX(EXIT_FAILURE, "clock (%s)", strerror(errno));
    249 #else
    250 		struct timeval tv;
    251 		if (gettimeofday(&tv, NULL) == -1)
    252 			ERRX(EXIT_FAILURE, "clock (%s)", strerror(errno));
    253 		msg.ts.tv_sec = tv.tv_sec;
    254 		msg.ts.tv_nsec = tv.tv_usec * 1000;
    255 #endif
    256 		if (debug)
    257 			show("sending", &msg);
    258 		l = conn ? send(s, &msg, sizeof(msg), 0) :
    259 		    sendto(s, &msg, sizeof(msg), 0, (void *)&ss, slen);
    260 		if (l == -1)
    261 			ERRX(EXIT_FAILURE, "send (%s)", strerror(errno));
    262 		usleep(100);
    263 	}
    264 }
    265 
    266 static void
    267 receiver(const char *host, const char *port, size_t n, bool conn, bool bug)
    268 {
    269 	int s;
    270 	ssize_t l;
    271 	size_t seq;
    272 	struct message msg;
    273 	struct pollfd pfd;
    274 	socklen_t slen;
    275 
    276 	s = getsocket(host, port, bind, &slen, bug);
    277 	pfd.fd = s;
    278 	pfd.events = POLLIN;
    279 	for (seq = 0; seq < n; seq++) {
    280 		if (poll(&pfd, 1, 10000) == -1)
    281 			ERRX(EXIT_FAILURE, "poll (%s)", strerror(errno));
    282 		l = conn ? recv(s, &msg, sizeof(msg), 0) :
    283 		    recvfrom(s, &msg, sizeof(msg), 0, (void *)&ss, &slen);
    284 		if (l == -1)
    285 			ERRX(EXIT_FAILURE, "recv (%s)", strerror(errno));
    286 		if (debug)
    287 			show("got", &msg);
    288 		if (seq != msg.seq)
    289 			ERRX(EXIT_FAILURE, "seq: expect=%zu actual=%zu",
    290 			    seq, msg.seq);
    291 	}
    292 }
    293 
    294 static void
    295 run(const char *host, const char *port, size_t n, bool conn, bool bug)
    296 {
    297 	pid_t pid;
    298 	int status;
    299 
    300 	switch ((pid = fork())) {
    301 	case 0:
    302 		receiver(host, port, n, conn, bug);
    303 		return;
    304 	case -1:
    305 		ERRX(EXIT_FAILURE, "fork (%s)", strerror(errno));
    306 	default:
    307 		usleep(1000);
    308 		sender(host, port, n, conn, bug);
    309 		usleep(100);
    310 	again:
    311 		switch (waitpid(pid, &status, WNOHANG)) {
    312 		case -1:
    313 			ERRX(EXIT_FAILURE, "wait (%s)", strerror(errno));
    314 		case 0:
    315 			if (kill(pid, SIGTERM) == -1)
    316 				ERRX(EXIT_FAILURE, "kill (%s)",
    317 				    strerror(errno));
    318 			goto again;
    319 		default:
    320 			if (WIFSIGNALED(status)) {
    321 				if (WTERMSIG(status) == SIGTERM)
    322 					ERRX(EXIT_FAILURE,
    323 					    "receiver got terminated due to " \
    324 					    "deadline (%d usec)", 100);
    325 				else
    326 					ERRX(EXIT_FAILURE,
    327 					    "receiver got signaled (%s)",
    328 					    strsignal(WTERMSIG(status)));
    329 			} else if (WIFEXITED(status)) {
    330 				if (WEXITSTATUS(status) != 0)
    331 					ERRX(EXIT_FAILURE,
    332 					    "receiver exited with status %d",
    333 					    WEXITSTATUS(status));
    334 			} else {
    335 				ERRX(EXIT_FAILURE,
    336 				    "receiver exited with unexpected status %d",
    337 				    status);
    338 			}
    339 			break;
    340 		}
    341 		return;
    342 	}
    343 }
    344 
    345 #ifndef ATF
    346 int
    347 main(int argc, char *argv[])
    348 {
    349 	const char *host, *port;
    350 	int c;
    351 	size_t n;
    352 	bool conn, bug;
    353 
    354 	host = HOST_V4;
    355 	port = PORT_V4;
    356 	n = TOTAL;
    357 	bug = conn = false;
    358 
    359 	while ((c = getopt(argc, argv, "46bcdmn:")) != -1)
    360 		switch (c) {
    361 		case '4':
    362 			host = HOST_V4;
    363 			port = PORT_V4;
    364 			break;
    365 		case '6':
    366 			host = HOST_V6;
    367 			port = PORT_V6;
    368 			break;
    369 		case 'b':
    370 			bug = true;
    371 			break;
    372 		case 'c':
    373 			conn = true;
    374 			break;
    375 		case 'd':
    376 			debug++;
    377 			break;
    378 		case 'm':
    379 			host = HOST_V4MAPPED;
    380 			port = PORT_V4MAPPED;
    381 			break;
    382 		case 'n':
    383 			n = atoi(optarg);
    384 			break;
    385 		default:
    386 			fprintf(stderr, "Usage: %s [-cdm46] [-n <tot>]",
    387 			    getprogname());
    388 			return 1;
    389 		}
    390 
    391 	run(host, port, n, conn, bug);
    392 	return 0;
    393 }
    394 #else
    395 
    396 ATF_TC(conninet4);
    397 ATF_TC_HEAD(conninet4, tc)
    398 {
    399 	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for ipv4");
    400 }
    401 
    402 ATF_TC_BODY(conninet4, tc)
    403 {
    404 	run(HOST_V4, PORT_V4, TOTAL, true, false);
    405 }
    406 
    407 ATF_TC(connmappedinet4);
    408 ATF_TC_HEAD(connmappedinet4, tc)
    409 {
    410 	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for mapped ipv4");
    411 }
    412 
    413 ATF_TC_BODY(connmappedinet4, tc)
    414 {
    415 	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, true, false);
    416 }
    417 
    418 ATF_TC(connmappedbuginet4);
    419 ATF_TC_HEAD(connmappedbuginet4, tc)
    420 {
    421 	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for mapped ipv4 using the v4 ioctls");
    422 }
    423 
    424 ATF_TC_BODY(connmappedbuginet4, tc)
    425 {
    426 	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, true, true);
    427 }
    428 
    429 ATF_TC(conninet6);
    430 ATF_TC_HEAD(conninet6, tc)
    431 {
    432 	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for ipv6");
    433 }
    434 
    435 ATF_TC_BODY(conninet6, tc)
    436 {
    437 	run(HOST_V6, PORT_V6, TOTAL, true, false);
    438 }
    439 
    440 ATF_TC(unconninet4);
    441 ATF_TC_HEAD(unconninet4, tc)
    442 {
    443 	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for ipv4");
    444 }
    445 
    446 ATF_TC_BODY(unconninet4, tc)
    447 {
    448 	run(HOST_V4, PORT_V4, TOTAL, false, false);
    449 }
    450 
    451 ATF_TC(unconnmappedinet4);
    452 ATF_TC_HEAD(unconnmappedinet4, tc)
    453 {
    454 	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for mapped ipv4");
    455 }
    456 
    457 ATF_TC_BODY(unconnmappedinet4, tc)
    458 {
    459 	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, false, false);
    460 }
    461 
    462 ATF_TC(unconnmappedbuginet4);
    463 ATF_TC_HEAD(unconnmappedbuginet4, tc)
    464 {
    465 	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for mapped ipv4 using the v4 ioctls");
    466 }
    467 
    468 ATF_TC_BODY(unconnmappedbuginet4, tc)
    469 {
    470 	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, false, true);
    471 }
    472 
    473 ATF_TC(unconninet6);
    474 ATF_TC_HEAD(unconninet6, tc)
    475 {
    476 	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for ipv6");
    477 }
    478 
    479 ATF_TC_BODY(unconninet6, tc)
    480 {
    481 	run(HOST_V6, PORT_V6, TOTAL, false, false);
    482 }
    483 
    484 ATF_TP_ADD_TCS(tp)
    485 {
    486 	debug++;
    487 	ATF_TP_ADD_TC(tp, conninet4);
    488 	ATF_TP_ADD_TC(tp, connmappedinet4);
    489 	ATF_TP_ADD_TC(tp, connmappedbuginet4);
    490 	ATF_TP_ADD_TC(tp, conninet6);
    491 	ATF_TP_ADD_TC(tp, unconninet4);
    492 	ATF_TP_ADD_TC(tp, unconnmappedinet4);
    493 	ATF_TP_ADD_TC(tp, unconnmappedbuginet4);
    494 	ATF_TP_ADD_TC(tp, unconninet6);
    495 
    496 	return atf_no_error();
    497 }
    498 #endif
    499