1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3  * Privilege Separation for dhcpcd, network proxy
4  * Copyright (c) 2006-2021 Roy Marples <roy@marples.name>
5  * All rights reserved
6 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/socket.h>
30 #include <sys/types.h>
31 
32 #include <netinet/in.h>
33 #include <netinet/icmp6.h>
34 
35 #include <assert.h>
36 #include <errno.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 
41 #include "arp.h"
42 #include "bpf.h"
43 #include "dhcp.h"
44 #include "dhcp6.h"
45 #include "eloop.h"
46 #include "ipv6nd.h"
47 #include "logerr.h"
48 #include "privsep.h"
49 
50 #ifdef INET
51 static void
ps_inet_recvbootp(void * arg)52 ps_inet_recvbootp(void *arg)
53 {
54 	struct dhcpcd_ctx *ctx = arg;
55 
56 	if (ps_recvmsg(ctx, ctx->udp_rfd, PS_BOOTP, ctx->ps_inet_fd) == -1)
57 		logerr(__func__);
58 }
59 #endif
60 
61 #ifdef INET6
62 static void
ps_inet_recvra(void * arg)63 ps_inet_recvra(void *arg)
64 {
65 #ifdef __sun
66 	struct interface *ifp = arg;
67 	struct rs_state *state = RS_STATE(ifp);
68 	struct dhcpcd_ctx *ctx = ifp->ctx;
69 
70 	if (ps_recvmsg(ctx, state->nd_fd, PS_ND, ctx->ps_inet_fd) == -1)
71 		logerr(__func__);
72 #else
73 	struct dhcpcd_ctx *ctx = arg;
74 
75 	if (ps_recvmsg(ctx, ctx->nd_fd, PS_ND, ctx->ps_inet_fd) == -1)
76 		logerr(__func__);
77 #endif
78 }
79 #endif
80 
81 #ifdef DHCP6
82 static void
ps_inet_recvdhcp6(void * arg)83 ps_inet_recvdhcp6(void *arg)
84 {
85 	struct dhcpcd_ctx *ctx = arg;
86 
87 	if (ps_recvmsg(ctx, ctx->dhcp6_rfd, PS_DHCP6, ctx->ps_inet_fd) == -1)
88 		logerr(__func__);
89 }
90 #endif
91 
92 bool
ps_inet_canstart(const struct dhcpcd_ctx * ctx)93 ps_inet_canstart(const struct dhcpcd_ctx *ctx)
94 {
95 
96 #ifdef INET
97 	if ((ctx->options & (DHCPCD_IPV4 | DHCPCD_MANAGER)) ==
98 	    (DHCPCD_IPV4 | DHCPCD_MANAGER))
99 		return true;
100 #endif
101 #if defined(INET6) && !defined(__sun)
102 	if (ctx->options & DHCPCD_IPV6)
103 		return true;
104 #endif
105 #ifdef DHCP6
106 	if ((ctx->options & (DHCPCD_IPV6 | DHCPCD_MANAGER)) ==
107 	    (DHCPCD_IPV6 | DHCPCD_MANAGER))
108 		return true;
109 #endif
110 
111 	return false;
112 }
113 
114 static int
ps_inet_startcb(void * arg)115 ps_inet_startcb(void *arg)
116 {
117 	struct dhcpcd_ctx *ctx = arg;
118 	int ret = 0;
119 
120 	if (ctx->options & DHCPCD_MANAGER)
121 		setproctitle("[network proxy]");
122 	else
123 		setproctitle("[network proxy] %s%s%s",
124 		    ctx->ifv[0],
125 		    ctx->options & DHCPCD_IPV4 ? " [ip4]" : "",
126 		    ctx->options & DHCPCD_IPV6 ? " [ip6]" : "");
127 
128 	/* This end is the main engine, so it's useless for us. */
129 	close(ctx->ps_data_fd);
130 	ctx->ps_data_fd = -1;
131 
132 	errno = 0;
133 
134 #ifdef INET
135 	if ((ctx->options & (DHCPCD_IPV4 | DHCPCD_MANAGER)) ==
136 	    (DHCPCD_IPV4 | DHCPCD_MANAGER))
137 	{
138 		ctx->udp_rfd = dhcp_openudp(NULL);
139 		if (ctx->udp_rfd == -1)
140 			logerr("%s: dhcp_open", __func__);
141 #ifdef PRIVSEP_RIGHTS
142 		else if (ps_rights_limit_fd_rdonly(ctx->udp_rfd) == -1) {
143 			logerr("%s: ps_rights_limit_fd_rdonly", __func__);
144 			close(ctx->udp_rfd);
145 			ctx->udp_rfd = -1;
146 		}
147 #endif
148 		else if (eloop_event_add(ctx->eloop, ctx->udp_rfd,
149 		    ps_inet_recvbootp, ctx) == -1)
150 		{
151 			logerr("%s: eloop_event_add DHCP", __func__);
152 			close(ctx->udp_rfd);
153 			ctx->udp_rfd = -1;
154 		} else
155 			ret++;
156 	}
157 #endif
158 #if defined(INET6) && !defined(__sun)
159 	if (ctx->options & DHCPCD_IPV6) {
160 		ctx->nd_fd = ipv6nd_open(true);
161 		if (ctx->nd_fd == -1)
162 			logerr("%s: ipv6nd_open", __func__);
163 #ifdef PRIVSEP_RIGHTS
164 		else if (ps_rights_limit_fd_rdonly(ctx->nd_fd) == -1) {
165 			logerr("%s: ps_rights_limit_fd_rdonly", __func__);
166 			close(ctx->nd_fd);
167 			ctx->nd_fd = -1;
168 		}
169 #endif
170 		else if (eloop_event_add(ctx->eloop, ctx->nd_fd,
171 		    ps_inet_recvra, ctx) == -1)
172 		{
173 			logerr("%s: eloop_event_add RA", __func__);
174 			close(ctx->nd_fd);
175 			ctx->nd_fd = -1;
176 		} else
177 			ret++;
178 	}
179 #endif
180 #ifdef DHCP6
181 	if ((ctx->options & (DHCPCD_IPV6 | DHCPCD_MANAGER)) ==
182 	    (DHCPCD_IPV6 | DHCPCD_MANAGER))
183 	{
184 		ctx->dhcp6_rfd = dhcp6_openudp(0, NULL);
185 		if (ctx->dhcp6_rfd == -1)
186 			logerr("%s: dhcp6_open", __func__);
187 #ifdef PRIVSEP_RIGHTS
188 		else if (ps_rights_limit_fd_rdonly(ctx->dhcp6_rfd) == -1) {
189 			logerr("%s: ps_rights_limit_fd_rdonly", __func__);
190 			close(ctx->dhcp6_rfd);
191 			ctx->dhcp6_rfd = -1;
192 		}
193 #endif
194 		else if (eloop_event_add(ctx->eloop, ctx->dhcp6_rfd,
195 		    ps_inet_recvdhcp6, ctx) == -1)
196 		{
197 			logerr("%s: eloop_event_add DHCP6", __func__);
198 			close(ctx->dhcp6_rfd);
199 			ctx->dhcp6_rfd = -1;
200 		} else
201 			ret++;
202 	}
203 #endif
204 
205 	if (ret == 0 && errno == 0) {
206 		errno = ENXIO;
207 		return -1;
208 	}
209 	return ret;
210 }
211 
212 static bool
ps_inet_validudp(struct msghdr * msg,uint16_t sport,uint16_t dport)213 ps_inet_validudp(struct msghdr *msg, uint16_t sport, uint16_t dport)
214 {
215 	struct udphdr udp;
216 	struct iovec *iov = msg->msg_iov;
217 
218 	if (msg->msg_iovlen == 0 || iov->iov_len < sizeof(udp)) {
219 		errno = EINVAL;
220 		return false;
221 	}
222 
223 	memcpy(&udp, iov->iov_base, sizeof(udp));
224 	if (udp.uh_sport != htons(sport) || udp.uh_dport != htons(dport)) {
225 		errno = EPERM;
226 		return false;
227 	}
228 	return true;
229 }
230 
231 #ifdef INET6
232 static bool
ps_inet_validnd(struct msghdr * msg)233 ps_inet_validnd(struct msghdr *msg)
234 {
235 	struct icmp6_hdr icmp6;
236 	struct iovec *iov = msg->msg_iov;
237 
238 	if (msg->msg_iovlen == 0 || iov->iov_len < sizeof(icmp6)) {
239 		errno = EINVAL;
240 		return false;
241 	}
242 
243 	memcpy(&icmp6, iov->iov_base, sizeof(icmp6));
244 	switch(icmp6.icmp6_type) {
245 	case ND_ROUTER_SOLICIT:
246 	case ND_NEIGHBOR_ADVERT:
247 		break;
248 	default:
249 		errno = EPERM;
250 		return false;
251 	}
252 
253 	return true;
254 }
255 #endif
256 
257 static ssize_t
ps_inet_sendmsg(struct dhcpcd_ctx * ctx,struct ps_msghdr * psm,struct msghdr * msg)258 ps_inet_sendmsg(struct dhcpcd_ctx *ctx,
259     struct ps_msghdr *psm, struct msghdr *msg)
260 {
261 	struct ps_process *psp;
262 	int s;
263 
264 	psp = ps_findprocess(ctx, &psm->ps_id);
265 	if (psp != NULL) {
266 		s = psp->psp_work_fd;
267 		goto dosend;
268 	}
269 
270 	switch (psm->ps_cmd) {
271 #ifdef INET
272 	case PS_BOOTP:
273 		if (!ps_inet_validudp(msg, BOOTPC, BOOTPS))
274 			return -1;
275 		s = ctx->udp_wfd;
276 		break;
277 #endif
278 #if defined(INET6) && !defined(__sun)
279 	case PS_ND:
280 		if (!ps_inet_validnd(msg))
281 			return -1;
282 		s = ctx->nd_fd;
283 		break;
284 #endif
285 #ifdef DHCP6
286 	case PS_DHCP6:
287 		if (!ps_inet_validudp(msg, DHCP6_CLIENT_PORT,DHCP6_SERVER_PORT))
288 			return -1;
289 		s = ctx->dhcp6_wfd;
290 		break;
291 #endif
292 	default:
293 		errno = EINVAL;
294 		return -1;
295 	}
296 
297 dosend:
298 	return sendmsg(s, msg, 0);
299 }
300 
301 static void
ps_inet_recvmsg(void * arg)302 ps_inet_recvmsg(void *arg)
303 {
304 	struct dhcpcd_ctx *ctx = arg;
305 
306 	/* Receive shutdown */
307 	if (ps_recvpsmsg(ctx, ctx->ps_inet_fd, NULL, NULL) == -1)
308 		logerr(__func__);
309 }
310 
311 ssize_t
ps_inet_dispatch(void * arg,struct ps_msghdr * psm,struct msghdr * msg)312 ps_inet_dispatch(void *arg, struct ps_msghdr *psm, struct msghdr *msg)
313 {
314 	struct dhcpcd_ctx *ctx = arg;
315 
316 	switch (psm->ps_cmd) {
317 #ifdef INET
318 	case PS_BOOTP:
319 		dhcp_recvmsg(ctx, msg);
320 		break;
321 #endif
322 #ifdef INET6
323 	case PS_ND:
324 		ipv6nd_recvmsg(ctx, msg);
325 		break;
326 #endif
327 #ifdef DHCP6
328 	case PS_DHCP6:
329 		dhcp6_recvmsg(ctx, msg, NULL);
330 		break;
331 #endif
332 	default:
333 		errno = ENOTSUP;
334 		return -1;
335 	}
336 	return 1;
337 }
338 
339 static void
ps_inet_dodispatch(void * arg)340 ps_inet_dodispatch(void *arg)
341 {
342 	struct dhcpcd_ctx *ctx = arg;
343 
344 	if (ps_recvpsmsg(ctx, ctx->ps_inet_fd, ps_inet_dispatch, ctx) == -1)
345 		logerr(__func__);
346 }
347 
348 pid_t
ps_inet_start(struct dhcpcd_ctx * ctx)349 ps_inet_start(struct dhcpcd_ctx *ctx)
350 {
351 	pid_t pid;
352 
353 	pid = ps_dostart(ctx, &ctx->ps_inet_pid, &ctx->ps_inet_fd,
354 	    ps_inet_recvmsg, ps_inet_dodispatch, ctx,
355 	    ps_inet_startcb, NULL,
356 	    PSF_DROPPRIVS);
357 
358 	if (pid == 0)
359 		ps_entersandbox("stdio", NULL);
360 
361 	return pid;
362 }
363 
364 int
ps_inet_stop(struct dhcpcd_ctx * ctx)365 ps_inet_stop(struct dhcpcd_ctx *ctx)
366 {
367 
368 	return ps_dostop(ctx, &ctx->ps_inet_pid, &ctx->ps_inet_fd);
369 }
370 
371 #ifdef INET
372 static void
ps_inet_recvinbootp(void * arg)373 ps_inet_recvinbootp(void *arg)
374 {
375 	struct ps_process *psp = arg;
376 
377 	if (ps_recvmsg(psp->psp_ctx, psp->psp_work_fd,
378 	    PS_BOOTP, psp->psp_ctx->ps_data_fd) == -1)
379 		logerr(__func__);
380 }
381 
382 static int
ps_inet_listenin(void * arg)383 ps_inet_listenin(void *arg)
384 {
385 	struct ps_process *psp = arg;
386 	struct in_addr *ia = &psp->psp_id.psi_addr.psa_in_addr;
387 	char buf[INET_ADDRSTRLEN];
388 
389 	inet_ntop(AF_INET, ia, buf, sizeof(buf));
390 	setproctitle("[network proxy] %s", buf);
391 
392 	psp->psp_work_fd = dhcp_openudp(ia);
393 	if (psp->psp_work_fd == -1) {
394 		logerr(__func__);
395 		return -1;
396 	}
397 
398 #ifdef PRIVSEP_RIGHTS
399 	if (ps_rights_limit_fd_rdonly(psp->psp_work_fd) == -1) {
400 		logerr("%s: ps_rights_limit_fd_rdonly", __func__);
401 		return -1;
402 	}
403 #endif
404 
405 	if (eloop_event_add(psp->psp_ctx->eloop, psp->psp_work_fd,
406 	    ps_inet_recvinbootp, psp) == -1)
407 	{
408 		logerr("%s: eloop_event_add DHCP", __func__);
409 		return -1;
410 	}
411 
412 	logdebugx("spawned listener %s on PID %d", buf, getpid());
413 	return 0;
414 }
415 #endif
416 
417 #if defined(INET6) && defined(__sun)
418 static void
ps_inet_recvin6nd(void * arg)419 ps_inet_recvin6nd(void *arg)
420 {
421 	struct ps_process *psp = arg;
422 
423 	if (ps_recvmsg(psp->psp_ctx, psp->psp_work_fd,
424 	    PS_ND, psp->psp_ctx->ps_data_fd) == -1)
425 		logerr(__func__);
426 }
427 
428 static int
ps_inet_listennd(void * arg)429 ps_inet_listennd(void *arg)
430 {
431 	struct ps_process *psp = arg;
432 
433 	setproctitle("[ND network proxy]");
434 
435 	psp->psp_work_fd = ipv6nd_open(&psp->psp_ifp);
436 	if (psp->psp_work_fd == -1) {
437 		logerr(__func__);
438 		return -1;
439 	}
440 
441 #ifdef PRIVSEP_RIGHTS
442 	if (ps_rights_limit_fd_rdonly(psp->psp_work_fd) == -1) {
443 		logerr("%s: ps_rights_limit_fd_rdonly", __func__);
444 		return -1;
445 	}
446 #endif
447 
448 	if (eloop_event_add(psp->psp_ctx->eloop, psp->psp_work_fd,
449 	    ps_inet_recvin6nd, psp) == -1)
450 	{
451 		logerr(__func__);
452 		return -1;
453 	}
454 
455 	logdebugx("spawned ND listener on PID %d", getpid());
456 	return 0;
457 }
458 #endif
459 
460 #ifdef DHCP6
461 static void
ps_inet_recvin6dhcp6(void * arg)462 ps_inet_recvin6dhcp6(void *arg)
463 {
464 	struct ps_process *psp = arg;
465 
466 	if (ps_recvmsg(psp->psp_ctx, psp->psp_work_fd,
467 	    PS_DHCP6, psp->psp_ctx->ps_data_fd) == -1)
468 		logerr(__func__);
469 }
470 
471 static int
ps_inet_listenin6(void * arg)472 ps_inet_listenin6(void *arg)
473 {
474 	struct ps_process *psp = arg;
475 	struct in6_addr *ia = &psp->psp_id.psi_addr.psa_in6_addr;
476 	char buf[INET6_ADDRSTRLEN];
477 
478 	inet_ntop(AF_INET6, ia, buf, sizeof(buf));
479 	setproctitle("[network proxy] %s", buf);
480 
481 	psp->psp_work_fd = dhcp6_openudp(psp->psp_id.psi_ifindex, ia);
482 	if (psp->psp_work_fd == -1) {
483 		logerr(__func__);
484 		return -1;
485 	}
486 
487 #ifdef PRIVSEP_RIGHTS
488 	if (ps_rights_limit_fd_rdonly(psp->psp_work_fd) == -1) {
489 		logerr("%s: ps_rights_limit_fd_rdonly", __func__);
490 		return -1;
491 	}
492 #endif
493 
494 	if (eloop_event_add(psp->psp_ctx->eloop, psp->psp_work_fd,
495 	    ps_inet_recvin6dhcp6, psp) == -1)
496 	{
497 		logerr("%s: eloop_event_add DHCP", __func__);
498 		return -1;
499 	}
500 
501 	logdebugx("spawned listener %s on PID %d", buf, getpid());
502 	return 0;
503 }
504 #endif
505 
506 static void
ps_inet_recvmsgpsp(void * arg)507 ps_inet_recvmsgpsp(void *arg)
508 {
509 	struct ps_process *psp = arg;
510 
511 	/* Receive shutdown. */
512 	if (ps_recvpsmsg(psp->psp_ctx, psp->psp_fd, NULL, NULL) == -1)
513 		logerr(__func__);
514 }
515 
516 ssize_t
ps_inet_cmd(struct dhcpcd_ctx * ctx,struct ps_msghdr * psm,struct msghdr * msg)517 ps_inet_cmd(struct dhcpcd_ctx *ctx, struct ps_msghdr *psm, struct msghdr *msg)
518 {
519 	uint16_t cmd;
520 	struct ps_process *psp;
521 	int (*start_func)(void *);
522 	pid_t start;
523 
524 	cmd = (uint16_t)(psm->ps_cmd & ~(PS_START | PS_STOP));
525 	if (cmd == psm->ps_cmd)
526 		return ps_inet_sendmsg(ctx, psm, msg);
527 
528 	psp = ps_findprocess(ctx, &psm->ps_id);
529 
530 #ifdef PRIVSEP_DEBUG
531 	logerrx("%s: IN cmd %x, psp %p", __func__, psm->ps_cmd, psp);
532 #endif
533 
534 	if (psm->ps_cmd & PS_STOP) {
535 		assert(psp == NULL);
536 		return 0;
537 	}
538 
539 	switch (cmd) {
540 #ifdef INET
541 	case PS_BOOTP:
542 		start_func = ps_inet_listenin;
543 		break;
544 #endif
545 #ifdef INET6
546 #ifdef __sun
547 	case PS_ND:
548 		start_func = ps_inet_listennd;
549 		break;
550 #endif
551 #ifdef DHCP6
552 	case PS_DHCP6:
553 		start_func = ps_inet_listenin6;
554 		break;
555 #endif
556 #endif
557 	default:
558 		logerrx("%s: unknown command %x", __func__, psm->ps_cmd);
559 		errno = ENOTSUP;
560 		return -1;
561 	}
562 
563 	if (!(psm->ps_cmd & PS_START)) {
564 		errno = EINVAL;
565 		return -1;
566 	}
567 
568 	if (psp != NULL)
569 		return 1;
570 
571 	psp = ps_newprocess(ctx, &psm->ps_id);
572 	if (psp == NULL)
573 		return -1;
574 
575 	start = ps_dostart(ctx,
576 	    &psp->psp_pid, &psp->psp_fd,
577 	    ps_inet_recvmsgpsp, NULL, psp,
578 	    start_func, NULL,
579 	    PSF_DROPPRIVS);
580 	switch (start) {
581 	case -1:
582 		ps_freeprocess(psp);
583 		return -1;
584 	case 0:
585 		ps_entersandbox("stdio", NULL);
586 		break;
587 	default:
588 		break;
589 	}
590 	return start;
591 }
592 
593 #ifdef INET
594 static ssize_t
ps_inet_in_docmd(struct ipv4_addr * ia,uint16_t cmd,const struct msghdr * msg)595 ps_inet_in_docmd(struct ipv4_addr *ia, uint16_t cmd, const struct msghdr *msg)
596 {
597 	assert(ia != NULL);
598 	struct dhcpcd_ctx *ctx = ia->iface->ctx;
599 	struct ps_msghdr psm = {
600 		.ps_cmd = cmd,
601 		.ps_id = {
602 			.psi_cmd = (uint8_t)(cmd & ~(PS_START | PS_STOP)),
603 			.psi_ifindex = ia->iface->index,
604 			.psi_addr.psa_in_addr = ia->addr,
605 		},
606 	};
607 
608 	return ps_sendpsmmsg(ctx, ctx->ps_root_fd, &psm, msg);
609 }
610 
611 ssize_t
ps_inet_openbootp(struct ipv4_addr * ia)612 ps_inet_openbootp(struct ipv4_addr *ia)
613 {
614 
615 	return ps_inet_in_docmd(ia, PS_START | PS_BOOTP, NULL);
616 }
617 
618 ssize_t
ps_inet_closebootp(struct ipv4_addr * ia)619 ps_inet_closebootp(struct ipv4_addr *ia)
620 {
621 
622 	return ps_inet_in_docmd(ia, PS_STOP | PS_BOOTP, NULL);
623 }
624 
625 ssize_t
ps_inet_sendbootp(struct interface * ifp,const struct msghdr * msg)626 ps_inet_sendbootp(struct interface *ifp, const struct msghdr *msg)
627 {
628 
629 	return ps_sendmsg(ifp->ctx, ifp->ctx->ps_root_fd, PS_BOOTP, 0, msg);
630 }
631 #endif /* INET */
632 
633 #ifdef INET6
634 #ifdef __sun
635 static ssize_t
ps_inet_ifp_docmd(struct interface * ifp,uint16_t cmd,const struct msghdr * msg)636 ps_inet_ifp_docmd(struct interface *ifp, uint16_t cmd, const struct msghdr *msg)
637 {
638 	struct dhcpcd_ctx *ctx = ifp->ctx;
639 	struct ps_msghdr psm = {
640 		.ps_cmd = cmd,
641 		.ps_id = {
642 			.psi_cmd = (uint8_t)(cmd & ~(PS_START | PS_STOP)),
643 			.psi_ifindex = ifp->index,
644 		},
645 	};
646 
647 	return ps_sendpsmmsg(ctx, ctx->ps_root_fd, &psm, msg);
648 }
649 
650 ssize_t
ps_inet_opennd(struct interface * ifp)651 ps_inet_opennd(struct interface *ifp)
652 {
653 
654 	return ps_inet_ifp_docmd(ifp, PS_ND | PS_START, NULL);
655 }
656 
657 ssize_t
ps_inet_closend(struct interface * ifp)658 ps_inet_closend(struct interface *ifp)
659 {
660 
661 	return ps_inet_ifp_docmd(ifp, PS_ND | PS_STOP, NULL);
662 }
663 
664 ssize_t
ps_inet_sendnd(struct interface * ifp,const struct msghdr * msg)665 ps_inet_sendnd(struct interface *ifp, const struct msghdr *msg)
666 {
667 
668 	return ps_inet_ifp_docmd(ifp, PS_ND, msg);
669 }
670 #else
671 ssize_t
ps_inet_sendnd(struct interface * ifp,const struct msghdr * msg)672 ps_inet_sendnd(struct interface *ifp, const struct msghdr *msg)
673 {
674 
675 	return ps_sendmsg(ifp->ctx, ifp->ctx->ps_root_fd, PS_ND, 0, msg);
676 }
677 #endif
678 
679 #ifdef DHCP6
680 static ssize_t
ps_inet_in6_docmd(struct ipv6_addr * ia,uint16_t cmd,const struct msghdr * msg)681 ps_inet_in6_docmd(struct ipv6_addr *ia, uint16_t cmd, const struct msghdr *msg)
682 {
683 	struct dhcpcd_ctx *ctx = ia->iface->ctx;
684 	struct ps_msghdr psm = {
685 		.ps_cmd = cmd,
686 		.ps_id = {
687 			.psi_cmd = (uint8_t)(cmd & ~(PS_START | PS_STOP)),
688 			.psi_ifindex = ia->iface->index,
689 			.psi_addr.psa_in6_addr = ia->addr,
690 		},
691 	};
692 
693 	return ps_sendpsmmsg(ctx, ctx->ps_root_fd, &psm, msg);
694 }
695 
696 ssize_t
ps_inet_opendhcp6(struct ipv6_addr * ia)697 ps_inet_opendhcp6(struct ipv6_addr *ia)
698 {
699 
700 	return ps_inet_in6_docmd(ia, PS_DHCP6 | PS_START, NULL);
701 }
702 
703 ssize_t
ps_inet_closedhcp6(struct ipv6_addr * ia)704 ps_inet_closedhcp6(struct ipv6_addr *ia)
705 {
706 
707 	return ps_inet_in6_docmd(ia, PS_DHCP6 | PS_STOP, NULL);
708 }
709 
710 ssize_t
ps_inet_senddhcp6(struct interface * ifp,const struct msghdr * msg)711 ps_inet_senddhcp6(struct interface *ifp, const struct msghdr *msg)
712 {
713 
714 	return ps_sendmsg(ifp->ctx, ifp->ctx->ps_root_fd, PS_DHCP6, 0, msg);
715 }
716 #endif /* DHCP6 */
717 #endif /* INET6 */
718