1/*	$NetBSD: mcast.c,v 1.3 2015/05/28 10:19:17 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.3 2015/05/28 10:19:17 ozaki-r Exp $");
34#else
35extern 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#define ERRX0(ev, msg)		ATF_REQUIRE_MSG(0, msg)
63
64#define SKIPX(ev, msg, ...)	do {			\
65	atf_tc_skip(msg, __VA_ARGS__);			\
66	return;						\
67} while(/*CONSTCOND*/0)
68
69#else
70#define ERRX(ev, msg, ...)	errx(ev, msg, __VA_ARGS__)
71#define ERRX0(ev, msg)		errx(ev, msg)
72#define SKIPX(ev, msg, ...)	errx(ev, msg, __VA_ARGS__)
73#endif
74
75static int debug;
76
77#define TOTAL 10
78#define PORT_V4MAPPED "6666"
79#define HOST_V4MAPPED "::FFFF:239.1.1.1"
80#define PORT_V4 "6666"
81#define HOST_V4 "239.1.1.1"
82#define PORT_V6 "6666"
83#define HOST_V6 "FF05:1:0:0:0:0:0:1"
84
85struct message {
86	size_t seq;
87	struct timespec ts;
88};
89
90static int
91addmc(int s, struct addrinfo *ai, bool bug)
92{
93	struct ip_mreq m4;
94	struct ipv6_mreq m6;
95	struct sockaddr_in *s4;
96	struct sockaddr_in6 *s6;
97	unsigned int ifc;
98
99	switch (ai->ai_family) {
100	case AF_INET:
101		s4 = (void *)ai->ai_addr;
102		assert(sizeof(*s4) == ai->ai_addrlen);
103		m4.imr_multiaddr = s4->sin_addr;
104		m4.imr_interface.s_addr = htonl(INADDR_ANY);
105		return setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
106		    &m4, sizeof(m4));
107	case AF_INET6:
108		s6 = (void *)ai->ai_addr;
109		/*
110		 * Linux:	Does not support the v6 ioctls on v4 mapped
111		 *		sockets but it does support the v4 ones and
112		 *		it works.
113		 * MacOS/X:	Supports the v6 ioctls on v4 mapped sockets,
114		 *		but does not work and also does not support
115		 *		the v4 ioctls. So no way to make multicasting
116		 *		work with mapped addresses.
117		 * NetBSD:	Supports both and works for both.
118		 */
119		if (bug && IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr)) {
120			memcpy(&m4.imr_multiaddr, &s6->sin6_addr.s6_addr[12],
121			    sizeof(m4.imr_multiaddr));
122			m4.imr_interface.s_addr = htonl(INADDR_ANY);
123			return setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,
124			    &m4, sizeof(m4));
125		}
126		assert(sizeof(*s6) == ai->ai_addrlen);
127		memset(&m6, 0, sizeof(m6));
128#if 0
129		ifc = 1;
130		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
131		    &ifc, sizeof(ifc)) == -1)
132			return -1;
133		ifc = 224;
134		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
135		    &ifc, sizeof(ifc)) == -1)
136			return -1;
137		ifc = 1; /* XXX should pick a proper interface */
138		if (setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifc,
139		    sizeof(ifc)) == -1)
140			return -1;
141#else
142		ifc = 0; /* Let pick an appropriate interface */
143#endif
144		m6.ipv6mr_interface = ifc;
145		m6.ipv6mr_multiaddr = s6->sin6_addr;
146		return setsockopt(s, IPPROTO_IPV6, IPV6_JOIN_GROUP,
147		    &m6, sizeof(m6));
148	default:
149		errno = EOPNOTSUPP;
150		return -1;
151	}
152}
153
154static int
155allowv4mapped(int s, struct addrinfo *ai)
156{
157	struct sockaddr_in6 *s6;
158	int zero = 0;
159
160	if (ai->ai_family != AF_INET6)
161		return 0;
162
163	s6 = (void *)ai->ai_addr;
164
165	if (!IN6_IS_ADDR_V4MAPPED(&s6->sin6_addr))
166		return 0;
167	return setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero));
168}
169
170static struct sockaddr_storage ss;
171static int
172connector(int fd, const struct sockaddr *sa, socklen_t slen)
173{
174	assert(sizeof(ss) > slen);
175	memcpy(&ss, sa, slen);
176	return 0;
177}
178
179static void
180show(const char *prefix, const struct message *msg)
181{
182	printf("%10.10s: %zu [%jd.%ld]\n", prefix, msg->seq, (intmax_t)
183	    msg->ts.tv_sec, msg->ts.tv_nsec);
184}
185
186static int
187getsocket(const char *host, const char *port,
188    int (*f)(int, const struct sockaddr *, socklen_t), socklen_t *slen,
189    bool bug)
190{
191	int e, s, lasterrno = 0;
192	struct addrinfo hints, *ai0, *ai;
193	const char *cause = "?";
194
195	memset(&hints, 0, sizeof(hints));
196	hints.ai_family = AF_UNSPEC;
197	hints.ai_socktype = SOCK_DGRAM;
198	e = getaddrinfo(host, port, &hints, &ai0);
199	if (e)
200		ERRX(EXIT_FAILURE, "Can't resolve %s:%s (%s)", host, port,
201		    gai_strerror(e));
202
203	s = -1;
204	for (ai = ai0; ai; ai = ai->ai_next) {
205		s = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
206		if (s == -1) {
207			lasterrno = errno;
208			cause = "socket";
209			continue;
210		}
211		if (allowv4mapped(s, ai) == -1) {
212			cause = "allow v4 mapped";
213			goto out;
214		}
215		if ((*f)(s, ai->ai_addr, ai->ai_addrlen) == -1) {
216			cause = f == bind ? "bind" : "connect";
217			goto out;
218		}
219		if ((f == bind || f == connector) && addmc(s, ai, bug) == -1) {
220			cause = "join group";
221			goto out;
222		}
223		*slen = ai->ai_addrlen;
224		break;
225out:
226		lasterrno = errno;
227		close(s);
228		s = -1;
229		continue;
230	}
231	freeaddrinfo(ai0);
232	if (s == -1)
233		ERRX(EXIT_FAILURE, "%s (%s)", cause, strerror(lasterrno));
234	return s;
235}
236
237static int
238synchronize(const int fd, bool waiter)
239{
240	int syncmsg = 0;
241	int r;
242	struct pollfd pfd;
243
244	if (waiter) {
245		pfd.fd = fd;
246		pfd.events = POLLIN;
247
248		/* We use poll to avoid lock up when the peer died unexpectedly */
249		r = poll(&pfd, 1, 10000);
250		if (r == -1)
251			ERRX(EXIT_FAILURE, "poll (%s)", strerror(errno));
252		if (r == 0)
253			/* Timed out */
254			return -1;
255
256		if (read(fd, &syncmsg, sizeof(syncmsg)) == -1)
257			ERRX(EXIT_FAILURE, "read (%s)", strerror(errno));
258	} else {
259		if (write(fd, &syncmsg, sizeof(syncmsg)) == -1)
260			ERRX(EXIT_FAILURE, "write (%s)", strerror(errno));
261	}
262
263	return 0;
264}
265
266static int
267sender(const int fd, const char *host, const char *port, size_t n, bool conn,
268    bool bug)
269{
270	int s;
271	ssize_t l;
272	struct message msg;
273
274	socklen_t slen;
275
276	s = getsocket(host, port, conn ? connect : connector, &slen, bug);
277
278	/* Wait until receiver gets ready. */
279	if (synchronize(fd, true) == -1)
280		return -1;
281
282	for (msg.seq = 0; msg.seq < n; msg.seq++) {
283#ifdef CLOCK_MONOTONIC
284		if (clock_gettime(CLOCK_MONOTONIC, &msg.ts) == -1)
285			ERRX(EXIT_FAILURE, "clock (%s)", strerror(errno));
286#else
287		struct timeval tv;
288		if (gettimeofday(&tv, NULL) == -1)
289			ERRX(EXIT_FAILURE, "clock (%s)", strerror(errno));
290		msg.ts.tv_sec = tv.tv_sec;
291		msg.ts.tv_nsec = tv.tv_usec * 1000;
292#endif
293		if (debug)
294			show("sending", &msg);
295		l = conn ? send(s, &msg, sizeof(msg), 0) :
296		    sendto(s, &msg, sizeof(msg), 0, (void *)&ss, slen);
297		if (l == -1)
298			ERRX(EXIT_FAILURE, "send (%s)", strerror(errno));
299		usleep(100);
300	}
301
302	/* Wait until receiver finishes its work. */
303	if (synchronize(fd, true) == -1)
304		return -1;
305
306	return 0;
307}
308
309static void
310receiver(const int fd, const char *host, const char *port, size_t n, bool conn,
311    bool bug)
312{
313	int s;
314	ssize_t l;
315	size_t seq;
316	struct message msg;
317	struct pollfd pfd;
318	socklen_t slen;
319
320	s = getsocket(host, port, bind, &slen, bug);
321	pfd.fd = s;
322	pfd.events = POLLIN;
323
324	/* Tell I'm ready */
325	synchronize(fd, false);
326
327	for (seq = 0; seq < n; seq++) {
328		if (poll(&pfd, 1, 10000) == -1)
329			ERRX(EXIT_FAILURE, "poll (%s)", strerror(errno));
330		l = conn ? recv(s, &msg, sizeof(msg), 0) :
331		    recvfrom(s, &msg, sizeof(msg), 0, (void *)&ss, &slen);
332		if (l == -1)
333			ERRX(EXIT_FAILURE, "recv (%s)", strerror(errno));
334		if (debug)
335			show("got", &msg);
336		if (seq != msg.seq)
337			ERRX(EXIT_FAILURE, "seq: expect=%zu actual=%zu",
338			    seq, msg.seq);
339	}
340
341	/* Tell I'm finished */
342	synchronize(fd, false);
343}
344
345static void
346run(const char *host, const char *port, size_t n, bool conn, bool bug)
347{
348	pid_t pid;
349	int status;
350	int syncfds[2];
351	int error;
352
353	if (socketpair(AF_UNIX, SOCK_STREAM, 0, syncfds) == -1)
354		ERRX(EXIT_FAILURE, "socketpair (%s)", strerror(errno));
355
356	switch ((pid = fork())) {
357	case 0:
358		receiver(syncfds[0], host, port, n, conn, bug);
359		return;
360	case -1:
361		ERRX(EXIT_FAILURE, "fork (%s)", strerror(errno));
362	default:
363		error = sender(syncfds[1], host, port, n, conn, bug);
364	again:
365		switch (waitpid(pid, &status, WNOHANG)) {
366		case -1:
367			ERRX(EXIT_FAILURE, "wait (%s)", strerror(errno));
368		case 0:
369			if (error == 0)
370				/*
371				 * Receiver is still alive, but we know
372				 * it will exit soon.
373				 */
374				goto again;
375
376			if (kill(pid, SIGTERM) == -1)
377				ERRX(EXIT_FAILURE, "kill (%s)",
378				    strerror(errno));
379			goto again;
380		default:
381			if (WIFSIGNALED(status)) {
382				if (WTERMSIG(status) == SIGTERM)
383					ERRX0(EXIT_FAILURE,
384					    "receiver failed and was killed" \
385					    "by sender");
386				else
387					ERRX(EXIT_FAILURE,
388					    "receiver got signaled (%s)",
389					    strsignal(WTERMSIG(status)));
390			} else if (WIFEXITED(status)) {
391				if (WEXITSTATUS(status) != 0)
392					ERRX(EXIT_FAILURE,
393					    "receiver exited with status %d",
394					    WEXITSTATUS(status));
395			} else {
396				ERRX(EXIT_FAILURE,
397				    "receiver exited with unexpected status %d",
398				    status);
399			}
400			break;
401		}
402		return;
403	}
404}
405
406#ifndef ATF
407int
408main(int argc, char *argv[])
409{
410	const char *host, *port;
411	int c;
412	size_t n;
413	bool conn, bug;
414
415	host = HOST_V4;
416	port = PORT_V4;
417	n = TOTAL;
418	bug = conn = false;
419
420	while ((c = getopt(argc, argv, "46bcdmn:")) != -1)
421		switch (c) {
422		case '4':
423			host = HOST_V4;
424			port = PORT_V4;
425			break;
426		case '6':
427			host = HOST_V6;
428			port = PORT_V6;
429			break;
430		case 'b':
431			bug = true;
432			break;
433		case 'c':
434			conn = true;
435			break;
436		case 'd':
437			debug++;
438			break;
439		case 'm':
440			host = HOST_V4MAPPED;
441			port = PORT_V4MAPPED;
442			break;
443		case 'n':
444			n = atoi(optarg);
445			break;
446		default:
447			fprintf(stderr, "Usage: %s [-cdm46] [-n <tot>]",
448			    getprogname());
449			return 1;
450		}
451
452	run(host, port, n, conn, bug);
453	return 0;
454}
455#else
456
457ATF_TC(conninet4);
458ATF_TC_HEAD(conninet4, tc)
459{
460	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for ipv4");
461}
462
463ATF_TC_BODY(conninet4, tc)
464{
465	run(HOST_V4, PORT_V4, TOTAL, true, false);
466}
467
468ATF_TC(connmappedinet4);
469ATF_TC_HEAD(connmappedinet4, tc)
470{
471	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for mapped ipv4");
472}
473
474ATF_TC_BODY(connmappedinet4, tc)
475{
476	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, true, false);
477}
478
479ATF_TC(connmappedbuginet4);
480ATF_TC_HEAD(connmappedbuginet4, tc)
481{
482	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for mapped ipv4 using the v4 ioctls");
483}
484
485ATF_TC_BODY(connmappedbuginet4, tc)
486{
487	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, true, true);
488}
489
490ATF_TC(conninet6);
491ATF_TC_HEAD(conninet6, tc)
492{
493	atf_tc_set_md_var(tc, "descr", "Checks connected multicast for ipv6");
494}
495
496ATF_TC_BODY(conninet6, tc)
497{
498	run(HOST_V6, PORT_V6, TOTAL, true, false);
499}
500
501ATF_TC(unconninet4);
502ATF_TC_HEAD(unconninet4, tc)
503{
504	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for ipv4");
505}
506
507ATF_TC_BODY(unconninet4, tc)
508{
509	run(HOST_V4, PORT_V4, TOTAL, false, false);
510}
511
512ATF_TC(unconnmappedinet4);
513ATF_TC_HEAD(unconnmappedinet4, tc)
514{
515	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for mapped ipv4");
516}
517
518ATF_TC_BODY(unconnmappedinet4, tc)
519{
520	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, false, false);
521}
522
523ATF_TC(unconnmappedbuginet4);
524ATF_TC_HEAD(unconnmappedbuginet4, tc)
525{
526	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for mapped ipv4 using the v4 ioctls");
527}
528
529ATF_TC_BODY(unconnmappedbuginet4, tc)
530{
531	run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, false, true);
532}
533
534ATF_TC(unconninet6);
535ATF_TC_HEAD(unconninet6, tc)
536{
537	atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for ipv6");
538}
539
540ATF_TC_BODY(unconninet6, tc)
541{
542	run(HOST_V6, PORT_V6, TOTAL, false, false);
543}
544
545ATF_TP_ADD_TCS(tp)
546{
547	debug++;
548	ATF_TP_ADD_TC(tp, conninet4);
549	ATF_TP_ADD_TC(tp, connmappedinet4);
550	ATF_TP_ADD_TC(tp, connmappedbuginet4);
551	ATF_TP_ADD_TC(tp, conninet6);
552	ATF_TP_ADD_TC(tp, unconninet4);
553	ATF_TP_ADD_TC(tp, unconnmappedinet4);
554	ATF_TP_ADD_TC(tp, unconnmappedbuginet4);
555	ATF_TP_ADD_TC(tp, unconninet6);
556
557	return atf_no_error();
558}
559#endif
560