#include <unistd.h>

#include <fcntl.h>

#include <sys/epoll.h>

#include <sys/prctl.h>

#include <sys/socket.h>

#include <sys/wait.h>

#include <getopt.h>

#include <systemd/sd-daemon.h>

#include "socket-util.h"

#include "build.h"

#include "log.h"

#include "strv.h"

#include "macro.h"

static char** arg_listen = NULL;

static bool arg_accept = false;

static char** arg_args = NULL;

static char** arg_environ = NULL;

static int add_epoll(int epoll_fd, int fd) {

int r;

struct epoll_event ev = {EPOLLIN};

ev.data.fd = fd;

assert(epoll_fd >= 0);

assert(fd >= 0);

r = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev);

if (r < 0)

log_error("Failed to add event on epoll fd:%d for fd:%d: %s",

epoll_fd, fd, strerror(-r));

return r;

}

static int print_socket(const char* desc, int fd) {

int r;

SocketAddress addr = {

.size = sizeof(union sockaddr_union),

.type = SOCK_STREAM,

};

int family;

r = getsockname(fd, &addr.sockaddr.sa, &addr.size);

if (r < 0) {

log_warning("Failed to query socket on fd:%d: %m", fd);

return 0;

}

family = socket_address_family(&addr);

switch(family) {

case AF_INET:

case AF_INET6: {

char* _cleanup_free_ a = NULL;

r = socket_address_print(&addr, &a);

if (r < 0)

log_warning("socket_address_print(): %s", strerror(-r));

else

log_info("%s %s address %s",

desc,

family == AF_INET ? "IP" : "IPv6",

a);

break;

}

default:

log_warning("Connection with unknown family %d", family);

}

return 0;

}

static int make_socket_fd(const char* address, int flags) {

_cleanup_free_ char *p = NULL;

SocketAddress a;

int fd, r;

r = socket_address_parse(&a, address);

if (r < 0) {

log_error("Failed to parse socket: %s", strerror(-r));

return r;

}

fd = socket_address_listen(&a, flags, SOMAXCONN, SOCKET_ADDRESS_DEFAULT, NULL, false, false, 0755, 0644, NULL);

if (fd < 0) {

log_error("Failed to listen: %s", strerror(-r));

return fd;

}

r = socket_address_print(&a, &p);

if (r < 0) {

log_error("socket_address_print(): %s", strerror(-r));

close_nointr_nofail(fd);

return r;

}

log_info("Listening on %s", p);

return fd;

}

static int open_sockets(int *epoll_fd, bool accept) {

int n, fd, r;

int count = 0;

char **address;

n = sd_listen_fds(true);

if (n < 0) {

log_error("Failed to read listening file descriptors from environment: %s",

strerror(-n));

return n;

}

log_info("Received %d descriptors", n);

for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {

log_debug("Received descriptor fd:%d", fd);

print_socket("Listening on", fd);

r = fd_cloexec(fd, arg_accept);

if (r < 0)

return r;

count ++;

}

/** Note: we leak some fd's on error here. I doesn't matter

STRV_FOREACH(address, arg_listen) {

log_info("Opening address %s", *address);

fd = make_socket_fd(*address, SOCK_STREAM | (arg_accept*SOCK_CLOEXEC));

if (fd < 0) {

log_error("Failed to open '%s': %s", *address, strerror(-fd));

return fd;

}

assert(fd == SD_LISTEN_FDS_START + count);

count ++;

}

*epoll_fd = epoll_create1(EPOLL_CLOEXEC);

if (*epoll_fd < 0) {

log_error("Failed to create epoll object: %m");

return -errno;

}

for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + count; fd++) {

r = add_epoll(*epoll_fd, fd);

if (r < 0)

return r;

}

return count;

}

static int launch(char* name, char **argv, char **env, int fds) {

unsigned n_env = 0, length;

_cleanup_strv_free_ char **envp = NULL;

char **s;

static const char* tocopy[] = {"TERM=", "PATH=", "USER=", "HOME="};

_cleanup_free_ char *tmp = NULL;

unsigned i;

length = strv_length(arg_environ);

/* PATH, TERM, HOME, USER, LISTEN_FDS, LISTEN_PID, NULL */

envp = new(char *, length + 7);

STRV_FOREACH(s, arg_environ) {

if (strchr(*s, '='))

envp[n_env++] = *s;

else {

_cleanup_free_ char *p = strappend(*s, "=");

if (!p)

return log_oom();

envp[n_env] = strv_find_prefix(env, p);

if (envp[n_env])

n_env ++;

}

}

for (i = 0; i < ELEMENTSOF(tocopy); i++) {

envp[n_env] = strv_find_prefix(env, tocopy[i]);

if (envp[n_env])

n_env ++;

}

if ((asprintf((char**)(envp + n_env++), "LISTEN_FDS=%d", fds) < 0) ||

(asprintf((char**)(envp + n_env++), "LISTEN_PID=%d", getpid()) < 0))

return log_oom();

tmp = strv_join(argv, " ");

if (!tmp)

return log_oom();

log_info("Execing %s (%s)", name, tmp);

execvpe(name, argv, envp);

log_error("Failed to execp %s (%s): %m", name, tmp);

return -errno;

}

