src/activate/activate.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Zbigniew Jędrzejewski-Szmek
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <sys/epoll.h>
  25 #include <sys/prctl.h>
  26 #include <sys/socket.h>
  27 #include <sys/wait.h>
  28 #include <getopt.h>
  29
  30 #include <systemd/sd-daemon.h>
  31
  32 #include "socket-util.h"
  33 #include "build.h"
  34 #include "log.h"
  35 #include "strv.h"
  36 #include "macro.h"
  37
  38 static char** arg_listen = NULL;
  39 static bool arg_accept = false;
  40 static char** arg_args = NULL;
  41 static char** arg_setenv = NULL;
  42
  43 static int add_epoll(int epoll_fd, int fd) {
  44         struct epoll_event ev = {
  45                 .events = EPOLLIN
  46         };
  47         int r;
  48
  49         assert(epoll_fd >= 0);
  50         assert(fd >= 0);
  51
  52         ev.data.fd = fd;
  53         r = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);
  54         if (r < 0) {
  55                 log_error("Failed to add event on epoll fd:%d for fd:%d: %m", epoll_fd, fd);
  56                 return -errno;
  57         }
  58
  59         return 0;
  60 }
  61
  62 static int make_socket_fd(const char* address, int flags) {
  63         SocketAddress a;
  64         int fd, r;
  65
  66         r = socket_address_parse(&a, address);
  67         if (r < 0) {
  68                 log_error("Failed to parse socket: %s", strerror(-r));
  69                 return r;
  70         }
  71
  72         fd = socket_address_listen(&a, flags, SOMAXCONN, SOCKET_ADDRESS_DEFAULT, NULL, false, false, 0755, 0644, NULL);
  73         if (fd < 0) {
  74                 log_error("Failed to listen: %s", strerror(-r));
  75                 return fd;
  76         }
  77
  78         return fd;
  79 }
  80
  81 static int open_sockets(int *epoll_fd, bool accept) {
  82         char **address;
  83         int n, fd, r;
  84         int count = 0;
  85
  86         n = sd_listen_fds(true);
  87         if (n < 0) {
  88                 log_error("Failed to read listening file descriptors from environment: %s",
  89                           strerror(-n));
  90                 return n;
  91         }
  92         if (n > 0) {
  93                 log_info("Received %i descriptors via the environment.", n);
  94
  95                 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
  96                         r = fd_cloexec(fd, arg_accept);
  97                         if (r < 0)
  98                                 return r;
  99
 100                         count ++;
 101                 }
 102         }
 103
 104         /* Close logging and all other descriptors */
 105         if (arg_listen) {
 106                 int except[3 + n];
 107
 108                 for (fd = 0; fd < SD_LISTEN_FDS_START + n; fd++)
 109                         except[fd] = fd;
 110
 111                 log_close();
 112                 close_all_fds(except, 3 + n);
 113         }
 114
 115         /** Note: we leak some fd's on error here. I doesn't matter
 116          *  much, since the program will exit immediately anyway, but
 117          *  would be a pain to fix.
 118          */
 119
 120         STRV_FOREACH(address, arg_listen) {
 121
 122                 fd = make_socket_fd(*address, SOCK_STREAM | (arg_accept*SOCK_CLOEXEC));
 123                 if (fd < 0) {
 124                         log_open();
 125                         log_error("Failed to open '%s': %s", *address, strerror(-fd));
 126                         return fd;
 127                 }
 128
 129                 assert(fd == SD_LISTEN_FDS_START + count);
 130                 count ++;
 131         }
 132
 133         if (arg_listen)
 134                 log_open();
 135
 136         *epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 137         if (*epoll_fd < 0) {
 138                 log_error("Failed to create epoll object: %m");
 139                 return -errno;
 140         }
 141
 142         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + count; fd++) {
 143                 _cleanup_free_ char *name = NULL;
 144
 145                 getsockname_pretty(fd, &name);
 146                 log_info("Listening on %s as %i.", strna(name), fd);
 147
 148                 r = add_epoll(*epoll_fd, fd);
 149                 if (r < 0)
 150                         return r;
 151         }
 152
 153         return count;
 154 }
 155
 156 static int launch(char* name, char **argv, char **env, int fds) {
 157
 158         static const char* tocopy[] = {"TERM=", "PATH=", "USER=", "HOME="};
 159         _cleanup_strv_free_ char **envp = NULL;
 160         _cleanup_free_ char *tmp = NULL;
 161         unsigned n_env = 0, length;
 162         char **s;
 163         unsigned i;
 164
 165         length = strv_length(arg_setenv);
 166
 167         /* PATH, TERM, HOME, USER, LISTEN_FDS, LISTEN_PID, NULL */
 168         envp = new0(char *, length + 7);
 169         if (!envp)
 170                 return log_oom();
 171
 172         STRV_FOREACH(s, arg_setenv) {
 173                 if (strchr(*s, '='))
 174                         envp[n_env++] = *s;
 175                 else {
 176                         _cleanup_free_ char *p = strappend(*s, "=");
 177                         if (!p)
 178                                 return log_oom();
 179                         envp[n_env] = strv_find_prefix(env, p);
 180                         if (envp[n_env])
 181                                 n_env ++;
 182                 }
 183         }
 184
 185         for (i = 0; i < ELEMENTSOF(tocopy); i++) {
 186                 envp[n_env] = strv_find_prefix(env, tocopy[i]);
 187                 if (envp[n_env])
 188                         n_env ++;
 189         }
 190
 191         if ((asprintf((char**)(envp + n_env++), "LISTEN_FDS=%d", fds) < 0) ||
 192             (asprintf((char**)(envp + n_env++), "LISTEN_PID=%d", getpid()) < 0))
 193                 return log_oom();
 194
 195         tmp = strv_join(argv, " ");
 196         if (!tmp)
 197                 return log_oom();
 198
 199         log_info("Execing %s (%s)", name, tmp);
 200         execvpe(name, argv, envp);
 201         log_error("Failed to execp %s (%s): %m", name, tmp);
 202
 203         return -errno;
 204 }
 205
 206 static int launch1(const char* child, char** argv, char **env, int fd) {
 207         _cleanup_free_ char *tmp = NULL;
 208         pid_t parent_pid, child_pid;
 209         int r;
 210
 211         tmp = strv_join(argv, " ");
 212         if (!tmp)
 213                 return log_oom();
 214
 215         parent_pid = getpid();
 216
 217         child_pid = fork();
 218         if (child_pid < 0) {
 219                 log_error("Failed to fork: %m");
 220                 return -errno;
 221         }
 222
 223         /* In the child */
 224         if (child_pid == 0) {
 225                 r = dup2(fd, STDIN_FILENO);
 226                 if (r < 0) {
 227                         log_error("Failed to dup connection to stdin: %m");
 228                         _exit(EXIT_FAILURE);
 229                 }
 230
 231                 r = dup2(fd, STDOUT_FILENO);
 232                 if (r < 0) {
 233                         log_error("Failed to dup connection to stdout: %m");
 234                         _exit(EXIT_FAILURE);
 235                 }
 236
 237                 r = close(fd);
 238                 if (r < 0) {
 239                         log_error("Failed to close dupped connection: %m");
 240                         _exit(EXIT_FAILURE);
 241                 }
 242
 243                 /* Make sure the child goes away when the parent dies */
 244                 if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
 245                         _exit(EXIT_FAILURE);
 246
 247                 /* Check whether our parent died before we were able
 248                  * to set the death signal */
 249                 if (getppid() != parent_pid)
 250                         _exit(EXIT_SUCCESS);
 251
 252                 execvp(child, argv);
 253                 log_error("Failed to exec child %s: %m", child);
 254                 _exit(EXIT_FAILURE);
 255         }
 256
 257         log_info("Spawned %s (%s) as PID %d", child, tmp, child_pid);
 258
 259         return 0;
 260 }
 261
 262 static int do_accept(const char* name, char **argv, char **envp, int fd) {
 263         _cleanup_free_ char *local = NULL, *peer = NULL;
 264         int fd2;
 265
 266         fd2 = accept(fd, NULL, NULL);
 267         if (fd2 < 0) {
 268                 log_error("Failed to accept connection on fd:%d: %m", fd);
 269                 return fd2;
 270         }
 271
 272         getsockname_pretty(fd2, &local);
 273         getpeername_pretty(fd2, &peer);
 274         log_info("Connection from %s to %s", strna(peer), strna(local));
 275
 276         return launch1(name, argv, envp, fd2);
 277 }
 278
 279 /* SIGCHLD handler. */
 280 static void sigchld_hdl(int sig, siginfo_t *t, void *data) {
 281         PROTECT_ERRNO;
 282
 283         log_info("Child %d died with code %d", t->si_pid, t->si_status);
 284         /* Wait for a dead child. */
 285         waitpid(t->si_pid, NULL, 0);
 286 }
 287
 288 static int install_chld_handler(void) {
 289         int r;
 290         struct sigaction act = {
 291                 .sa_flags = SA_SIGINFO,
 292                 .sa_sigaction = sigchld_hdl,
 293         };
 294
 295         r = sigaction(SIGCHLD, &act, 0);
 296         if (r < 0)
 297                 log_error("Failed to install SIGCHLD handler: %m");
 298         return r;
 299 }
 300
 301 static int help(void) {
 302         printf("%s [OPTIONS...]\n\n"
 303                "Listen on sockets and launch child on connection.\n\n"
 304                "Options:\n"
 305                "  -l --listen=ADDR         Listen for raw connections at ADDR\n"
 306                "  -a --accept              Spawn separate child for each connection\n"
 307                "  -h --help                Show this help and exit\n"
 308                "  -E --setenv=NAME[=VALUE] Pass an environment variable to children\n"
 309                "  --version                Print version string and exit\n"
 310                "\n"
 311                "Note: file descriptors from sd_listen_fds() will be passed through.\n"
 312                , program_invocation_short_name
 313                );
 314
 315         return 0;
 316 }
 317
 318 static int parse_argv(int argc, char *argv[]) {
 319         enum {
 320                 ARG_VERSION = 0x100,
 321         };
 322
 323         static const struct option options[] = {
 324                 { "help",        no_argument,       NULL, 'h'           },
 325                 { "version",     no_argument,       NULL, ARG_VERSION   },
 326                 { "listen",      required_argument, NULL, 'l'           },
 327                 { "accept",      no_argument,       NULL, 'a'           },
 328                 { "setenv",      required_argument, NULL, 'E'           },
 329                 { "environment", required_argument, NULL, 'E'           }, /* alias */
 330                 {}
 331         };
 332
 333         int c;
 334
 335         assert(argc >= 0);
 336         assert(argv);
 337
 338         while ((c = getopt_long(argc, argv, "+hl:aE:", options, NULL)) >= 0)
 339                 switch(c) {
 340                 case 'h':
 341                         return help();
 342
 343                 case ARG_VERSION:
 344                         puts(PACKAGE_STRING);
 345                         puts(SYSTEMD_FEATURES);
 346                         return 0 /* done */;
 347
 348                 case 'l': {
 349                         int r = strv_extend(&arg_listen, optarg);
 350                         if (r < 0)
 351                                 return r;
 352
 353                         break;
 354                 }
 355
 356                 case 'a':
 357                         arg_accept = true;
 358                         break;
 359
 360                 case 'E': {
 361                         int r = strv_extend(&arg_setenv, optarg);
 362                         if (r < 0)
 363                                 return r;
 364
 365                         break;
 366                 }
 367
 368                 case '?':
 369                         return -EINVAL;
 370
 371                 default:
 372                         assert_not_reached("Unhandled option");
 373                 }
 374
 375         if (optind == argc) {
 376                 log_error("Usage: %s [OPTION...] PROGRAM [OPTION...]",
 377                           program_invocation_short_name);
 378                 return -EINVAL;
 379         }
 380
 381         arg_args = argv + optind;
 382
 383         return 1 /* work to do */;
 384 }
 385
 386 int main(int argc, char **argv, char **envp) {
 387         int r, n;
 388         int epoll_fd = -1;
 389
 390         log_parse_environment();
 391         log_open();
 392
 393         r = parse_argv(argc, argv);
 394         if (r <= 0)
 395                 return r == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 396
 397         r = install_chld_handler();
 398         if (r < 0)
 399                 return EXIT_FAILURE;
 400
 401         n = open_sockets(&epoll_fd, arg_accept);
 402         if (n < 0)
 403                 return EXIT_FAILURE;
 404         if (n == 0) {
 405                 log_error("No sockets to listen on specified or passed in.");
 406                 return EXIT_FAILURE;
 407         }
 408
 409         for (;;) {
 410                 struct epoll_event event;
 411
 412                 r = epoll_wait(epoll_fd, &event, 1, -1);
 413                 if (r < 0) {
 414                         if (errno == EINTR)
 415                                 continue;
 416
 417                         log_error("epoll_wait() failed: %m");
 418                         return EXIT_FAILURE;
 419                 }
 420
 421                 log_info("Communication attempt on fd %i.", event.data.fd);
 422                 if (arg_accept) {
 423                         r = do_accept(argv[optind], argv + optind, envp,
 424                                       event.data.fd);
 425                         if (r < 0)
 426                                 return EXIT_FAILURE;
 427                 } else
 428                         break;
 429         }
 430
 431         launch(argv[optind], argv + optind, envp, n);
 432
 433         return EXIT_SUCCESS;
 434 }