1 /* $OpenBSD: slaacd.c,v 1.69 2024/04/21 17:33:05 florian Exp $ */
2
3 /*
4 * Copyright (c) 2017 Florian Obser <florian@openbsd.org>
5 * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
6 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
7 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
8 *
9 * Permission to use, copy, modify, and distribute this software for any
10 * purpose with or without fee is hereby granted, provided that the above
11 * copyright notice and this permission notice appear in all copies.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 */
21 #include <sys/types.h>
22 #include <sys/ioctl.h>
23 #include <sys/queue.h>
24 #include <sys/socket.h>
25 #include <sys/syslog.h>
26 #include <sys/sysctl.h>
27 #include <sys/uio.h>
28 #include <sys/wait.h>
29
30 #include <net/if.h>
31 #include <net/route.h>
32 #include <netinet/in.h>
33 #include <netinet/if_ether.h>
34 #include <netinet6/in6_var.h>
35 #include <netinet/icmp6.h>
36
37 #include <err.h>
38 #include <errno.h>
39 #include <fcntl.h>
40 #include <event.h>
41 #include <imsg.h>
42 #include <netdb.h>
43 #include <pwd.h>
44 #include <stddef.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <signal.h>
49 #include <unistd.h>
50
51 #include "log.h"
52 #include "slaacd.h"
53 #include "frontend.h"
54 #include "engine.h"
55 #include "control.h"
56
57 enum slaacd_process {
58 PROC_MAIN,
59 PROC_ENGINE,
60 PROC_FRONTEND
61 };
62
63 __dead void usage(void);
64 __dead void main_shutdown(void);
65
66 void main_sig_handler(int, short, void *);
67
68 static pid_t start_child(enum slaacd_process, char *, int, int, int);
69
70 void main_dispatch_frontend(int, short, void *);
71 void main_dispatch_engine(int, short, void *);
72 void open_icmp6sock(int);
73 void configure_interface(struct imsg_configure_address *);
74 void delete_address(struct imsg_configure_address *);
75 void configure_gateway(struct imsg_configure_dfr *, uint8_t);
76 void add_gateway(struct imsg_configure_dfr *);
77 void delete_gateway(struct imsg_configure_dfr *);
78 void send_rdns_proposal(struct imsg_propose_rdns *);
79 int get_soiikey(uint8_t *);
80
81 static int main_imsg_send_ipc_sockets(struct imsgbuf *, struct imsgbuf *);
82 int main_imsg_compose_frontend(int, int, void *, uint16_t);
83 int main_imsg_compose_engine(int, pid_t, void *, uint16_t);
84
85 static struct imsgev *iev_frontend;
86 static struct imsgev *iev_engine;
87
88 pid_t frontend_pid;
89 pid_t engine_pid;
90
91 int routesock, ioctl_sock, rtm_seq = 0;
92
93 void
main_sig_handler(int sig,short event,void * arg)94 main_sig_handler(int sig, short event, void *arg)
95 {
96 /*
97 * Normal signal handler rules don't apply because libevent
98 * decouples for us.
99 */
100
101 switch (sig) {
102 case SIGTERM:
103 case SIGINT:
104 main_shutdown();
105 default:
106 fatalx("unexpected signal");
107 }
108 }
109
110 __dead void
usage(void)111 usage(void)
112 {
113 extern char *__progname;
114
115 fprintf(stderr, "usage: %s [-dv] [-s socket]\n",
116 __progname);
117 exit(1);
118 }
119
120 int
main(int argc,char * argv[])121 main(int argc, char *argv[])
122 {
123 struct event ev_sigint, ev_sigterm;
124 int ch;
125 int debug = 0, engine_flag = 0, frontend_flag = 0;
126 int verbose = 0;
127 char *saved_argv0;
128 int pipe_main2frontend[2];
129 int pipe_main2engine[2];
130 int frontend_routesock, rtfilter, lockfd;
131 int rtable_any = RTABLE_ANY;
132 char *csock = _PATH_SLAACD_SOCKET;
133 struct imsg_propose_rdns rdns;
134 #ifndef SMALL
135 int control_fd;
136 #endif /* SMALL */
137
138 log_init(1, LOG_DAEMON); /* Log to stderr until daemonized. */
139 log_setverbose(1);
140
141 saved_argv0 = argv[0];
142 if (saved_argv0 == NULL)
143 saved_argv0 = "slaacd";
144
145 while ((ch = getopt(argc, argv, "dEFs:v")) != -1) {
146 switch (ch) {
147 case 'd':
148 debug = 1;
149 break;
150 case 'E':
151 engine_flag = 1;
152 break;
153 case 'F':
154 frontend_flag = 1;
155 break;
156 case 's':
157 csock = optarg;
158 break;
159 case 'v':
160 verbose++;
161 break;
162 default:
163 usage();
164 }
165 }
166
167 argc -= optind;
168 argv += optind;
169 if (argc > 0 || (engine_flag && frontend_flag))
170 usage();
171
172 if (engine_flag)
173 engine(debug, verbose);
174 else if (frontend_flag)
175 frontend(debug, verbose);
176
177 /* Check for root privileges. */
178 if (geteuid())
179 errx(1, "need root privileges");
180
181 lockfd = open(_PATH_LOCKFILE, O_CREAT|O_RDWR|O_EXLOCK|O_NONBLOCK, 0600);
182 if (lockfd == -1) {
183 if (errno == EAGAIN)
184 errx(1, "already running");
185 err(1, "%s", _PATH_LOCKFILE);
186 }
187
188 /* Check for assigned daemon user */
189 if (getpwnam(SLAACD_USER) == NULL)
190 errx(1, "unknown user %s", SLAACD_USER);
191
192 log_init(debug, LOG_DAEMON);
193 log_setverbose(verbose);
194
195 if (!debug)
196 daemon(0, 0);
197
198 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
199 PF_UNSPEC, pipe_main2frontend) == -1)
200 fatal("main2frontend socketpair");
201 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
202 PF_UNSPEC, pipe_main2engine) == -1)
203 fatal("main2engine socketpair");
204
205 /* Start children. */
206 engine_pid = start_child(PROC_ENGINE, saved_argv0, pipe_main2engine[1],
207 debug, verbose);
208 frontend_pid = start_child(PROC_FRONTEND, saved_argv0,
209 pipe_main2frontend[1], debug, verbose);
210
211 log_procinit("main");
212
213 if ((routesock = socket(AF_ROUTE, SOCK_RAW | SOCK_CLOEXEC |
214 SOCK_NONBLOCK, AF_INET6)) == -1)
215 fatal("route socket");
216 shutdown(routesock, SHUT_RD);
217
218 event_init();
219
220 /* Setup signal handler. */
221 signal_set(&ev_sigint, SIGINT, main_sig_handler, NULL);
222 signal_set(&ev_sigterm, SIGTERM, main_sig_handler, NULL);
223 signal_add(&ev_sigint, NULL);
224 signal_add(&ev_sigterm, NULL);
225 signal(SIGPIPE, SIG_IGN);
226 signal(SIGHUP, SIG_IGN);
227
228 /* Setup pipes to children. */
229
230 if ((iev_frontend = malloc(sizeof(struct imsgev))) == NULL ||
231 (iev_engine = malloc(sizeof(struct imsgev))) == NULL)
232 fatal(NULL);
233 imsg_init(&iev_frontend->ibuf, pipe_main2frontend[0]);
234 iev_frontend->handler = main_dispatch_frontend;
235 imsg_init(&iev_engine->ibuf, pipe_main2engine[0]);
236 iev_engine->handler = main_dispatch_engine;
237
238 /* Setup event handlers for pipes to engine & frontend. */
239 iev_frontend->events = EV_READ;
240 event_set(&iev_frontend->ev, iev_frontend->ibuf.fd,
241 iev_frontend->events, iev_frontend->handler, iev_frontend);
242 event_add(&iev_frontend->ev, NULL);
243
244 iev_engine->events = EV_READ;
245 event_set(&iev_engine->ev, iev_engine->ibuf.fd, iev_engine->events,
246 iev_engine->handler, iev_engine);
247 event_add(&iev_engine->ev, NULL);
248
249 if (main_imsg_send_ipc_sockets(&iev_frontend->ibuf, &iev_engine->ibuf))
250 fatal("could not establish imsg links");
251
252 if ((ioctl_sock = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0)) == -1)
253 fatal("socket");
254
255 if ((frontend_routesock = socket(AF_ROUTE, SOCK_RAW | SOCK_CLOEXEC,
256 AF_INET6)) == -1)
257 fatal("route socket");
258
259 rtfilter = ROUTE_FILTER(RTM_IFINFO) | ROUTE_FILTER(RTM_NEWADDR) |
260 ROUTE_FILTER(RTM_DELADDR) | ROUTE_FILTER(RTM_DELETE) |
261 ROUTE_FILTER(RTM_CHGADDRATTR) | ROUTE_FILTER(RTM_PROPOSAL) |
262 ROUTE_FILTER(RTM_IFANNOUNCE);
263 if (setsockopt(frontend_routesock, AF_ROUTE, ROUTE_MSGFILTER,
264 &rtfilter, sizeof(rtfilter)) == -1)
265 fatal("setsockopt(ROUTE_MSGFILTER)");
266 if (setsockopt(frontend_routesock, AF_ROUTE, ROUTE_TABLEFILTER,
267 &rtable_any, sizeof(rtable_any)) == -1)
268 fatal("setsockopt(ROUTE_TABLEFILTER)");
269
270 #ifndef SMALL
271 if ((control_fd = control_init(csock)) == -1)
272 warnx("control socket setup failed");
273 #endif /* SMALL */
274
275 if (pledge("stdio inet sendfd wroute", NULL) == -1)
276 fatal("pledge");
277
278 main_imsg_compose_frontend(IMSG_ROUTESOCK, frontend_routesock, NULL, 0);
279
280 #ifndef SMALL
281 if (control_fd != -1)
282 main_imsg_compose_frontend(IMSG_CONTROLFD, control_fd, NULL, 0);
283 #endif /* SMALL */
284
285 main_imsg_compose_frontend(IMSG_STARTUP, -1, NULL, 0);
286
287 /* we are taking over, clear all previos slaac proposals */
288 memset(&rdns, 0, sizeof(rdns));
289 rdns.if_index = 0;
290 rdns.rdns_count = 0;
291 send_rdns_proposal(&rdns);
292
293 event_dispatch();
294
295 main_shutdown();
296 return (0);
297 }
298
299 __dead void
main_shutdown(void)300 main_shutdown(void)
301 {
302 pid_t pid;
303 int status;
304
305 /* Close pipes. */
306 msgbuf_clear(&iev_frontend->ibuf.w);
307 close(iev_frontend->ibuf.fd);
308 msgbuf_clear(&iev_engine->ibuf.w);
309 close(iev_engine->ibuf.fd);
310
311 log_debug("waiting for children to terminate");
312 do {
313 pid = wait(&status);
314 if (pid == -1) {
315 if (errno != EINTR && errno != ECHILD)
316 fatal("wait");
317 } else if (WIFSIGNALED(status))
318 log_warnx("%s terminated; signal %d",
319 (pid == engine_pid) ? "engine" :
320 "frontend", WTERMSIG(status));
321 } while (pid != -1 || (pid == -1 && errno == EINTR));
322
323 free(iev_frontend);
324 free(iev_engine);
325
326 log_info("terminating");
327 exit(0);
328 }
329
330 static pid_t
start_child(enum slaacd_process p,char * argv0,int fd,int debug,int verbose)331 start_child(enum slaacd_process p, char *argv0, int fd, int debug, int verbose)
332 {
333 char *argv[7];
334 int argc = 0;
335 pid_t pid;
336
337 switch (pid = fork()) {
338 case -1:
339 fatal("cannot fork");
340 case 0:
341 break;
342 default:
343 close(fd);
344 return (pid);
345 }
346
347 if (fd != 3) {
348 if (dup2(fd, 3) == -1)
349 fatal("cannot setup imsg fd");
350 } else if (fcntl(fd, F_SETFD, 0) == -1)
351 fatal("cannot setup imsg fd");
352
353 argv[argc++] = argv0;
354 switch (p) {
355 case PROC_MAIN:
356 fatalx("Can not start main process");
357 case PROC_ENGINE:
358 argv[argc++] = "-E";
359 break;
360 case PROC_FRONTEND:
361 argv[argc++] = "-F";
362 break;
363 }
364 if (debug)
365 argv[argc++] = "-d";
366 if (verbose)
367 argv[argc++] = "-v";
368 if (verbose > 1)
369 argv[argc++] = "-v";
370 argv[argc++] = NULL;
371
372 execvp(argv0, argv);
373 fatal("execvp");
374 }
375
376 void
main_dispatch_frontend(int fd,short event,void * bula)377 main_dispatch_frontend(int fd, short event, void *bula)
378 {
379 struct imsgev *iev = bula;
380 struct imsgbuf *ibuf;
381 struct imsg imsg;
382 struct imsg_ifinfo imsg_ifinfo;
383 ssize_t n;
384 int shut = 0;
385 int rdomain;
386 #ifndef SMALL
387 int verbose;
388 #endif /* SMALL */
389
390 ibuf = &iev->ibuf;
391
392 if (event & EV_READ) {
393 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
394 fatal("imsg_read error");
395 if (n == 0) /* Connection closed. */
396 shut = 1;
397 }
398 if (event & EV_WRITE) {
399 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
400 fatal("msgbuf_write");
401 if (n == 0) /* Connection closed. */
402 shut = 1;
403 }
404
405 for (;;) {
406 if ((n = imsg_get(ibuf, &imsg)) == -1)
407 fatal("imsg_get");
408 if (n == 0) /* No more messages. */
409 break;
410
411 switch (imsg.hdr.type) {
412 case IMSG_OPEN_ICMP6SOCK:
413 log_debug("IMSG_OPEN_ICMP6SOCK");
414 if (IMSG_DATA_SIZE(imsg) != sizeof(rdomain))
415 fatalx("%s: IMSG_OPEN_ICMP6SOCK wrong length: "
416 "%lu", __func__, IMSG_DATA_SIZE(imsg));
417 memcpy(&rdomain, imsg.data, sizeof(rdomain));
418 open_icmp6sock(rdomain);
419 break;
420 #ifndef SMALL
421 case IMSG_CTL_LOG_VERBOSE:
422 if (IMSG_DATA_SIZE(imsg) != sizeof(verbose))
423 fatalx("%s: IMSG_CTL_LOG_VERBOSE wrong length: "
424 "%lu", __func__, IMSG_DATA_SIZE(imsg));
425 memcpy(&verbose, imsg.data, sizeof(verbose));
426 log_setverbose(verbose);
427 break;
428 #endif /* SMALL */
429 case IMSG_UPDATE_IF:
430 if (IMSG_DATA_SIZE(imsg) != sizeof(imsg_ifinfo))
431 fatalx("%s: IMSG_UPDATE_IF wrong length: %lu",
432 __func__, IMSG_DATA_SIZE(imsg));
433 memcpy(&imsg_ifinfo, imsg.data, sizeof(imsg_ifinfo));
434 if (get_soiikey(imsg_ifinfo.soiikey) == -1)
435 log_warn("get_soiikey");
436 else
437 main_imsg_compose_engine(IMSG_UPDATE_IF, 0,
438 &imsg_ifinfo, sizeof(imsg_ifinfo));
439 break;
440 default:
441 log_debug("%s: error handling imsg %d", __func__,
442 imsg.hdr.type);
443 break;
444 }
445 imsg_free(&imsg);
446 }
447 if (!shut)
448 imsg_event_add(iev);
449 else {
450 /* This pipe is dead. Remove its event handler */
451 event_del(&iev->ev);
452 event_loopexit(NULL);
453 }
454 }
455
456 void
main_dispatch_engine(int fd,short event,void * bula)457 main_dispatch_engine(int fd, short event, void *bula)
458 {
459 struct imsgev *iev = bula;
460 struct imsgbuf *ibuf;
461 struct imsg imsg;
462 struct imsg_configure_address address;
463 struct imsg_configure_dfr dfr;
464 struct imsg_propose_rdns rdns;
465 ssize_t n;
466 int shut = 0;
467
468 ibuf = &iev->ibuf;
469
470 if (event & EV_READ) {
471 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
472 fatal("imsg_read error");
473 if (n == 0) /* Connection closed. */
474 shut = 1;
475 }
476 if (event & EV_WRITE) {
477 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
478 fatal("msgbuf_write");
479 if (n == 0) /* Connection closed. */
480 shut = 1;
481 }
482
483 for (;;) {
484 if ((n = imsg_get(ibuf, &imsg)) == -1)
485 fatal("imsg_get");
486 if (n == 0) /* No more messages. */
487 break;
488
489 switch (imsg.hdr.type) {
490 case IMSG_CONFIGURE_ADDRESS:
491 if (IMSG_DATA_SIZE(imsg) != sizeof(address))
492 fatalx("%s: IMSG_CONFIGURE_ADDRESS wrong "
493 "length: %lu", __func__,
494 IMSG_DATA_SIZE(imsg));
495 memcpy(&address, imsg.data, sizeof(address));
496 configure_interface(&address);
497 break;
498 case IMSG_WITHDRAW_ADDRESS:
499 if (IMSG_DATA_SIZE(imsg) != sizeof(address))
500 fatalx("%s: IMSG_WITHDRAW_ADDRESS wrong "
501 "length: %lu", __func__,
502 IMSG_DATA_SIZE(imsg));
503 memcpy(&address, imsg.data, sizeof(address));
504 delete_address(&address);
505 break;
506 case IMSG_CONFIGURE_DFR:
507 if (IMSG_DATA_SIZE(imsg) != sizeof(dfr))
508 fatalx("%s: IMSG_CONFIGURE_DFR wrong "
509 "length: %lu", __func__,
510 IMSG_DATA_SIZE(imsg));
511 memcpy(&dfr, imsg.data, sizeof(dfr));
512 add_gateway(&dfr);
513 break;
514 case IMSG_WITHDRAW_DFR:
515 if (IMSG_DATA_SIZE(imsg) != sizeof(dfr))
516 fatalx("%s: IMSG_WITHDRAW_DFR wrong "
517 "length: %lu", __func__,
518 IMSG_DATA_SIZE(imsg));
519 memcpy(&dfr, imsg.data, sizeof(dfr));
520 delete_gateway(&dfr);
521 break;
522 case IMSG_PROPOSE_RDNS:
523 if (IMSG_DATA_SIZE(imsg) != sizeof(rdns))
524 fatalx("%s: IMSG_PROPOSE_RDNS wrong "
525 "length: %lu", __func__,
526 IMSG_DATA_SIZE(imsg));
527 memcpy(&rdns, imsg.data, sizeof(rdns));
528 if ((2 + rdns.rdns_count * sizeof(struct in6_addr)) >
529 sizeof(struct sockaddr_rtdns))
530 fatalx("%s: rdns_count too big: %d", __func__,
531 rdns.rdns_count);
532 send_rdns_proposal(&rdns);
533 break;
534 default:
535 log_debug("%s: error handling imsg %d", __func__,
536 imsg.hdr.type);
537 break;
538 }
539 imsg_free(&imsg);
540 }
541 if (!shut)
542 imsg_event_add(iev);
543 else {
544 /* This pipe is dead. Remove its event handler. */
545 event_del(&iev->ev);
546 event_loopexit(NULL);
547 }
548 }
549
550 int
main_imsg_compose_frontend(int type,int fd,void * data,uint16_t datalen)551 main_imsg_compose_frontend(int type, int fd, void *data, uint16_t datalen)
552 {
553 if (iev_frontend)
554 return (imsg_compose_event(iev_frontend, type, 0, 0, fd, data,
555 datalen));
556 else
557 return (-1);
558 }
559
560 int
main_imsg_compose_engine(int type,pid_t pid,void * data,uint16_t datalen)561 main_imsg_compose_engine(int type, pid_t pid, void *data, uint16_t datalen)
562 {
563 if (iev_engine)
564 return(imsg_compose_event(iev_engine, type, 0, pid, -1, data,
565 datalen));
566 else
567 return (-1);
568 }
569
570 void
imsg_event_add(struct imsgev * iev)571 imsg_event_add(struct imsgev *iev)
572 {
573 iev->events = EV_READ;
574 if (iev->ibuf.w.queued)
575 iev->events |= EV_WRITE;
576
577 event_del(&iev->ev);
578 event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev);
579 event_add(&iev->ev, NULL);
580 }
581
582 int
imsg_compose_event(struct imsgev * iev,uint16_t type,uint32_t peerid,pid_t pid,int fd,void * data,uint16_t datalen)583 imsg_compose_event(struct imsgev *iev, uint16_t type, uint32_t peerid,
584 pid_t pid, int fd, void *data, uint16_t datalen)
585 {
586 int ret;
587
588 if ((ret = imsg_compose(&iev->ibuf, type, peerid, pid, fd, data,
589 datalen)) != -1)
590 imsg_event_add(iev);
591
592 return (ret);
593 }
594
595 static int
main_imsg_send_ipc_sockets(struct imsgbuf * frontend_buf,struct imsgbuf * engine_buf)596 main_imsg_send_ipc_sockets(struct imsgbuf *frontend_buf,
597 struct imsgbuf *engine_buf)
598 {
599 int pipe_frontend2engine[2];
600
601 if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
602 PF_UNSPEC, pipe_frontend2engine) == -1)
603 return (-1);
604
605 if (imsg_compose(frontend_buf, IMSG_SOCKET_IPC, 0, 0,
606 pipe_frontend2engine[0], NULL, 0) == -1)
607 return (-1);
608 imsg_flush(frontend_buf);
609 if (imsg_compose(engine_buf, IMSG_SOCKET_IPC, 0, 0,
610 pipe_frontend2engine[1], NULL, 0) == -1)
611 return (-1);
612 imsg_flush(engine_buf);
613 return (0);
614 }
615
616 void
configure_interface(struct imsg_configure_address * address)617 configure_interface(struct imsg_configure_address *address)
618 {
619
620 struct in6_aliasreq in6_addreq;
621 time_t t;
622 char *if_name;
623
624 memset(&in6_addreq, 0, sizeof(in6_addreq));
625
626 if_name = if_indextoname(address->if_index, in6_addreq.ifra_name);
627 if (if_name == NULL) {
628 log_warnx("%s: cannot find interface %d", __func__,
629 address->if_index);
630 return;
631 }
632
633 memcpy(&in6_addreq.ifra_addr, &address->addr,
634 sizeof(in6_addreq.ifra_addr));
635 memcpy(&in6_addreq.ifra_dstaddr, &address->gw,
636 sizeof(in6_addreq.ifra_dstaddr));
637 memcpy(&in6_addreq.ifra_prefixmask.sin6_addr, &address->mask,
638 sizeof(in6_addreq.ifra_prefixmask.sin6_addr));
639 in6_addreq.ifra_prefixmask.sin6_family = AF_INET6;
640 in6_addreq.ifra_prefixmask.sin6_len =
641 sizeof(in6_addreq.ifra_prefixmask);
642
643 t = time(NULL);
644
645 in6_addreq.ifra_lifetime.ia6t_expire = t + address->vltime;
646 in6_addreq.ifra_lifetime.ia6t_vltime = address->vltime;
647
648 in6_addreq.ifra_lifetime.ia6t_preferred = t + address->pltime;
649 in6_addreq.ifra_lifetime.ia6t_pltime = address->pltime;
650
651 in6_addreq.ifra_flags |= IN6_IFF_AUTOCONF;
652
653 if (address->temporary)
654 in6_addreq.ifra_flags |= IN6_IFF_TEMPORARY;
655
656 log_debug("%s: %s", __func__, if_name);
657
658 if (ioctl(ioctl_sock, SIOCAIFADDR_IN6, &in6_addreq) == -1)
659 log_warn("SIOCAIFADDR_IN6");
660
661 if (address->mtu) {
662 struct ifreq ifr;
663
664 strlcpy(ifr.ifr_name, in6_addreq.ifra_name,
665 sizeof(ifr.ifr_name));
666 ifr.ifr_mtu = address->mtu;
667 log_debug("Setting MTU to %d", ifr.ifr_mtu);
668
669 if (ioctl(ioctl_sock, SIOCSIFMTU, &ifr) == -1)
670 log_warn("failed to set MTU");
671 }
672 }
673
674 void
delete_address(struct imsg_configure_address * address)675 delete_address(struct imsg_configure_address *address)
676 {
677
678 struct in6_ifreq in6_ridreq;
679 char *if_name;
680
681 memset(&in6_ridreq, 0, sizeof(in6_ridreq));
682
683 if_name = if_indextoname(address->if_index, in6_ridreq.ifr_name);
684 if (if_name == NULL) {
685 log_warnx("%s: cannot find interface %d", __func__,
686 address->if_index);
687 return;
688 }
689
690 memcpy(&in6_ridreq.ifr_addr, &address->addr,
691 sizeof(in6_ridreq.ifr_addr));
692
693 log_debug("%s: %s", __func__, if_name);
694
695 if (ioctl(ioctl_sock, SIOCDIFADDR_IN6, &in6_ridreq) == -1 &&
696 errno != EADDRNOTAVAIL)
697 log_warn("%s: cannot remove address", __func__);
698
699 }
700
701 #define ROUNDUP(a) \
702 (((a) & (sizeof(long) - 1)) ? (1 + ((a) | (sizeof(long) - 1))) : (a))
703
704 void
configure_gateway(struct imsg_configure_dfr * dfr,uint8_t rtm_type)705 configure_gateway(struct imsg_configure_dfr *dfr, uint8_t rtm_type)
706 {
707 struct rt_msghdr rtm;
708 struct sockaddr_rtlabel rl;
709 struct sockaddr_in6 dst, gw, mask;
710 struct iovec iov[10];
711 long pad = 0;
712 int iovcnt = 0, padlen;
713
714 memset(&rtm, 0, sizeof(rtm));
715
716 rtm.rtm_version = RTM_VERSION;
717 rtm.rtm_type = rtm_type;
718 rtm.rtm_msglen = sizeof(rtm);
719 rtm.rtm_tableid = dfr->rdomain;
720 rtm.rtm_index = dfr->if_index;
721 rtm.rtm_seq = ++rtm_seq;
722 rtm.rtm_priority = RTP_NONE;
723 rtm.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK | RTA_LABEL;
724 rtm.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC | RTF_MPATH;
725
726 iov[iovcnt].iov_base = &rtm;
727 iov[iovcnt++].iov_len = sizeof(rtm);
728
729 memset(&dst, 0, sizeof(mask));
730 dst.sin6_family = AF_INET6;
731 dst.sin6_len = sizeof(struct sockaddr_in6);
732
733 iov[iovcnt].iov_base = &dst;
734 iov[iovcnt++].iov_len = sizeof(dst);
735 rtm.rtm_msglen += sizeof(dst);
736 padlen = ROUNDUP(sizeof(dst)) - sizeof(dst);
737 if (padlen > 0) {
738 iov[iovcnt].iov_base = &pad;
739 iov[iovcnt++].iov_len = padlen;
740 rtm.rtm_msglen += padlen;
741 }
742
743 memcpy(&gw, &dfr->addr, sizeof(gw));
744 #ifdef __KAME__
745 /* from route(8) getaddr()*/
746 *(u_int16_t *)& gw.sin6_addr.s6_addr[2] = htons(gw.sin6_scope_id);
747 gw.sin6_scope_id = 0;
748 #endif
749 iov[iovcnt].iov_base = &gw;
750 iov[iovcnt++].iov_len = sizeof(gw);
751 rtm.rtm_msglen += sizeof(gw);
752 padlen = ROUNDUP(sizeof(gw)) - sizeof(gw);
753 if (padlen > 0) {
754 iov[iovcnt].iov_base = &pad;
755 iov[iovcnt++].iov_len = padlen;
756 rtm.rtm_msglen += padlen;
757 }
758
759 memset(&mask, 0, sizeof(mask));
760 mask.sin6_family = AF_INET6;
761 mask.sin6_len = sizeof(struct sockaddr_in6);
762 iov[iovcnt].iov_base = &mask;
763 iov[iovcnt++].iov_len = sizeof(mask);
764 rtm.rtm_msglen += sizeof(mask);
765 padlen = ROUNDUP(sizeof(mask)) - sizeof(mask);
766 if (padlen > 0) {
767 iov[iovcnt].iov_base = &pad;
768 iov[iovcnt++].iov_len = padlen;
769 rtm.rtm_msglen += padlen;
770 }
771
772 memset(&rl, 0, sizeof(rl));
773 rl.sr_len = sizeof(rl);
774 rl.sr_family = AF_UNSPEC;
775 (void)snprintf(rl.sr_label, sizeof(rl.sr_label), "%s",
776 SLAACD_RTA_LABEL);
777 iov[iovcnt].iov_base = &rl;
778 iov[iovcnt++].iov_len = sizeof(rl);
779 rtm.rtm_msglen += sizeof(rl);
780 padlen = ROUNDUP(sizeof(rl)) - sizeof(rl);
781 if (padlen > 0) {
782 iov[iovcnt].iov_base = &pad;
783 iov[iovcnt++].iov_len = padlen;
784 rtm.rtm_msglen += padlen;
785 }
786
787 if (writev(routesock, iov, iovcnt) == -1)
788 log_warn("failed to send route message");
789 }
790
791 void
add_gateway(struct imsg_configure_dfr * dfr)792 add_gateway(struct imsg_configure_dfr *dfr)
793 {
794 configure_gateway(dfr, RTM_ADD);
795 }
796
797 void
delete_gateway(struct imsg_configure_dfr * dfr)798 delete_gateway(struct imsg_configure_dfr *dfr)
799 {
800 configure_gateway(dfr, RTM_DELETE);
801 }
802
803 void
send_rdns_proposal(struct imsg_propose_rdns * rdns)804 send_rdns_proposal(struct imsg_propose_rdns *rdns)
805 {
806 struct rt_msghdr rtm;
807 struct sockaddr_rtdns rtdns;
808 struct iovec iov[3];
809 long pad = 0;
810 int iovcnt = 0, padlen;
811
812 memset(&rtm, 0, sizeof(rtm));
813
814 rtm.rtm_version = RTM_VERSION;
815 rtm.rtm_type = RTM_PROPOSAL;
816 rtm.rtm_msglen = sizeof(rtm);
817 rtm.rtm_tableid = rdns->rdomain;
818 rtm.rtm_index = rdns->if_index;
819 rtm.rtm_seq = ++rtm_seq;
820 rtm.rtm_priority = RTP_PROPOSAL_SLAAC;
821 rtm.rtm_addrs = RTA_DNS;
822 rtm.rtm_flags = RTF_UP;
823
824 iov[iovcnt].iov_base = &rtm;
825 iov[iovcnt++].iov_len = sizeof(rtm);
826
827 memset(&rtdns, 0, sizeof(rtdns));
828 rtdns.sr_family = AF_INET6;
829 rtdns.sr_len = 2 + rdns->rdns_count * sizeof(struct in6_addr);
830 memcpy(rtdns.sr_dns, rdns->rdns, sizeof(rtdns.sr_dns));
831
832 iov[iovcnt].iov_base = &rtdns;
833 iov[iovcnt++].iov_len = sizeof(rtdns);
834 rtm.rtm_msglen += sizeof(rtdns);
835 padlen = ROUNDUP(sizeof(rtdns)) - sizeof(rtdns);
836 if (padlen > 0) {
837 iov[iovcnt].iov_base = &pad;
838 iov[iovcnt++].iov_len = padlen;
839 rtm.rtm_msglen += padlen;
840 }
841
842 if (writev(routesock, iov, iovcnt) == -1)
843 log_warn("failed to send route message");
844 }
845
846 #ifndef SMALL
847 const char*
sin6_to_str(struct sockaddr_in6 * sin6)848 sin6_to_str(struct sockaddr_in6 *sin6)
849 {
850 static char hbuf[NI_MAXHOST];
851 int error;
852
853 error = getnameinfo((struct sockaddr *)sin6, sin6->sin6_len, hbuf,
854 sizeof(hbuf), NULL, 0, NI_NUMERICHOST | NI_NUMERICSERV);
855 if (error) {
856 log_warnx("%s", gai_strerror(error));
857 strlcpy(hbuf, "unknown", sizeof(hbuf));
858 }
859 return hbuf;
860 }
861 #endif /* SMALL */
862
863 int
get_soiikey(uint8_t * key)864 get_soiikey(uint8_t *key)
865 {
866 int mib[4] = {CTL_NET, PF_INET6, IPPROTO_IPV6, IPV6CTL_SOIIKEY};
867 size_t size = SLAACD_SOIIKEY_LEN;
868
869 return sysctl(mib, sizeof(mib) / sizeof(mib[0]), key, &size, NULL, 0);
870 }
871
872 void
open_icmp6sock(int rdomain)873 open_icmp6sock(int rdomain)
874 {
875 int icmp6sock, on = 1;
876
877 log_debug("%s: %d", __func__, rdomain);
878
879 if ((icmp6sock = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC,
880 IPPROTO_ICMPV6)) == -1)
881 fatal("ICMPv6 socket");
882
883 if (setsockopt(icmp6sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &on,
884 sizeof(on)) == -1)
885 fatal("IPV6_RECVPKTINFO");
886
887 if (setsockopt(icmp6sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on,
888 sizeof(on)) == -1)
889 fatal("IPV6_RECVHOPLIMIT");
890
891 if (setsockopt(icmp6sock, SOL_SOCKET, SO_RTABLE, &rdomain,
892 sizeof(rdomain)) == -1) {
893 /* we might race against removal of the rdomain */
894 log_warn("setsockopt SO_RTABLE");
895 close(icmp6sock);
896 return;
897 }
898
899 main_imsg_compose_frontend(IMSG_ICMP6SOCK, icmp6sock, &rdomain,
900 sizeof(rdomain));
901 }
902