static int launch1(const char* child, char** argv, char **env, int fd) {

pid_t parent_pid, child_pid;

int r;

_cleanup_free_ char *tmp = NULL;

tmp = strv_join(argv, " ");

if (!tmp)

return log_oom();

parent_pid = getpid();

child_pid = fork();

if (child_pid < 0) {

log_error("Failed to fork: %m");

return -errno;

}

/* In the child */

if (child_pid == 0) {

r = dup2(fd, STDIN_FILENO);

if (r < 0) {

log_error("Failed to dup connection to stdin: %m");

_exit(EXIT_FAILURE);

}

r = dup2(fd, STDOUT_FILENO);

if (r < 0) {

log_error("Failed to dup connection to stdout: %m");

_exit(EXIT_FAILURE);

}

r = close(fd);

if (r < 0) {

log_error("Failed to close dupped connection: %m");

_exit(EXIT_FAILURE);

}

/* Make sure the child goes away when the parent dies */

if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)

_exit(EXIT_FAILURE);

/* Check whether our parent died before we were able

if (getppid() != parent_pid)

_exit(EXIT_SUCCESS);

execvp(child, argv);

log_error("Failed to exec child %s: %m", child);

_exit(EXIT_FAILURE);

}

log_info("Spawned %s (%s) as PID %d", child, tmp, child_pid);

return 0;

}

static int do_accept(const char* name, char **argv, char **envp, int fd) {

SocketAddress addr = {

.size = sizeof(union sockaddr_union),

.type = SOCK_STREAM,

};

int fd2, r;

fd2 = accept(fd, &addr.sockaddr.sa, &addr.size);

if (fd2 < 0) {

log_error("Failed to accept connection on fd:%d: %m", fd);

return fd2;

}

print_socket("Connection from", fd2);

r = launch1(name, argv, envp, fd2);

return r;

}

static void sigchld_hdl(int sig, siginfo_t *t, void *data) {

log_info("Child %d died with code %d", t->si_pid, t->si_status);

/* Wait for a dead child. */

waitpid(t->si_pid, NULL, 0);

}

static int install_chld_handler(void) {

int r;

struct sigaction act;

zero(act);

act.sa_flags = SA_SIGINFO;

act.sa_sigaction = sigchld_hdl;

r = sigaction(SIGCHLD, &act, 0);

if (r < 0)

log_error("Failed to install SIGCHLD handler: %m");

return r;

}

static int help(void) {

printf("%s [OPTIONS...]\n\n"

"Listen on sockets and launch child on connection.\n\n"

"Options:\n"

" -l --listen=ADDR Listen for raw connections at ADDR\n"

" -a --accept Spawn separate child for each connection\n"

" -h --help Show this help and exit\n"

" --version Print version string and exit\n"

"\n"

"Note: file descriptors from sd_listen_fds() will be passed through.\n"

, program_invocation_short_name

);

return 0;

}

static int parse_argv(int argc, char *argv[]) {

enum {

ARG_VERSION = 0x100,

};

static const struct option options[] = {

{ "help", no_argument, NULL, 'h' },

{ "version", no_argument, NULL, ARG_VERSION },

{ "listen", required_argument, NULL, 'l' },

{ "accept", no_argument, NULL, 'a' },

{ "environment", required_argument, NULL, 'E' },

{}

};

int c;

assert(argc >= 0);

assert(argv);

while ((c = getopt_long(argc, argv, "+hl:saE:", options, NULL)) >= 0)

switch(c) {

case 'h':

return help();

case ARG_VERSION:

puts(PACKAGE_STRING);

puts(SYSTEMD_FEATURES);

return 0 /* done */;

case 'l': {

int r = strv_extend(&arg_listen, optarg);

if (r < 0)

return r;

break;

}

case 'a':

arg_accept = true;

break;

case 'E': {

int r = strv_extend(&arg_environ, optarg);

if (r < 0)

return r;

break;

}

case '?':

return -EINVAL;

default:

assert_not_reached("Unhandled option");

}

if (optind == argc) {

log_error("Usage: %s [OPTION...] PROGRAM [OPTION...]",

program_invocation_short_name);

return -EINVAL;

}

arg_args = argv + optind;

return 1 /* work to do */;

}

int main(int argc, char **argv, char **envp) {

int r, n;

int epoll_fd = -1;

log_parse_environment();

log_open();

r = parse_argv(argc, argv);

if (r <= 0)

return r == 0 ? EXIT_SUCCESS : EXIT_FAILURE;

r = install_chld_handler();

if (r < 0)

return EXIT_FAILURE;

n = open_sockets(&epoll_fd, arg_accept);

if (n < 0)

return EXIT_FAILURE;

for (;;) {

struct epoll_event event;

r = epoll_wait(epoll_fd, &event, 1, -1);

if (r < 0) {

if (errno == EINTR)

continue;

log_error("epoll_wait() failed: %m");

return EXIT_FAILURE;

}

log_info("Communication attempt on fd:%d", event.data.fd);

if (arg_accept) {

r = do_accept(argv[optind], argv + optind, envp,

event.data.fd);

if (r < 0)

return EXIT_FAILURE;

} else

break;

}

launch(argv[optind], argv + optind, envp, n);

return EXIT_SUCCESS;

}