contrib/dhcpcd/src/script.c

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