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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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