src/activate/activate.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <getopt.h>
   4 #include <sys/epoll.h>
   5 #include <sys/prctl.h>
   6 #include <sys/socket.h>
   7 #include <sys/wait.h>
   8 #include <unistd.h>
   9
  10 #include "sd-daemon.h"
  11
  12 #include "alloc-util.h"
  13 #include "escape.h"
  14 #include "fd-util.h"
  15 #include "log.h"
  16 #include "macro.h"
  17 #include "pretty-print.h"
  18 #include "process-util.h"
  19 #include "signal-util.h"
  20 #include "socket-util.h"
  21 #include "string-util.h"
  22 #include "strv.h"
  23 #include "terminal-util.h"
  24
  25 static char** arg_listen = NULL;
  26 static bool arg_accept = false;
  27 static int arg_socket_type = SOCK_STREAM;
  28 static char** arg_args = NULL;
  29 static char** arg_setenv = NULL;
  30 static char **arg_fdnames = NULL;
  31 static bool arg_inetd = false;
  32
  33 static int add_epoll(int epoll_fd, int fd) {
  34         struct epoll_event ev = {
  35                 .events = EPOLLIN,
  36                 .data.fd = fd,
  37         };
  38
  39         assert(epoll_fd >= 0);
  40         assert(fd >= 0);
  41
  42         if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
  43                 return log_error_errno(errno, "Failed to add event on epoll fd:%d for fd:%d: %m", epoll_fd, fd);
  44
  45         return 0;
  46 }
  47
  48 static int open_sockets(int *epoll_fd, bool accept) {
  49         char **address;
  50         int n, fd, r;
  51         int count = 0;
  52
  53         n = sd_listen_fds(true);
  54         if (n < 0)
  55                 return log_error_errno(n, "Failed to read listening file descriptors from environment: %m");
  56         if (n > 0) {
  57                 log_info("Received %i descriptors via the environment.", n);
  58
  59                 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
  60                         r = fd_cloexec(fd, arg_accept);
  61                         if (r < 0)
  62                                 return r;
  63
  64                         count++;
  65                 }
  66         }
  67
  68         /* Close logging and all other descriptors */
  69         if (arg_listen) {
  70                 int except[3 + n];
  71
  72                 for (fd = 0; fd < SD_LISTEN_FDS_START + n; fd++)
  73                         except[fd] = fd;
  74
  75                 log_close();
  76                 close_all_fds(except, 3 + n);
  77         }
  78
  79         /** Note: we leak some fd's on error here. I doesn't matter
  80          *  much, since the program will exit immediately anyway, but
  81          *  would be a pain to fix.
  82          */
  83
  84         STRV_FOREACH(address, arg_listen) {
  85                 fd = make_socket_fd(LOG_DEBUG, *address, arg_socket_type, (arg_accept*SOCK_CLOEXEC));
  86                 if (fd < 0) {
  87                         log_open();
  88                         return log_error_errno(fd, "Failed to open '%s': %m", *address);
  89                 }
  90
  91                 assert(fd == SD_LISTEN_FDS_START + count);
  92                 count++;
  93         }
  94
  95         if (arg_listen)
  96                 log_open();
  97
  98         *epoll_fd = epoll_create1(EPOLL_CLOEXEC);
  99         if (*epoll_fd < 0)
 100                 return log_error_errno(errno, "Failed to create epoll object: %m");
 101
 102         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + count; fd++) {
 103                 _cleanup_free_ char *name = NULL;
 104
 105                 getsockname_pretty(fd, &name);
 106                 log_info("Listening on %s as %i.", strna(name), fd);
 107
 108                 r = add_epoll(*epoll_fd, fd);
 109                 if (r < 0)
 110                         return r;
 111         }
 112
 113         return count;
 114 }
 115
 116 static int exec_process(const char* name, char **argv, char **env, int start_fd, size_t n_fds) {
 117
 118         _cleanup_strv_free_ char **envp = NULL;
 119         _cleanup_free_ char *joined = NULL;
 120         size_t n_env = 0, length;
 121         const char *tocopy;
 122         char **s;
 123         int r;
 124
 125         if (arg_inetd && n_fds != 1)
 126                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 127                                        "--inetd only supported for single file descriptors.");
 128
 129         length = strv_length(arg_setenv);
 130
 131         /* PATH, TERM, HOME, USER, LISTEN_FDS, LISTEN_PID, LISTEN_FDNAMES, NULL */
 132         envp = new0(char *, length + 8);
 133         if (!envp)
 134                 return log_oom();
 135
 136         STRV_FOREACH(s, arg_setenv) {
 137
 138                 if (strchr(*s, '=')) {
 139                         char *k;
 140
 141                         k = strdup(*s);
 142                         if (!k)
 143                                 return log_oom();
 144
 145                         envp[n_env++] = k;
 146                 } else {
 147                         _cleanup_free_ char *p;
 148                         const char *n;
 149
 150                         p = strappend(*s, "=");
 151                         if (!p)
 152                                 return log_oom();
 153
 154                         n = strv_find_prefix(env, p);
 155                         if (!n)
 156                                 continue;
 157
 158                         envp[n_env] = strdup(n);
 159                         if (!envp[n_env])
 160                                 return log_oom();
 161
 162                         n_env++;
 163                 }
 164         }
 165
 166         FOREACH_STRING(tocopy, "TERM=", "PATH=", "USER=", "HOME=") {
 167                 const char *n;
 168
 169                 n = strv_find_prefix(env, tocopy);
 170                 if (!n)
 171                         continue;
 172
 173                 envp[n_env] = strdup(n);
 174                 if (!envp[n_env])
 175                         return log_oom();
 176
 177                 n_env++;
 178         }
 179
 180         if (arg_inetd) {
 181                 assert(n_fds == 1);
 182
 183                 r = rearrange_stdio(start_fd, start_fd, STDERR_FILENO); /* invalidates start_fd on success + error */
 184                 if (r < 0)
 185                         return log_error_errno(r, "Failed to move fd to stdin+stdout: %m");
 186
 187         } else {
 188                 if (start_fd != SD_LISTEN_FDS_START) {
 189                         assert(n_fds == 1);
 190
 191                         if (dup2(start_fd, SD_LISTEN_FDS_START) < 0)
 192                                 return log_error_errno(errno, "Failed to dup connection: %m");
 193
 194                         safe_close(start_fd);
 195                         start_fd = SD_LISTEN_FDS_START;
 196                 }
 197
 198                 if (asprintf((char**)(envp + n_env++), "LISTEN_FDS=%zu", n_fds) < 0)
 199                         return log_oom();
 200
 201                 if (asprintf((char**)(envp + n_env++), "LISTEN_PID=" PID_FMT, getpid_cached()) < 0)
 202                         return log_oom();
 203
 204                 if (arg_fdnames) {
 205                         _cleanup_free_ char *names = NULL;
 206                         size_t len;
 207                         char *e;
 208
 209                         len = strv_length(arg_fdnames);
 210                         if (len == 1) {
 211                                 size_t i;
 212
 213                                 for (i = 1; i < n_fds; i++) {
 214                                         r = strv_extend(&arg_fdnames, arg_fdnames[0]);
 215                                         if (r < 0)
 216                                                 return log_error_errno(r, "Failed to extend strv: %m");
 217                                 }
 218                         } else if (len != n_fds)
 219                                 log_warning("The number of fd names is different than number of fds: %zu vs %zu", len, n_fds);
 220
 221                         names = strv_join(arg_fdnames, ":");
 222                         if (!names)
 223                                 return log_oom();
 224
 225                         e = strappend("LISTEN_FDNAMES=", names);
 226                         if (!e)
 227                                 return log_oom();
 228
 229                         envp[n_env++] = e;
 230                 }
 231         }
 232
 233         joined = strv_join(argv, " ");
 234         if (!joined)
 235                 return log_oom();
 236
 237         log_info("Execing %s (%s)", name, joined);
 238         execvpe(name, argv, envp);
 239
 240         return log_error_errno(errno, "Failed to execp %s (%s): %m", name, joined);
 241 }
 242
 243 static int fork_and_exec_process(const char* child, char** argv, char **env, int fd) {
 244         _cleanup_free_ char *joined = NULL;
 245         pid_t child_pid;
 246         int r;
 247
 248         joined = strv_join(argv, " ");
 249         if (!joined)
 250                 return log_oom();
 251
 252         r = safe_fork("(activate)", FORK_RESET_SIGNALS|FORK_DEATHSIG|FORK_RLIMIT_NOFILE_SAFE|FORK_LOG, &child_pid);
 253         if (r < 0)
 254                 return r;
 255         if (r == 0) {
 256                 /* In the child */
 257                 exec_process(child, argv, env, fd, 1);
 258                 _exit(EXIT_FAILURE);
 259         }
 260
 261         log_info("Spawned %s (%s) as PID " PID_FMT ".", child, joined, child_pid);
 262         return 0;
 263 }
 264
 265 static int do_accept(const char* name, char **argv, char **envp, int fd) {
 266         _cleanup_free_ char *local = NULL, *peer = NULL;
 267         _cleanup_close_ int fd_accepted = -1;
 268
 269         fd_accepted = accept4(fd, NULL, NULL, 0);
 270         if (fd_accepted < 0)
 271                 return log_error_errno(errno, "Failed to accept connection on fd:%d: %m", fd);
 272
 273         getsockname_pretty(fd_accepted, &local);
 274         getpeername_pretty(fd_accepted, true, &peer);
 275         log_info("Connection from %s to %s", strna(peer), strna(local));
 276
 277         return fork_and_exec_process(name, argv, envp, fd_accepted);
 278 }
 279
 280 /* SIGCHLD handler. */
 281 static void sigchld_hdl(int sig) {
 282         PROTECT_ERRNO;
 283
 284         for (;;) {
 285                 siginfo_t si;
 286                 int r;
 287
 288                 si.si_pid = 0;
 289                 r = waitid(P_ALL, 0, &si, WEXITED|WNOHANG);
 290                 if (r < 0) {
 291                         if (errno != ECHILD)
 292                                 log_error_errno(errno, "Failed to reap children: %m");
 293                         return;
 294                 }
 295                 if (si.si_pid == 0)
 296                         return;
 297
 298                 log_info("Child %d died with code %d", si.si_pid, si.si_status);
 299         }
 300 }
 301
 302 static int install_chld_handler(void) {
 303         static const struct sigaction act = {
 304                 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 305                 .sa_handler = sigchld_hdl,
 306         };
 307
 308         if (sigaction(SIGCHLD, &act, 0) < 0)
 309                 return log_error_errno(errno, "Failed to install SIGCHLD handler: %m");
 310
 311         return 0;
 312 }
 313
 314 static int help(void) {
 315         _cleanup_free_ char *link = NULL;
 316         int r;
 317
 318         r = terminal_urlify_man("systemd-socket-activate", "1", &link);
 319         if (r < 0)
 320                 return log_oom();
 321
 322         printf("%s [OPTIONS...]\n\n"
 323                "Listen on sockets and launch child on connection.\n\n"
 324                "Options:\n"
 325                "  -h --help                  Show this help and exit\n"
 326                "     --version               Print version string and exit\n"
 327                "  -l --listen=ADDR           Listen for raw connections at ADDR\n"
 328                "  -d --datagram              Listen on datagram instead of stream socket\n"
 329                "     --seqpacket             Listen on SOCK_SEQPACKET instead of stream socket\n"
 330                "  -a --accept                Spawn separate child for each connection\n"
 331                "  -E --setenv=NAME[=VALUE]   Pass an environment variable to children\n"
 332                "     --fdname=NAME[:NAME...] Specify names for file descriptors\n"
 333                "     --inetd                 Enable inetd file descriptor passing protocol\n"
 334                "\nNote: file descriptors from sd_listen_fds() will be passed through.\n"
 335                "\nSee the %s for details.\n"
 336                , program_invocation_short_name
 337                , link
 338         );
 339
 340         return 0;
 341 }
 342
 343 static int parse_argv(int argc, char *argv[]) {
 344         enum {
 345                 ARG_VERSION = 0x100,
 346                 ARG_FDNAME,
 347                 ARG_SEQPACKET,
 348                 ARG_INETD,
 349         };
 350
 351         static const struct option options[] = {
 352                 { "help",        no_argument,       NULL, 'h'           },
 353                 { "version",     no_argument,       NULL, ARG_VERSION   },
 354                 { "datagram",    no_argument,       NULL, 'd'           },
 355                 { "seqpacket",   no_argument,       NULL, ARG_SEQPACKET },
 356                 { "listen",      required_argument, NULL, 'l'           },
 357                 { "accept",      no_argument,       NULL, 'a'           },
 358                 { "setenv",      required_argument, NULL, 'E'           },
 359                 { "environment", required_argument, NULL, 'E'           }, /* legacy alias */
 360                 { "fdname",      required_argument, NULL, ARG_FDNAME    },
 361                 { "inetd",       no_argument,       NULL, ARG_INETD     },
 362                 {}
 363         };
 364
 365         int c, r;
 366
 367         assert(argc >= 0);
 368         assert(argv);
 369
 370         while ((c = getopt_long(argc, argv, "+hl:aE:d", options, NULL)) >= 0)
 371                 switch(c) {
 372                 case 'h':
 373                         return help();
 374
 375                 case ARG_VERSION:
 376                         return version();
 377
 378                 case 'l':
 379                         r = strv_extend(&arg_listen, optarg);
 380                         if (r < 0)
 381                                 return log_oom();
 382
 383                         break;
 384
 385                 case 'd':
 386                         if (arg_socket_type == SOCK_SEQPACKET)
 387                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 388                                                        "--datagram may not be combined with --seqpacket.");
 389
 390                         arg_socket_type = SOCK_DGRAM;
 391                         break;
 392
 393                 case ARG_SEQPACKET:
 394                         if (arg_socket_type == SOCK_DGRAM)
 395                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 396                                                        "--seqpacket may not be combined with --datagram.");
 397
 398                         arg_socket_type = SOCK_SEQPACKET;
 399                         break;
 400
 401                 case 'a':
 402                         arg_accept = true;
 403                         break;
 404
 405                 case 'E':
 406                         r = strv_extend(&arg_setenv, optarg);
 407                         if (r < 0)
 408                                 return log_oom();
 409
 410                         break;
 411
 412                 case ARG_FDNAME: {
 413                         _cleanup_strv_free_ char **names;
 414                         char **s;
 415
 416                         names = strv_split(optarg, ":");
 417                         if (!names)
 418                                 return log_oom();
 419
 420                         STRV_FOREACH(s, names)
 421                                 if (!fdname_is_valid(*s)) {
 422                                         _cleanup_free_ char *esc;
 423
 424                                         esc = cescape(*s);
 425                                         log_warning("File descriptor name \"%s\" is not valid.", esc);
 426                                 }
 427
 428                         /* Empty optargs means one empty name */
 429                         r = strv_extend_strv(&arg_fdnames,
 430                                              strv_isempty(names) ? STRV_MAKE("") : names,
 431                                              false);
 432                         if (r < 0)
 433                                 return log_error_errno(r, "strv_extend_strv: %m");
 434                         break;
 435                 }
 436
 437                 case ARG_INETD:
 438                         arg_inetd = true;
 439                         break;
 440
 441                 case '?':
 442                         return -EINVAL;
 443
 444                 default:
 445                         assert_not_reached("Unhandled option");
 446                 }
 447
 448         if (optind == argc)
 449                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 450                                        "%s: command to execute is missing.",
 451                                        program_invocation_short_name);
 452
 453         if (arg_socket_type == SOCK_DGRAM && arg_accept)
 454                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 455                                        "Datagram sockets do not accept connections. "
 456                                        "The --datagram and --accept options may not be combined.");
 457
 458         arg_args = argv + optind;
 459
 460         return 1 /* work to do */;
 461 }
 462
 463 int main(int argc, char **argv, char **envp) {
 464         int r, n;
 465         int epoll_fd = -1;
 466
 467         log_parse_environment();
 468         log_open();
 469
 470         r = parse_argv(argc, argv);
 471         if (r <= 0)
 472                 return r == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 473
 474         r = install_chld_handler();
 475         if (r < 0)
 476                 return EXIT_FAILURE;
 477
 478         n = open_sockets(&epoll_fd, arg_accept);
 479         if (n < 0)
 480                 return EXIT_FAILURE;
 481         if (n == 0) {
 482                 log_error("No sockets to listen on specified or passed in.");
 483                 return EXIT_FAILURE;
 484         }
 485
 486         for (;;) {
 487                 struct epoll_event event;
 488
 489                 if (epoll_wait(epoll_fd, &event, 1, -1) < 0) {
 490                         if (errno == EINTR)
 491                                 continue;
 492
 493                         log_error_errno(errno, "epoll_wait() failed: %m");
 494                         return EXIT_FAILURE;
 495                 }
 496
 497                 log_info("Communication attempt on fd %i.", event.data.fd);
 498                 if (arg_accept) {
 499                         r = do_accept(argv[optind], argv + optind, envp, event.data.fd);
 500                         if (r < 0)
 501                                 return EXIT_FAILURE;
 502                 } else
 503                         break;
 504         }
 505
 506         exec_process(argv[optind], argv + optind, envp, SD_LISTEN_FDS_START, (size_t) n);
 507
 508         return EXIT_SUCCESS;
 509 }