1 /* stSPDX-License-Identifier: BSD-2-Clause */ 2 /* 3 * dhcpcd - DHCP client daemon 4 * Copyright (c) 2006-2020 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/stat.h> 30 #include <sys/uio.h> 31 #include <sys/wait.h> 32 33 #include <netinet/in.h> 34 #include <arpa/inet.h> 35 36 #include <assert.h> 37 #include <ctype.h> 38 #include <errno.h> 39 #include <pwd.h> 40 #include <signal.h> 41 #include <spawn.h> 42 #include <stdarg.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <unistd.h> 46 47 #include "config.h" 48 #include "common.h" 49 #include "dhcp.h" 50 #include "dhcp6.h" 51 #include "eloop.h" 52 #include "if.h" 53 #include "if-options.h" 54 #include "ipv4ll.h" 55 #include "ipv6nd.h" 56 #include "logerr.h" 57 #include "privsep.h" 58 #include "script.h" 59 60 #define DEFAULT_PATH "/usr/bin:/usr/sbin:/bin:/sbin" 61 62 static const char * const if_params[] = { 63 "interface", 64 "protocol", 65 "reason", 66 "pid", 67 "ifcarrier", 68 "ifmetric", 69 "ifwireless", 70 "ifflags", 71 "ssid", 72 "profile", 73 "interface_order", 74 NULL 75 }; 76 77 void 78 if_printoptions(void) 79 { 80 const char * const *p; 81 82 for (p = if_params; *p; p++) 83 printf(" - %s\n", *p); 84 } 85 86 pid_t 87 script_exec(char *const *argv, char *const *env) 88 { 89 pid_t pid = 0; 90 posix_spawnattr_t attr; 91 int r; 92 #ifdef USE_SIGNALS 93 size_t i; 94 short flags; 95 sigset_t defsigs; 96 #else 97 UNUSED(ctx); 98 #endif 99 100 /* posix_spawn is a safe way of executing another image 101 * and changing signals back to how they should be. */ 102 if (posix_spawnattr_init(&attr) == -1) 103 return -1; 104 #ifdef USE_SIGNALS 105 flags = POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF; 106 posix_spawnattr_setflags(&attr, flags); 107 sigemptyset(&defsigs); 108 posix_spawnattr_setsigmask(&attr, &defsigs); 109 for (i = 0; i < dhcpcd_signals_len; i++) 110 sigaddset(&defsigs, dhcpcd_signals[i]); 111 posix_spawnattr_setsigdefault(&attr, &defsigs); 112 #endif 113 errno = 0; 114 r = posix_spawn(&pid, argv[0], NULL, &attr, argv, env); 115 posix_spawnattr_destroy(&attr); 116 if (r) { 117 errno = r; 118 return -1; 119 } 120 return pid; 121 } 122 123 #ifdef INET 124 static int 125 append_config(FILE *fp, const char *prefix, const char *const *config) 126 { 127 size_t i; 128 129 if (config == NULL) 130 return 0; 131 132 /* Do we need to replace existing config rather than append? */ 133 for (i = 0; config[i] != NULL; i++) { 134 if (efprintf(fp, "%s_%s", prefix, config[i]) == -1) 135 return -1; 136 } 137 return 1; 138 } 139 140 #endif 141 142 #define PROTO_LINK 0 143 #define PROTO_DHCP 1 144 #define PROTO_IPV4LL 2 145 #define PROTO_RA 3 146 #define PROTO_DHCP6 4 147 #define PROTO_STATIC6 5 148 static const char *protocols[] = { 149 "link", 150 "dhcp", 151 "ipv4ll", 152 "ra", 153 "dhcp6", 154 "static6" 155 }; 156 157 int 158 efprintf(FILE *fp, const char *fmt, ...) 159 { 160 va_list args; 161 int r; 162 163 va_start(args, fmt); 164 r = vfprintf(fp, fmt, args); 165 va_end(args); 166 if (r == -1) 167 return -1; 168 /* Write a trailing NULL so we can easily create env strings. */ 169 if (fputc('\0', fp) == EOF) 170 return -1; 171 return r; 172 } 173 174 char ** 175 script_buftoenv(struct dhcpcd_ctx *ctx, char *buf, size_t len) 176 { 177 char **env, **envp, *bufp, *endp; 178 size_t nenv; 179 180 /* Count the terminated env strings. 181 * Assert that the terminations are correct. */ 182 nenv = 0; 183 endp = buf + len; 184 for (bufp = buf; bufp < endp; bufp++) { 185 if (*bufp == '\0') { 186 #ifndef NDEBUG 187 if (bufp + 1 < endp) 188 assert(*(bufp + 1) != '\0'); 189 #endif 190 nenv++; 191 } 192 } 193 assert(*(bufp - 1) == '\0'); 194 195 if (ctx->script_envlen < nenv) { 196 env = reallocarray(ctx->script_env, nenv + 1, sizeof(*env)); 197 if (env == NULL) 198 return NULL; 199 ctx->script_env = env; 200 ctx->script_envlen = nenv; 201 } 202 203 bufp = buf; 204 envp = ctx->script_env; 205 *envp++ = bufp++; 206 endp--; /* Avoid setting the last \0 to an invalid pointer */ 207 for (; bufp < endp; bufp++) { 208 if (*bufp == '\0') 209 *envp++ = bufp + 1; 210 } 211 *envp = NULL; 212 213 return ctx->script_env; 214 } 215 216 static long 217 make_env(struct dhcpcd_ctx *ctx, const struct interface *ifp, 218 const char *reason) 219 { 220 FILE *fp; 221 long buf_pos, i; 222 char *path; 223 int protocol = PROTO_LINK; 224 const struct if_options *ifo; 225 const struct interface *ifp2; 226 int af; 227 #ifdef INET 228 const struct dhcp_state *state; 229 #ifdef IPV4LL 230 const struct ipv4ll_state *istate; 231 #endif 232 #endif 233 #ifdef DHCP6 234 const struct dhcp6_state *d6_state; 235 #endif 236 237 #ifdef HAVE_OPEN_MEMSTREAM 238 if (ctx->script_fp == NULL) { 239 fp = open_memstream(&ctx->script_buf, &ctx->script_buflen); 240 if (fp == NULL) 241 goto eexit; 242 ctx->script_fp = fp; 243 } else { 244 fp = ctx->script_fp; 245 rewind(fp); 246 } 247 #else 248 char tmpfile[] = "/tmp/dhcpcd-script-env-XXXXXX"; 249 int tmpfd; 250 251 fp = NULL; 252 tmpfd = mkstemp(tmpfile); 253 if (tmpfd == -1) 254 goto eexit; 255 unlink(tmpfile); 256 fp = fdopen(tmpfd, "w+"); 257 if (fp == NULL) { 258 close(tmpfd); 259 goto eexit; 260 } 261 #endif 262 263 /* Needed for scripts */ 264 path = getenv("PATH"); 265 if (efprintf(fp, "PATH=%s", path == NULL ? DEFAULT_PATH:path) == -1) 266 goto eexit; 267 if (efprintf(fp, "reason=%s", reason) == -1) 268 goto eexit; 269 if (efprintf(fp, "pid=%d", getpid()) == -1) 270 goto eexit; 271 272 #ifdef PRIVSEP 273 if (ctx->options & DHCPCD_PRIVSEP && ctx->ps_user != NULL) { 274 if (efprintf(fp, "chroot=%s", ctx->ps_user->pw_dir) == -1) 275 goto eexit; 276 } 277 if (strcmp(reason, "CHROOT") == 0) 278 goto make; 279 #endif 280 281 ifo = ifp->options; 282 #ifdef INET 283 state = D_STATE(ifp); 284 #ifdef IPV4LL 285 istate = IPV4LL_CSTATE(ifp); 286 #endif 287 #endif 288 #ifdef DHCP6 289 d6_state = D6_CSTATE(ifp); 290 #endif 291 if (strcmp(reason, "TEST") == 0) { 292 if (1 == 2) { 293 /* This space left intentionally blank 294 * as all the below statements are optional. */ 295 } 296 #ifdef INET6 297 #ifdef DHCP6 298 else if (d6_state && d6_state->new) 299 protocol = PROTO_DHCP6; 300 #endif 301 else if (ipv6nd_hasra(ifp)) 302 protocol = PROTO_RA; 303 #endif 304 #ifdef INET 305 #ifdef IPV4LL 306 else if (istate && istate->addr != NULL) 307 protocol = PROTO_IPV4LL; 308 #endif 309 else 310 protocol = PROTO_DHCP; 311 #endif 312 } 313 #ifdef INET6 314 else if (strcmp(reason, "STATIC6") == 0) 315 protocol = PROTO_STATIC6; 316 #ifdef DHCP6 317 else if (reason[strlen(reason) - 1] == '6') 318 protocol = PROTO_DHCP6; 319 #endif 320 else if (strcmp(reason, "ROUTERADVERT") == 0) 321 protocol = PROTO_RA; 322 #endif 323 else if (strcmp(reason, "PREINIT") == 0 || 324 strcmp(reason, "CARRIER") == 0 || 325 strcmp(reason, "NOCARRIER") == 0 || 326 strcmp(reason, "UNKNOWN") == 0 || 327 strcmp(reason, "DEPARTED") == 0 || 328 strcmp(reason, "STOPPED") == 0) 329 protocol = PROTO_LINK; 330 #ifdef INET 331 #ifdef IPV4LL 332 else if (strcmp(reason, "IPV4LL") == 0) 333 protocol = PROTO_IPV4LL; 334 #endif 335 else 336 protocol = PROTO_DHCP; 337 #endif 338 339 340 if (efprintf(fp, "interface=%s", ifp->name) == -1) 341 goto eexit; 342 if (ifp->ctx->options & DHCPCD_DUMPLEASE) 343 goto dumplease; 344 if (efprintf(fp, "ifcarrier=%s", 345 ifp->carrier == LINK_UNKNOWN ? "unknown" : 346 ifp->carrier == LINK_UP ? "up" : "down") == -1) 347 goto eexit; 348 if (efprintf(fp, "ifmetric=%d", ifp->metric) == -1) 349 goto eexit; 350 if (efprintf(fp, "ifwireless=%d", ifp->wireless) == -1) 351 goto eexit; 352 if (efprintf(fp, "ifflags=%u", ifp->flags) == -1) 353 goto eexit; 354 if (efprintf(fp, "ifmtu=%d", if_getmtu(ifp)) == -1) 355 goto eexit; 356 357 if (fprintf(fp, "interface_order=") == -1) 358 goto eexit; 359 TAILQ_FOREACH(ifp2, ifp->ctx->ifaces, next) { 360 if (ifp2 != TAILQ_FIRST(ifp->ctx->ifaces)) { 361 if (fputc(' ', fp) == EOF) 362 return -1; 363 } 364 if (fprintf(fp, "%s", ifp2->name) == -1) 365 return -1; 366 } 367 if (fputc('\0', fp) == EOF) 368 return -1; 369 370 if (strcmp(reason, "STOPPED") == 0) { 371 if (efprintf(fp, "if_up=false") == -1) 372 goto eexit; 373 if (efprintf(fp, "if_down=%s", 374 ifo->options & DHCPCD_RELEASE ? "true" : "false") == -1) 375 goto eexit; 376 } else if (strcmp(reason, "TEST") == 0 || 377 strcmp(reason, "PREINIT") == 0 || 378 strcmp(reason, "CARRIER") == 0 || 379 strcmp(reason, "UNKNOWN") == 0) 380 { 381 if (efprintf(fp, "if_up=false") == -1) 382 goto eexit; 383 if (efprintf(fp, "if_down=false") == -1) 384 goto eexit; 385 } else if (1 == 2 /* appease ifdefs */ 386 #ifdef INET 387 || (protocol == PROTO_DHCP && state && state->new) 388 #ifdef IPV4LL 389 || (protocol == PROTO_IPV4LL && IPV4LL_STATE_RUNNING(ifp)) 390 #endif 391 #endif 392 #ifdef INET6 393 || (protocol == PROTO_STATIC6 && IPV6_STATE_RUNNING(ifp)) 394 #ifdef DHCP6 395 || (protocol == PROTO_DHCP6 && d6_state && d6_state->new) 396 #endif 397 || (protocol == PROTO_RA && ipv6nd_hasra(ifp)) 398 #endif 399 ) 400 { 401 if (efprintf(fp, "if_up=true") == -1) 402 goto eexit; 403 if (efprintf(fp, "if_down=false") == -1) 404 goto eexit; 405 } else { 406 if (efprintf(fp, "if_up=false") == -1) 407 goto eexit; 408 if (efprintf(fp, "if_down=true") == -1) 409 goto eexit; 410 } 411 if (protocols[protocol] != NULL) { 412 if (efprintf(fp, "protocol=%s", protocols[protocol]) == -1) 413 goto eexit; 414 } 415 if ((af = dhcpcd_ifafwaiting(ifp)) != AF_MAX) { 416 if (efprintf(fp, "if_afwaiting=%d", af) == -1) 417 goto eexit; 418 } 419 if ((af = dhcpcd_afwaiting(ifp->ctx)) != AF_MAX) { 420 TAILQ_FOREACH(ifp2, ifp->ctx->ifaces, next) { 421 if ((af = dhcpcd_ifafwaiting(ifp2)) != AF_MAX) 422 break; 423 } 424 } 425 if (af != AF_MAX) { 426 if (efprintf(fp, "af_waiting=%d", af) == -1) 427 goto eexit; 428 } 429 if (ifo->options & DHCPCD_DEBUG) { 430 if (efprintf(fp, "syslog_debug=true") == -1) 431 goto eexit; 432 } 433 if (*ifp->profile != '\0') { 434 if (efprintf(fp, "profile=%s", ifp->profile) == -1) 435 goto eexit; 436 } 437 if (ifp->wireless) { 438 char pssid[IF_SSIDLEN * 4]; 439 440 if (print_string(pssid, sizeof(pssid), OT_ESCSTRING, 441 ifp->ssid, ifp->ssid_len) != -1) 442 { 443 if (efprintf(fp, "ifssid=%s", pssid) == -1) 444 goto eexit; 445 } 446 } 447 #ifdef INET 448 if (protocol == PROTO_DHCP && state && state->old) { 449 if (dhcp_env(fp, "old", ifp, 450 state->old, state->old_len) == -1) 451 goto eexit; 452 if (append_config(fp, "old", 453 (const char *const *)ifo->config) == -1) 454 goto eexit; 455 } 456 #endif 457 #ifdef DHCP6 458 if (protocol == PROTO_DHCP6 && d6_state && d6_state->old) { 459 if (dhcp6_env(fp, "old", ifp, 460 d6_state->old, d6_state->old_len) == -1) 461 goto eexit; 462 } 463 #endif 464 465 dumplease: 466 #ifdef INET 467 #ifdef IPV4LL 468 if (protocol == PROTO_IPV4LL && istate) { 469 if (ipv4ll_env(fp, istate->down ? "old" : "new", ifp) == -1) 470 goto eexit; 471 } 472 #endif 473 if (protocol == PROTO_DHCP && state && state->new) { 474 if (dhcp_env(fp, "new", ifp, 475 state->new, state->new_len) == -1) 476 goto eexit; 477 if (append_config(fp, "new", 478 (const char *const *)ifo->config) == -1) 479 goto eexit; 480 } 481 #endif 482 #ifdef INET6 483 if (protocol == PROTO_STATIC6) { 484 if (ipv6_env(fp, "new", ifp) == -1) 485 goto eexit; 486 } 487 #ifdef DHCP6 488 if (protocol == PROTO_DHCP6 && D6_STATE_RUNNING(ifp)) { 489 if (dhcp6_env(fp, "new", ifp, 490 d6_state->new, d6_state->new_len) == -1) 491 goto eexit; 492 } 493 #endif 494 if (protocol == PROTO_RA) { 495 if (ipv6nd_env(fp, ifp) == -1) 496 goto eexit; 497 } 498 #endif 499 500 /* Add our base environment */ 501 if (ifo->environ) { 502 for (i = 0; ifo->environ[i] != NULL; i++) 503 if (efprintf(fp, "%s", ifo->environ[i]) == -1) 504 goto eexit; 505 } 506 507 #ifdef PRIVSEP 508 make: 509 #endif 510 /* Convert buffer to argv */ 511 fflush(fp); 512 513 buf_pos = ftell(fp); 514 if (buf_pos == -1) { 515 logerr(__func__); 516 goto eexit; 517 } 518 519 #ifndef HAVE_OPEN_MEMSTREAM 520 size_t buf_len = (size_t)buf_pos; 521 if (ctx->script_buflen < buf_len) { 522 char *buf = realloc(ctx->script_buf, buf_len); 523 if (buf == NULL) 524 goto eexit; 525 ctx->script_buf = buf; 526 ctx->script_buflen = buf_len; 527 } 528 rewind(fp); 529 if (fread(ctx->script_buf, sizeof(char), buf_len, fp) != buf_len) 530 goto eexit; 531 fclose(fp); 532 fp = NULL; 533 #endif 534 535 if (script_buftoenv(ctx, ctx->script_buf, (size_t)buf_pos) == NULL) 536 goto eexit; 537 538 return buf_pos; 539 540 eexit: 541 logerr(__func__); 542 #ifndef HAVE_OPEN_MEMSTREAM 543 if (fp != NULL) 544 fclose(fp); 545 #endif 546 return -1; 547 } 548 549 static int 550 send_interface1(struct fd_list *fd, const struct interface *ifp, 551 const char *reason) 552 { 553 struct dhcpcd_ctx *ctx = ifp->ctx; 554 long len; 555 556 len = make_env(ifp->ctx, ifp, reason); 557 if (len == -1) 558 return -1; 559 return control_queue(fd, ctx->script_buf, (size_t)len, 1); 560 } 561 562 int 563 send_interface(struct fd_list *fd, const struct interface *ifp, int af) 564 { 565 int retval = 0; 566 #ifdef INET 567 const struct dhcp_state *d; 568 #endif 569 #ifdef DHCP6 570 const struct dhcp6_state *d6; 571 #endif 572 573 #ifndef AF_LINK 574 #define AF_LINK AF_PACKET 575 #endif 576 577 if (af == AF_UNSPEC || af == AF_LINK) { 578 const char *reason; 579 580 switch (ifp->carrier) { 581 case LINK_UP: 582 reason = "CARRIER"; 583 break; 584 case LINK_DOWN: 585 case LINK_DOWN_IFFUP: 586 reason = "NOCARRIER"; 587 break; 588 default: 589 reason = "UNKNOWN"; 590 break; 591 } 592 if (fd != NULL) { 593 if (send_interface1(fd, ifp, reason) == -1) 594 retval = -1; 595 } else 596 retval++; 597 } 598 599 #ifdef INET 600 if (af == AF_UNSPEC || af == AF_INET) { 601 if (D_STATE_RUNNING(ifp)) { 602 d = D_CSTATE(ifp); 603 if (fd != NULL) { 604 if (send_interface1(fd, ifp, d->reason) == -1) 605 retval = -1; 606 } else 607 retval++; 608 } 609 #ifdef IPV4LL 610 if (IPV4LL_STATE_RUNNING(ifp)) { 611 if (fd != NULL) { 612 if (send_interface1(fd, ifp, "IPV4LL") == -1) 613 retval = -1; 614 } else 615 retval++; 616 } 617 #endif 618 } 619 #endif 620 621 #ifdef INET6 622 if (af == AF_UNSPEC || af == AF_INET6) { 623 if (IPV6_STATE_RUNNING(ifp)) { 624 if (fd != NULL) { 625 if (send_interface1(fd, ifp, "STATIC6") == -1) 626 retval = -1; 627 } else 628 retval++; 629 } 630 if (RS_STATE_RUNNING(ifp)) { 631 if (fd != NULL) { 632 if (send_interface1(fd, ifp, 633 "ROUTERADVERT") == -1) 634 retval = -1; 635 } else 636 retval++; 637 } 638 #ifdef DHCP6 639 if (D6_STATE_RUNNING(ifp)) { 640 d6 = D6_CSTATE(ifp); 641 if (fd != NULL) { 642 if (send_interface1(fd, ifp, d6->reason) == -1) 643 retval = -1; 644 } else 645 retval++; 646 } 647 #endif 648 } 649 #endif 650 651 return retval; 652 } 653 654 static int 655 script_run(struct dhcpcd_ctx *ctx, char **argv) 656 { 657 pid_t pid; 658 int status = 0; 659 660 pid = script_exec(argv, ctx->script_env); 661 if (pid == -1) 662 logerr("%s: %s", __func__, argv[0]); 663 else if (pid != 0) { 664 /* Wait for the script to finish */ 665 while (waitpid(pid, &status, 0) == -1) { 666 if (errno != EINTR) { 667 logerr("%s: waitpid", __func__); 668 status = 0; 669 break; 670 } 671 } 672 if (WIFEXITED(status)) { 673 if (WEXITSTATUS(status)) 674 logerrx("%s: %s: WEXITSTATUS %d", 675 __func__, argv[0], WEXITSTATUS(status)); 676 } else if (WIFSIGNALED(status)) 677 logerrx("%s: %s: %s", 678 __func__, argv[0], strsignal(WTERMSIG(status))); 679 } 680 681 return WEXITSTATUS(status); 682 } 683 684 int 685 script_runreason(const struct interface *ifp, const char *reason) 686 { 687 struct dhcpcd_ctx *ctx = ifp->ctx; 688 char *argv[2]; 689 int status = 0; 690 struct fd_list *fd; 691 692 if (ifp->options->script == NULL && 693 TAILQ_FIRST(&ifp->ctx->control_fds) == NULL) 694 return 0; 695 696 /* Make our env */ 697 if (make_env(ifp->ctx, ifp, reason) == -1) { 698 logerr(__func__); 699 return -1; 700 } 701 702 if (ifp->options->script == NULL) 703 goto send_listeners; 704 705 argv[0] = ifp->options->script; 706 argv[1] = NULL; 707 logdebugx("%s: executing `%s' %s", ifp->name, argv[0], reason); 708 709 #ifdef PRIVSEP 710 if (ctx->options & DHCPCD_PRIVSEP) { 711 if (ps_root_script(ifp, 712 ctx->script_buf, ctx->script_buflen) == -1) 713 logerr(__func__); 714 goto send_listeners; 715 } 716 #endif 717 718 status = script_run(ctx, argv); 719 720 send_listeners: 721 /* Send to our listeners */ 722 status = 0; 723 TAILQ_FOREACH(fd, &ctx->control_fds, next) { 724 if (!(fd->flags & FD_LISTEN)) 725 continue; 726 if (control_queue(fd, ctx->script_buf, ctx->script_buflen, 727 true) == -1) 728 logerr("%s: control_queue", __func__); 729 else 730 status = 1; 731 } 732 733 return status; 734 } 735 736 #ifdef PRIVSEP 737 int 738 script_runchroot(struct dhcpcd_ctx *ctx, char *script) 739 { 740 char *argv[2]; 741 742 /* Make our env */ 743 if (make_env(ctx, NULL, "CHROOT") == -1) { 744 logerr(__func__); 745 return -1; 746 } 747 748 argv[0] = script; 749 argv[1] = NULL; 750 logdebugx("executing `%s' %s", argv[0], "CHROOT"); 751 752 return script_run(ctx, argv); 753 } 754 #endif 755