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
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 #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
75 static 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
85 struct message {
86 size_t seq;
87 struct timespec ts;
88 };
89
90 static int
addmc(int s,struct addrinfo * ai,bool bug)91 addmc(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
154 static int
allowv4mapped(int s,struct addrinfo * ai)155 allowv4mapped(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
170 static struct sockaddr_storage ss;
171 static int
connector(int fd,const struct sockaddr * sa,socklen_t slen)172 connector(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
179 static void
show(const char * prefix,const struct message * msg)180 show(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
186 static int
getsocket(const char * host,const char * port,int (* f)(int,const struct sockaddr *,socklen_t),socklen_t * slen,bool bug)187 getsocket(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;
225 out:
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
237 static int
synchronize(const int fd,bool waiter)238 synchronize(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
266 static int
sender(const int fd,const char * host,const char * port,size_t n,bool conn,bool bug)267 sender(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
309 static void
receiver(const int fd,const char * host,const char * port,size_t n,bool conn,bool bug)310 receiver(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
345 static void
run(const char * host,const char * port,size_t n,bool conn,bool bug)346 run(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
407 int
main(int argc,char * argv[])408 main(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
457 ATF_TC(conninet4);
ATF_TC_HEAD(conninet4,tc)458 ATF_TC_HEAD(conninet4, tc)
459 {
460 atf_tc_set_md_var(tc, "descr", "Checks connected multicast for ipv4");
461 }
462
ATF_TC_BODY(conninet4,tc)463 ATF_TC_BODY(conninet4, tc)
464 {
465 run(HOST_V4, PORT_V4, TOTAL, true, false);
466 }
467
468 ATF_TC(connmappedinet4);
ATF_TC_HEAD(connmappedinet4,tc)469 ATF_TC_HEAD(connmappedinet4, tc)
470 {
471 atf_tc_set_md_var(tc, "descr", "Checks connected multicast for mapped ipv4");
472 }
473
ATF_TC_BODY(connmappedinet4,tc)474 ATF_TC_BODY(connmappedinet4, tc)
475 {
476 run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, true, false);
477 }
478
479 ATF_TC(connmappedbuginet4);
ATF_TC_HEAD(connmappedbuginet4,tc)480 ATF_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
ATF_TC_BODY(connmappedbuginet4,tc)485 ATF_TC_BODY(connmappedbuginet4, tc)
486 {
487 run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, true, true);
488 }
489
490 ATF_TC(conninet6);
ATF_TC_HEAD(conninet6,tc)491 ATF_TC_HEAD(conninet6, tc)
492 {
493 atf_tc_set_md_var(tc, "descr", "Checks connected multicast for ipv6");
494 }
495
ATF_TC_BODY(conninet6,tc)496 ATF_TC_BODY(conninet6, tc)
497 {
498 run(HOST_V6, PORT_V6, TOTAL, true, false);
499 }
500
501 ATF_TC(unconninet4);
ATF_TC_HEAD(unconninet4,tc)502 ATF_TC_HEAD(unconninet4, tc)
503 {
504 atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for ipv4");
505 }
506
ATF_TC_BODY(unconninet4,tc)507 ATF_TC_BODY(unconninet4, tc)
508 {
509 run(HOST_V4, PORT_V4, TOTAL, false, false);
510 }
511
512 ATF_TC(unconnmappedinet4);
ATF_TC_HEAD(unconnmappedinet4,tc)513 ATF_TC_HEAD(unconnmappedinet4, tc)
514 {
515 atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for mapped ipv4");
516 }
517
ATF_TC_BODY(unconnmappedinet4,tc)518 ATF_TC_BODY(unconnmappedinet4, tc)
519 {
520 run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, false, false);
521 }
522
523 ATF_TC(unconnmappedbuginet4);
ATF_TC_HEAD(unconnmappedbuginet4,tc)524 ATF_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
ATF_TC_BODY(unconnmappedbuginet4,tc)529 ATF_TC_BODY(unconnmappedbuginet4, tc)
530 {
531 run(HOST_V4MAPPED, PORT_V4MAPPED, TOTAL, false, true);
532 }
533
534 ATF_TC(unconninet6);
ATF_TC_HEAD(unconninet6,tc)535 ATF_TC_HEAD(unconninet6, tc)
536 {
537 atf_tc_set_md_var(tc, "descr", "Checks unconnected multicast for ipv6");
538 }
539
ATF_TC_BODY(unconninet6,tc)540 ATF_TC_BODY(unconninet6, tc)
541 {
542 run(HOST_V6, PORT_V6, TOTAL, false, false);
543 }
544
ATF_TP_ADD_TCS(tp)545 ATF_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