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