1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3 * Privilege Separation for dhcpcd, privileged 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/ioctl.h>
30 #include <sys/socket.h>
31 #include <sys/stat.h>
32 #include <sys/time.h>
33 #include <sys/types.h>
34 #include <sys/wait.h>
35
36 #include <assert.h>
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <pwd.h>
40 #include <signal.h>
41 #include <stddef.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45
46 #include "auth.h"
47 #include "common.h"
48 #include "dev.h"
49 #include "dhcpcd.h"
50 #include "dhcp6.h"
51 #include "eloop.h"
52 #include "if.h"
53 #include "ipv6nd.h"
54 #include "logerr.h"
55 #include "privsep.h"
56 #include "sa.h"
57 #include "script.h"
58
59 __CTASSERT(sizeof(ioctl_request_t) <= sizeof(unsigned long));
60
61 struct psr_error
62 {
63 ssize_t psr_result;
64 int psr_errno;
65 char psr_pad[sizeof(ssize_t) - sizeof(int)];
66 size_t psr_datalen;
67 };
68
69 struct psr_ctx {
70 struct dhcpcd_ctx *psr_ctx;
71 struct psr_error psr_error;
72 size_t psr_datalen;
73 void *psr_data;
74 };
75
76 static void
ps_root_readerrorcb(void * arg)77 ps_root_readerrorcb(void *arg)
78 {
79 struct psr_ctx *psr_ctx = arg;
80 struct dhcpcd_ctx *ctx = psr_ctx->psr_ctx;
81 struct psr_error *psr_error = &psr_ctx->psr_error;
82 struct iovec iov[] = {
83 { .iov_base = psr_error, .iov_len = sizeof(*psr_error) },
84 { .iov_base = psr_ctx->psr_data,
85 .iov_len = psr_ctx->psr_datalen },
86 };
87 ssize_t len;
88 int exit_code = EXIT_FAILURE;
89
90 #define PSR_ERROR(e) \
91 do { \
92 psr_error->psr_result = -1; \
93 psr_error->psr_errno = (e); \
94 goto out; \
95 } while (0 /* CONSTCOND */)
96
97 len = readv(ctx->ps_root_fd, iov, __arraycount(iov));
98 if (len == -1)
99 PSR_ERROR(errno);
100 else if ((size_t)len < sizeof(*psr_error))
101 PSR_ERROR(EINVAL);
102 exit_code = EXIT_SUCCESS;
103
104 out:
105 eloop_exit(ctx->ps_eloop, exit_code);
106 }
107
108 ssize_t
ps_root_readerror(struct dhcpcd_ctx * ctx,void * data,size_t len)109 ps_root_readerror(struct dhcpcd_ctx *ctx, void *data, size_t len)
110 {
111 struct psr_ctx psr_ctx = {
112 .psr_ctx = ctx,
113 .psr_data = data, .psr_datalen = len,
114 };
115
116 if (eloop_event_add(ctx->ps_eloop, ctx->ps_root_fd,
117 ps_root_readerrorcb, &psr_ctx) == -1)
118 return -1;
119
120 eloop_enter(ctx->ps_eloop);
121 eloop_start(ctx->ps_eloop, &ctx->sigset);
122
123 errno = psr_ctx.psr_error.psr_errno;
124 return psr_ctx.psr_error.psr_result;
125 }
126
127 #ifdef PRIVSEP_GETIFADDRS
128 static void
ps_root_mreaderrorcb(void * arg)129 ps_root_mreaderrorcb(void *arg)
130 {
131 struct psr_ctx *psr_ctx = arg;
132 struct dhcpcd_ctx *ctx = psr_ctx->psr_ctx;
133 struct psr_error *psr_error = &psr_ctx->psr_error;
134 struct iovec iov[] = {
135 { .iov_base = psr_error, .iov_len = sizeof(*psr_error) },
136 { .iov_base = NULL, .iov_len = 0 },
137 };
138 ssize_t len;
139 int exit_code = EXIT_FAILURE;
140
141 len = recv(ctx->ps_root_fd, psr_error, sizeof(*psr_error), MSG_PEEK);
142 if (len == -1)
143 PSR_ERROR(errno);
144 else if ((size_t)len < sizeof(*psr_error))
145 PSR_ERROR(EINVAL);
146
147 if (psr_error->psr_datalen > SSIZE_MAX)
148 PSR_ERROR(ENOBUFS);
149 else if (psr_error->psr_datalen != 0) {
150 psr_ctx->psr_data = malloc(psr_error->psr_datalen);
151 if (psr_ctx->psr_data == NULL)
152 PSR_ERROR(errno);
153 psr_ctx->psr_datalen = psr_error->psr_datalen;
154 iov[1].iov_base = psr_ctx->psr_data;
155 iov[1].iov_len = psr_ctx->psr_datalen;
156 }
157
158 len = readv(ctx->ps_root_fd, iov, __arraycount(iov));
159 if (len == -1)
160 PSR_ERROR(errno);
161 else if ((size_t)len != sizeof(*psr_error) + psr_ctx->psr_datalen)
162 PSR_ERROR(EINVAL);
163 exit_code = EXIT_SUCCESS;
164
165 out:
166 eloop_exit(ctx->ps_eloop, exit_code);
167 }
168
169 ssize_t
ps_root_mreaderror(struct dhcpcd_ctx * ctx,void ** data,size_t * len)170 ps_root_mreaderror(struct dhcpcd_ctx *ctx, void **data, size_t *len)
171 {
172 struct psr_ctx psr_ctx = {
173 .psr_ctx = ctx,
174 };
175
176 if (eloop_event_add(ctx->ps_eloop, ctx->ps_root_fd,
177 ps_root_mreaderrorcb, &psr_ctx) == -1)
178 return -1;
179
180 eloop_enter(ctx->ps_eloop);
181 eloop_start(ctx->ps_eloop, &ctx->sigset);
182
183 errno = psr_ctx.psr_error.psr_errno;
184 *data = psr_ctx.psr_data;
185 *len = psr_ctx.psr_datalen;
186 return psr_ctx.psr_error.psr_result;
187 }
188 #endif
189
190 static ssize_t
ps_root_writeerror(struct dhcpcd_ctx * ctx,ssize_t result,void * data,size_t len)191 ps_root_writeerror(struct dhcpcd_ctx *ctx, ssize_t result,
192 void *data, size_t len)
193 {
194 struct psr_error psr = {
195 .psr_result = result,
196 .psr_errno = errno,
197 .psr_datalen = len,
198 };
199 struct iovec iov[] = {
200 { .iov_base = &psr, .iov_len = sizeof(psr) },
201 { .iov_base = data, .iov_len = len },
202 };
203
204 #ifdef PRIVSEP_DEBUG
205 logdebugx("%s: result %zd errno %d", __func__, result, errno);
206 #endif
207
208 return writev(ctx->ps_root_fd, iov, __arraycount(iov));
209 }
210
211 static ssize_t
ps_root_doioctl(unsigned long req,void * data,size_t len)212 ps_root_doioctl(unsigned long req, void *data, size_t len)
213 {
214 int s, err;
215
216 /* Only allow these ioctls */
217 switch(req) {
218 #ifdef SIOCAIFADDR
219 case SIOCAIFADDR: /* FALLTHROUGH */
220 case SIOCDIFADDR: /* FALLTHROUGH */
221 #endif
222 #ifdef SIOCSIFHWADDR
223 case SIOCSIFHWADDR: /* FALLTHROUGH */
224 #endif
225 #ifdef SIOCGIFPRIORITY
226 case SIOCGIFPRIORITY: /* FALLTHROUGH */
227 #endif
228 case SIOCSIFFLAGS: /* FALLTHROUGH */
229 case SIOCGIFMTU: /* FALLTHROUGH */
230 case SIOCSIFMTU:
231 break;
232 default:
233 errno = EPERM;
234 return -1;
235 }
236
237 s = socket(PF_INET, SOCK_DGRAM, 0);
238 if (s != -1)
239 #ifdef IOCTL_REQUEST_TYPE
240 {
241 ioctl_request_t reqt;
242
243 memcpy(&reqt, &req, sizeof(reqt));
244 err = ioctl(s, reqt, data, len);
245 }
246 #else
247 err = ioctl(s, req, data, len);
248 #endif
249 else
250 err = -1;
251 if (s != -1)
252 close(s);
253 return err;
254 }
255
256 static ssize_t
ps_root_run_script(struct dhcpcd_ctx * ctx,const void * data,size_t len)257 ps_root_run_script(struct dhcpcd_ctx *ctx, const void *data, size_t len)
258 {
259 const char *envbuf = data;
260 char * const argv[] = { ctx->script, NULL };
261 pid_t pid;
262 int status;
263
264 if (len == 0)
265 return 0;
266
267 if (script_buftoenv(ctx, UNCONST(envbuf), len) == NULL)
268 return -1;
269
270 pid = script_exec(argv, ctx->script_env);
271 if (pid == -1)
272 return -1;
273 /* Wait for the script to finish */
274 while (waitpid(pid, &status, 0) == -1) {
275 if (errno != EINTR) {
276 logerr(__func__);
277 status = 0;
278 break;
279 }
280 }
281 return status;
282 }
283
284 static bool
ps_root_validpath(const struct dhcpcd_ctx * ctx,uint16_t cmd,const char * path)285 ps_root_validpath(const struct dhcpcd_ctx *ctx, uint16_t cmd, const char *path)
286 {
287
288 /* Avoid a previous directory attack to avoid /proc/../
289 * dhcpcd should never use a path with double dots. */
290 if (strstr(path, "..") != NULL)
291 return false;
292
293 if (cmd == PS_READFILE) {
294 #ifdef EMBEDDED_CONFIG
295 if (strcmp(ctx->cffile, EMBEDDED_CONFIG) == 0)
296 return true;
297 #endif
298 if (strcmp(ctx->cffile, path) == 0)
299 return true;
300 }
301 if (strncmp(DBDIR, path, strlen(DBDIR)) == 0)
302 return true;
303 if (strncmp(RUNDIR, path, strlen(RUNDIR)) == 0)
304 return true;
305
306 #ifdef __linux__
307 if (strncmp("/proc/net/", path, strlen("/proc/net/")) == 0 ||
308 strncmp("/proc/sys/net/", path, strlen("/proc/sys/net/")) == 0 ||
309 strncmp("/sys/class/net/", path, strlen("/sys/class/net/")) == 0)
310 return true;
311 #endif
312
313 errno = EPERM;
314 return false;
315 }
316
317 static ssize_t
ps_root_dowritefile(const struct dhcpcd_ctx * ctx,mode_t mode,void * data,size_t len)318 ps_root_dowritefile(const struct dhcpcd_ctx *ctx,
319 mode_t mode, void *data, size_t len)
320 {
321 char *file = data, *nc;
322
323 nc = memchr(file, '\0', len);
324 if (nc == NULL) {
325 errno = EINVAL;
326 return -1;
327 }
328
329 if (!ps_root_validpath(ctx, PS_WRITEFILE, file))
330 return -1;
331 nc++;
332 return writefile(file, mode, nc, len - (size_t)(nc - file));
333 }
334
335 #ifdef AUTH
336 static ssize_t
ps_root_monordm(uint64_t * rdm,size_t len)337 ps_root_monordm(uint64_t *rdm, size_t len)
338 {
339
340 if (len != sizeof(*rdm)) {
341 errno = EINVAL;
342 return -1;
343 }
344 return auth_get_rdm_monotonic(rdm);
345 }
346 #endif
347
348 #ifdef PRIVSEP_GETIFADDRS
349 #define IFA_NADDRS 4
350 static ssize_t
ps_root_dogetifaddrs(void ** rdata,size_t * rlen)351 ps_root_dogetifaddrs(void **rdata, size_t *rlen)
352 {
353 struct ifaddrs *ifaddrs, *ifa;
354 size_t len;
355 uint8_t *buf, *sap;
356 socklen_t salen;
357
358 if (getifaddrs(&ifaddrs) == -1)
359 return -1;
360 if (ifaddrs == NULL) {
361 *rdata = NULL;
362 *rlen = 0;
363 return 0;
364 }
365
366 /* Work out the buffer length required.
367 * Ensure everything is aligned correctly, which does
368 * create a larger buffer than what is needed to send,
369 * but makes creating the same structure in the client
370 * much easier. */
371 len = 0;
372 for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
373 len += ALIGN(sizeof(*ifa));
374 len += ALIGN(IFNAMSIZ);
375 len += ALIGN(sizeof(salen) * IFA_NADDRS);
376 if (ifa->ifa_addr != NULL)
377 len += ALIGN(sa_len(ifa->ifa_addr));
378 if (ifa->ifa_netmask != NULL)
379 len += ALIGN(sa_len(ifa->ifa_netmask));
380 if (ifa->ifa_broadaddr != NULL)
381 len += ALIGN(sa_len(ifa->ifa_broadaddr));
382 #ifdef BSD
383 /*
384 * On BSD we need to carry ifa_data so we can access
385 * if_data->ifi_link_state
386 */
387 if (ifa->ifa_addr != NULL &&
388 ifa->ifa_addr->sa_family == AF_LINK)
389 len += ALIGN(sizeof(struct if_data));
390 #endif
391 }
392
393 /* Use calloc to set everything to zero.
394 * This satisfies memory sanitizers because don't write
395 * where we don't need to. */
396 buf = calloc(1, len);
397 if (buf == NULL) {
398 freeifaddrs(ifaddrs);
399 return -1;
400 }
401 *rdata = buf;
402 *rlen = len;
403
404 for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
405 memcpy(buf, ifa, sizeof(*ifa));
406 buf += ALIGN(sizeof(*ifa));
407
408 strlcpy((char *)buf, ifa->ifa_name, IFNAMSIZ);
409 buf += ALIGN(IFNAMSIZ);
410 sap = buf;
411 buf += ALIGN(sizeof(salen) * IFA_NADDRS);
412
413 #define COPYINSA(addr) \
414 do { \
415 if ((addr) != NULL) \
416 salen = sa_len((addr)); \
417 else \
418 salen = 0; \
419 if (salen != 0) { \
420 memcpy(sap, &salen, sizeof(salen)); \
421 memcpy(buf, (addr), salen); \
422 buf += ALIGN(salen); \
423 } \
424 sap += sizeof(salen); \
425 } while (0 /*CONSTCOND */)
426
427 COPYINSA(ifa->ifa_addr);
428 COPYINSA(ifa->ifa_netmask);
429 COPYINSA(ifa->ifa_broadaddr);
430
431 #ifdef BSD
432 if (ifa->ifa_addr != NULL &&
433 ifa->ifa_addr->sa_family == AF_LINK)
434 {
435 salen = (socklen_t)sizeof(struct if_data);
436 memcpy(buf, ifa->ifa_data, salen);
437 buf += ALIGN(salen);
438 } else
439 #endif
440 salen = 0;
441 memcpy(sap, &salen, sizeof(salen));
442 }
443
444 freeifaddrs(ifaddrs);
445 return 0;
446 }
447 #endif
448
449 static ssize_t
ps_root_recvmsgcb(void * arg,struct ps_msghdr * psm,struct msghdr * msg)450 ps_root_recvmsgcb(void *arg, struct ps_msghdr *psm, struct msghdr *msg)
451 {
452 struct dhcpcd_ctx *ctx = arg;
453 uint16_t cmd;
454 struct ps_process *psp;
455 struct iovec *iov = msg->msg_iov;
456 void *data = iov->iov_base, *rdata = NULL;
457 size_t len = iov->iov_len, rlen = 0;
458 uint8_t buf[PS_BUFLEN];
459 time_t mtime;
460 ssize_t err;
461 bool free_rdata = false;
462
463 cmd = (uint16_t)(psm->ps_cmd & ~(PS_START | PS_STOP));
464 psp = ps_findprocess(ctx, &psm->ps_id);
465
466 #ifdef PRIVSEP_DEBUG
467 logerrx("%s: IN cmd %x, psp %p", __func__, psm->ps_cmd, psp);
468 #endif
469
470 if (psp != NULL) {
471 if (psm->ps_cmd & PS_STOP) {
472 int ret = ps_dostop(ctx, &psp->psp_pid, &psp->psp_fd);
473
474 ps_freeprocess(psp);
475 return ret;
476 } else if (psm->ps_cmd & PS_START) {
477 /* Process has already started .... */
478 return 0;
479 }
480
481 err = ps_sendpsmmsg(ctx, psp->psp_fd, psm, msg);
482 if (err == -1) {
483 logerr("%s: failed to send message to pid %d",
484 __func__, psp->psp_pid);
485 shutdown(psp->psp_fd, SHUT_RDWR);
486 close(psp->psp_fd);
487 psp->psp_fd = -1;
488 ps_freeprocess(psp);
489 }
490 return 0;
491 }
492
493 if (psm->ps_cmd & PS_STOP && psp == NULL)
494 return 0;
495
496 switch (cmd) {
497 #ifdef INET
498 #ifdef ARP
499 case PS_BPF_ARP: /* FALLTHROUGH */
500 #endif
501 case PS_BPF_BOOTP:
502 return ps_bpf_cmd(ctx, psm, msg);
503 #endif
504 #ifdef INET
505 case PS_BOOTP:
506 return ps_inet_cmd(ctx, psm, msg);
507 #endif
508 #ifdef INET6
509 #ifdef DHCP6
510 case PS_DHCP6: /* FALLTHROUGH */
511 #endif
512 case PS_ND:
513 return ps_inet_cmd(ctx, psm, msg);
514 #endif
515 default:
516 break;
517 }
518
519 assert(msg->msg_iovlen == 0 || msg->msg_iovlen == 1);
520
521 /* Reset errno */
522 errno = 0;
523
524 switch (psm->ps_cmd) {
525 case PS_IOCTL:
526 err = ps_root_doioctl(psm->ps_flags, data, len);
527 if (err != -1) {
528 rdata = data;
529 rlen = len;
530 }
531 break;
532 case PS_SCRIPT:
533 err = ps_root_run_script(ctx, data, len);
534 break;
535 case PS_UNLINK:
536 if (!ps_root_validpath(ctx, psm->ps_cmd, data)) {
537 err = -1;
538 break;
539 }
540 err = unlink(data);
541 break;
542 case PS_READFILE:
543 if (!ps_root_validpath(ctx, psm->ps_cmd, data)) {
544 err = -1;
545 break;
546 }
547 err = readfile(data, buf, sizeof(buf));
548 if (err != -1) {
549 rdata = buf;
550 rlen = (size_t)err;
551 }
552 break;
553 case PS_WRITEFILE:
554 err = ps_root_dowritefile(ctx, (mode_t)psm->ps_flags,
555 data, len);
556 break;
557 case PS_FILEMTIME:
558 err = filemtime(data, &mtime);
559 if (err != -1) {
560 rdata = &mtime;
561 rlen = sizeof(mtime);
562 }
563 break;
564 case PS_LOGREOPEN:
565 err = logopen(ctx->logfile);
566 break;
567 #ifdef AUTH
568 case PS_AUTH_MONORDM:
569 err = ps_root_monordm(data, len);
570 if (err != -1) {
571 rdata = data;
572 rlen = len;
573 }
574 break;
575 #endif
576 #ifdef PRIVSEP_GETIFADDRS
577 case PS_GETIFADDRS:
578 err = ps_root_dogetifaddrs(&rdata, &rlen);
579 free_rdata = true;
580 break;
581 #endif
582 #if defined(INET6) && (defined(__linux__) || defined(HAVE_PLEDGE))
583 case PS_IP6FORWARDING:
584 err = ip6_forwarding(data);
585 break;
586 #endif
587 #ifdef PLUGIN_DEV
588 case PS_DEV_INITTED:
589 err = dev_initialised(ctx, data);
590 break;
591 case PS_DEV_LISTENING:
592 err = dev_listening(ctx);
593 break;
594 #endif
595 default:
596 err = ps_root_os(psm, msg, &rdata, &rlen);
597 break;
598 }
599
600 err = ps_root_writeerror(ctx, err, rlen != 0 ? rdata : 0, rlen);
601 if (free_rdata)
602 free(rdata);
603 return err;
604 }
605
606 /* Receive from state engine, do an action. */
607 static void
ps_root_recvmsg(void * arg)608 ps_root_recvmsg(void *arg)
609 {
610 struct dhcpcd_ctx *ctx = arg;
611
612 if (ps_recvpsmsg(ctx, ctx->ps_root_fd, ps_root_recvmsgcb, ctx) == -1)
613 logerr(__func__);
614 }
615
616 #ifdef PLUGIN_DEV
617 static int
ps_root_handleinterface(void * arg,int action,const char * ifname)618 ps_root_handleinterface(void *arg, int action, const char *ifname)
619 {
620 struct dhcpcd_ctx *ctx = arg;
621 unsigned long flag;
622
623 if (action == 1)
624 flag = PS_DEV_IFADDED;
625 else if (action == -1)
626 flag = PS_DEV_IFREMOVED;
627 else if (action == 0)
628 flag = PS_DEV_IFUPDATED;
629 else {
630 errno = EINVAL;
631 return -1;
632 }
633
634 return (int)ps_sendcmd(ctx, ctx->ps_data_fd, PS_DEV_IFCMD, flag,
635 ifname, strlen(ifname) + 1);
636 }
637 #endif
638
639 static int
ps_root_startcb(void * arg)640 ps_root_startcb(void *arg)
641 {
642 struct dhcpcd_ctx *ctx = arg;
643
644 if (ctx->options & DHCPCD_MANAGER)
645 setproctitle("[privileged proxy]");
646 else
647 setproctitle("[privileged proxy] %s%s%s",
648 ctx->ifv[0],
649 ctx->options & DHCPCD_IPV4 ? " [ip4]" : "",
650 ctx->options & DHCPCD_IPV6 ? " [ip6]" : "");
651 ctx->ps_root_pid = getpid();
652 ctx->options |= DHCPCD_PRIVSEPROOT;
653
654 /* Open network sockets for sending.
655 * This is a small bit wasteful for non sandboxed OS's
656 * but makes life very easy for unicasting DHCPv6 in non manager
657 * mode as we no longer care about address selection.
658 * We can't call shutdown SHUT_RD on the socket because it's
659 * not connectd. All we can do is try and set a zero sized
660 * receive buffer and just let it overflow.
661 * Reading from it just to drain it is a waste of CPU time. */
662 #ifdef INET
663 if (ctx->options & DHCPCD_IPV4) {
664 int buflen = 1;
665
666 ctx->udp_wfd = xsocket(PF_INET,
667 SOCK_RAW | SOCK_CXNB, IPPROTO_UDP);
668 if (ctx->udp_wfd == -1)
669 logerr("%s: dhcp_openraw", __func__);
670 else if (setsockopt(ctx->udp_wfd, SOL_SOCKET, SO_RCVBUF,
671 &buflen, sizeof(buflen)) == -1)
672 logerr("%s: setsockopt SO_RCVBUF DHCP", __func__);
673 }
674 #endif
675 #ifdef INET6
676 if (ctx->options & DHCPCD_IPV6) {
677 int buflen = 1;
678
679 ctx->nd_fd = ipv6nd_open(false);
680 if (ctx->nd_fd == -1)
681 logerr("%s: ipv6nd_open", __func__);
682 else if (setsockopt(ctx->nd_fd, SOL_SOCKET, SO_RCVBUF,
683 &buflen, sizeof(buflen)) == -1)
684 logerr("%s: setsockopt SO_RCVBUF ND", __func__);
685 }
686 #endif
687 #ifdef DHCP6
688 if (ctx->options & DHCPCD_IPV6) {
689 int buflen = 1;
690
691 ctx->dhcp6_wfd = dhcp6_openraw();
692 if (ctx->dhcp6_wfd == -1)
693 logerr("%s: dhcp6_openraw", __func__);
694 else if (setsockopt(ctx->dhcp6_wfd, SOL_SOCKET, SO_RCVBUF,
695 &buflen, sizeof(buflen)) == -1)
696 logerr("%s: setsockopt SO_RCVBUF DHCP6", __func__);
697 }
698 #endif
699
700 #ifdef PLUGIN_DEV
701 /* Start any dev listening plugin which may want to
702 * change the interface name provided by the kernel */
703 if ((ctx->options & (DHCPCD_MANAGER | DHCPCD_DEV)) ==
704 (DHCPCD_MANAGER | DHCPCD_DEV))
705 dev_start(ctx, ps_root_handleinterface);
706 #endif
707
708 return 0;
709 }
710
711 static void
ps_root_signalcb(int sig,__unused void * arg)712 ps_root_signalcb(int sig, __unused void *arg)
713 {
714
715 if (sig == SIGCHLD) {
716 while (waitpid(-1, NULL, WNOHANG) > 0)
717 ;
718 return;
719 }
720 }
721
722 int (*handle_interface)(void *, int, const char *);
723
724 #ifdef PLUGIN_DEV
725 static ssize_t
ps_root_devcb(struct dhcpcd_ctx * ctx,struct ps_msghdr * psm,struct msghdr * msg)726 ps_root_devcb(struct dhcpcd_ctx *ctx, struct ps_msghdr *psm, struct msghdr *msg)
727 {
728 int action;
729 struct iovec *iov = msg->msg_iov;
730
731 if (msg->msg_iovlen != 1) {
732 errno = EINVAL;
733 return -1;
734 }
735
736 switch(psm->ps_flags) {
737 case PS_DEV_IFADDED:
738 action = 1;
739 break;
740 case PS_DEV_IFREMOVED:
741 action = -1;
742 break;
743 case PS_DEV_IFUPDATED:
744 action = 0;
745 break;
746 default:
747 errno = EINVAL;
748 return -1;
749 }
750
751 return dhcpcd_handleinterface(ctx, action, iov->iov_base);
752 }
753 #endif
754
755 static ssize_t
ps_root_dispatchcb(void * arg,struct ps_msghdr * psm,struct msghdr * msg)756 ps_root_dispatchcb(void *arg, struct ps_msghdr *psm, struct msghdr *msg)
757 {
758 struct dhcpcd_ctx *ctx = arg;
759 ssize_t err;
760
761 switch(psm->ps_cmd) {
762 #ifdef PLUGIN_DEV
763 case PS_DEV_IFCMD:
764 err = ps_root_devcb(ctx, psm, msg);
765 break;
766 #endif
767 default:
768 #ifdef INET
769 err = ps_bpf_dispatch(ctx, psm, msg);
770 if (err == -1 && errno == ENOTSUP)
771 #endif
772 err = ps_inet_dispatch(ctx, psm, msg);
773 }
774 return err;
775 }
776
777 static void
ps_root_dispatch(void * arg)778 ps_root_dispatch(void *arg)
779 {
780 struct dhcpcd_ctx *ctx = arg;
781
782 if (ps_recvpsmsg(ctx, ctx->ps_data_fd, ps_root_dispatchcb, ctx) == -1)
783 logerr(__func__);
784 }
785
786 static void
ps_root_log(void * arg)787 ps_root_log(void *arg)
788 {
789 struct dhcpcd_ctx *ctx = arg;
790
791 if (logreadfd(ctx->ps_log_fd) == -1)
792 logerr(__func__);
793 }
794
795 pid_t
ps_root_start(struct dhcpcd_ctx * ctx)796 ps_root_start(struct dhcpcd_ctx *ctx)
797 {
798 int logfd[2], datafd[2];
799 pid_t pid;
800
801 if (xsocketpair(AF_UNIX, SOCK_DGRAM | SOCK_CXNB, 0, logfd) == -1)
802 return -1;
803 #ifdef PRIVSEP_RIGHTS
804 if (ps_rights_limit_fdpair(logfd) == -1)
805 return -1;
806 #endif
807
808 if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CXNB, 0, datafd) == -1)
809 return -1;
810 if (ps_setbuf_fdpair(datafd) == -1)
811 return -1;
812 #ifdef PRIVSEP_RIGHTS
813 if (ps_rights_limit_fdpair(datafd) == -1)
814 return -1;
815 #endif
816
817 pid = ps_dostart(ctx, &ctx->ps_root_pid, &ctx->ps_root_fd,
818 ps_root_recvmsg, NULL, ctx,
819 ps_root_startcb, ps_root_signalcb, 0);
820
821 if (pid == 0) {
822 ctx->ps_log_fd = logfd[1];
823 if (eloop_event_add(ctx->eloop, ctx->ps_log_fd,
824 ps_root_log, ctx) == -1)
825 return -1;
826 close(logfd[0]);
827 ctx->ps_data_fd = datafd[1];
828 close(datafd[0]);
829 return 0;
830 } else if (pid == -1)
831 return -1;
832
833 logsetfd(logfd[0]);
834 close(logfd[1]);
835
836 ctx->ps_data_fd = datafd[0];
837 close(datafd[1]);
838 if (eloop_event_add(ctx->eloop, ctx->ps_data_fd,
839 ps_root_dispatch, ctx) == -1)
840 return -1;
841
842 if ((ctx->ps_eloop = eloop_new()) == NULL)
843 return -1;
844
845 eloop_signal_set_cb(ctx->ps_eloop,
846 dhcpcd_signals, dhcpcd_signals_len,
847 ps_root_signalcb, ctx);
848
849 return pid;
850 }
851
852 int
ps_root_stop(struct dhcpcd_ctx * ctx)853 ps_root_stop(struct dhcpcd_ctx *ctx)
854 {
855
856 return ps_dostop(ctx, &ctx->ps_root_pid, &ctx->ps_root_fd);
857 }
858
859 ssize_t
ps_root_script(struct dhcpcd_ctx * ctx,const void * data,size_t len)860 ps_root_script(struct dhcpcd_ctx *ctx, const void *data, size_t len)
861 {
862
863 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_SCRIPT, 0, data, len) == -1)
864 return -1;
865 return ps_root_readerror(ctx, NULL, 0);
866 }
867
868 ssize_t
ps_root_ioctl(struct dhcpcd_ctx * ctx,ioctl_request_t req,void * data,size_t len)869 ps_root_ioctl(struct dhcpcd_ctx *ctx, ioctl_request_t req, void *data,
870 size_t len)
871 {
872 #ifdef IOCTL_REQUEST_TYPE
873 unsigned long ulreq = 0;
874
875 memcpy(&ulreq, &req, sizeof(req));
876 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_IOCTL, ulreq, data, len) == -1)
877 return -1;
878 #else
879 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_IOCTL, req, data, len) == -1)
880 return -1;
881 #endif
882 return ps_root_readerror(ctx, data, len);
883 }
884
885 ssize_t
ps_root_unlink(struct dhcpcd_ctx * ctx,const char * file)886 ps_root_unlink(struct dhcpcd_ctx *ctx, const char *file)
887 {
888
889 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_UNLINK, 0,
890 file, strlen(file) + 1) == -1)
891 return -1;
892 return ps_root_readerror(ctx, NULL, 0);
893 }
894
895 ssize_t
ps_root_readfile(struct dhcpcd_ctx * ctx,const char * file,void * data,size_t len)896 ps_root_readfile(struct dhcpcd_ctx *ctx, const char *file,
897 void *data, size_t len)
898 {
899 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_READFILE, 0,
900 file, strlen(file) + 1) == -1)
901 return -1;
902 return ps_root_readerror(ctx, data, len);
903 }
904
905 ssize_t
ps_root_writefile(struct dhcpcd_ctx * ctx,const char * file,mode_t mode,const void * data,size_t len)906 ps_root_writefile(struct dhcpcd_ctx *ctx, const char *file, mode_t mode,
907 const void *data, size_t len)
908 {
909 char buf[PS_BUFLEN];
910 size_t flen;
911
912 flen = strlcpy(buf, file, sizeof(buf));
913 flen += 1;
914 if (flen > sizeof(buf) || flen + len > sizeof(buf)) {
915 errno = ENOBUFS;
916 return -1;
917 }
918 memcpy(buf + flen, data, len);
919
920 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_WRITEFILE, mode,
921 buf, flen + len) == -1)
922 return -1;
923 return ps_root_readerror(ctx, NULL, 0);
924 }
925
926 ssize_t
ps_root_filemtime(struct dhcpcd_ctx * ctx,const char * file,time_t * time)927 ps_root_filemtime(struct dhcpcd_ctx *ctx, const char *file, time_t *time)
928 {
929
930 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_FILEMTIME, 0,
931 file, strlen(file) + 1) == -1)
932 return -1;
933 return ps_root_readerror(ctx, time, sizeof(*time));
934 }
935
936 ssize_t
ps_root_logreopen(struct dhcpcd_ctx * ctx)937 ps_root_logreopen(struct dhcpcd_ctx *ctx)
938 {
939
940 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_LOGREOPEN, 0, NULL, 0) == -1)
941 return -1;
942 return ps_root_readerror(ctx, NULL, 0);
943 }
944
945 #ifdef PRIVSEP_GETIFADDRS
946 int
ps_root_getifaddrs(struct dhcpcd_ctx * ctx,struct ifaddrs ** ifahead)947 ps_root_getifaddrs(struct dhcpcd_ctx *ctx, struct ifaddrs **ifahead)
948 {
949 struct ifaddrs *ifa;
950 void *buf = NULL;
951 char *bp, *sap;
952 socklen_t salen;
953 size_t len;
954 ssize_t err;
955
956 if (ps_sendcmd(ctx, ctx->ps_root_fd,
957 PS_GETIFADDRS, 0, NULL, 0) == -1)
958 return -1;
959 err = ps_root_mreaderror(ctx, &buf, &len);
960
961 if (err == -1)
962 return -1;
963
964 /* Should be impossible - lo0 will always exist. */
965 if (len == 0) {
966 *ifahead = NULL;
967 return 0;
968 }
969
970 bp = buf;
971 *ifahead = (struct ifaddrs *)(void *)bp;
972 for (ifa = *ifahead; ifa != NULL; ifa = ifa->ifa_next) {
973 if (len < ALIGN(sizeof(*ifa)) +
974 ALIGN(IFNAMSIZ) + ALIGN(sizeof(salen) * IFA_NADDRS))
975 goto err;
976 bp += ALIGN(sizeof(*ifa));
977 ifa->ifa_name = bp;
978 bp += ALIGN(IFNAMSIZ);
979 sap = bp;
980 bp += ALIGN(sizeof(salen) * IFA_NADDRS);
981 len -= ALIGN(sizeof(*ifa)) +
982 ALIGN(IFNAMSIZ) + ALIGN(sizeof(salen) * IFA_NADDRS);
983
984 #define COPYOUTSA(addr) \
985 do { \
986 memcpy(&salen, sap, sizeof(salen)); \
987 if (len < salen) \
988 goto err; \
989 if (salen != 0) { \
990 (addr) = (struct sockaddr *)bp; \
991 bp += ALIGN(salen); \
992 len -= ALIGN(salen); \
993 } \
994 sap += sizeof(salen); \
995 } while (0 /* CONSTCOND */)
996
997 COPYOUTSA(ifa->ifa_addr);
998 COPYOUTSA(ifa->ifa_netmask);
999 COPYOUTSA(ifa->ifa_broadaddr);
1000
1001 memcpy(&salen, sap, sizeof(salen));
1002 if (len < salen)
1003 goto err;
1004 if (salen != 0) {
1005 ifa->ifa_data = bp;
1006 bp += ALIGN(salen);
1007 len -= ALIGN(salen);
1008 } else
1009 ifa->ifa_data = NULL;
1010
1011 if (len != 0)
1012 ifa->ifa_next = (struct ifaddrs *)(void *)bp;
1013 else
1014 ifa->ifa_next = NULL;
1015 }
1016 return 0;
1017
1018 err:
1019 free(buf);
1020 *ifahead = NULL;
1021 errno = EINVAL;
1022 return -1;
1023 }
1024 #endif
1025
1026 #if defined(__linux__) || defined(HAVE_PLEDGE)
1027 ssize_t
ps_root_ip6forwarding(struct dhcpcd_ctx * ctx,const char * ifname)1028 ps_root_ip6forwarding(struct dhcpcd_ctx *ctx, const char *ifname)
1029 {
1030
1031 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_IP6FORWARDING, 0,
1032 ifname, ifname != NULL ? strlen(ifname) + 1 : 0) == -1)
1033 return -1;
1034 return ps_root_readerror(ctx, NULL, 0);
1035 }
1036 #endif
1037
1038 #ifdef AUTH
1039 int
ps_root_getauthrdm(struct dhcpcd_ctx * ctx,uint64_t * rdm)1040 ps_root_getauthrdm(struct dhcpcd_ctx *ctx, uint64_t *rdm)
1041 {
1042
1043 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_AUTH_MONORDM, 0,
1044 rdm, sizeof(*rdm))== -1)
1045 return -1;
1046 return (int)ps_root_readerror(ctx, rdm, sizeof(*rdm));
1047 }
1048 #endif
1049
1050 #ifdef PLUGIN_DEV
1051 int
ps_root_dev_initialised(struct dhcpcd_ctx * ctx,const char * ifname)1052 ps_root_dev_initialised(struct dhcpcd_ctx *ctx, const char *ifname)
1053 {
1054
1055 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_DEV_INITTED, 0,
1056 ifname, strlen(ifname) + 1)== -1)
1057 return -1;
1058 return (int)ps_root_readerror(ctx, NULL, 0);
1059 }
1060
1061 int
ps_root_dev_listening(struct dhcpcd_ctx * ctx)1062 ps_root_dev_listening(struct dhcpcd_ctx * ctx)
1063 {
1064
1065 if (ps_sendcmd(ctx, ctx->ps_root_fd, PS_DEV_LISTENING, 0, NULL, 0)== -1)
1066 return -1;
1067 return (int)ps_root_readerror(ctx, NULL, 0);
1068 }
1069 #endif
1070