X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=socket.c;h=88fb2d3869e50231a4cfd4a2b6974c091e352688;hp=a1f3ef8af75eadb9a637638f88ce494c99a1b0b7;hb=8d567588cad053f79abe603ab113e1b85a92f1da;hpb=23a177ef7c8c38c238ef06666f900f581b48298f diff --git a/socket.c b/socket.c index a1f3ef8af..88fb2d386 100644 --- a/socket.c +++ b/socket.c @@ -26,12 +26,15 @@ #include #include #include +#include #include "unit.h" #include "socket.h" #include "log.h" #include "load-dropin.h" #include "load-fragment.h" +#include "strv.h" +#include "unit-name.h" static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = { [SOCKET_DEAD] = UNIT_INACTIVE, @@ -43,8 +46,8 @@ static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = { [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING, [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING, [SOCKET_STOP_POST] = UNIT_DEACTIVATING, - [SOCKET_STOP_POST_SIGTERM] = UNIT_DEACTIVATING, - [SOCKET_STOP_POST_SIGKILL] = UNIT_DEACTIVATING, + [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING, + [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING, [SOCKET_MAINTAINANCE] = UNIT_INACTIVE, }; @@ -58,11 +61,21 @@ static const char* const state_string_table[_SOCKET_STATE_MAX] = { [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm", [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill", [SOCKET_STOP_POST] = "stop-post", - [SOCKET_STOP_POST_SIGTERM] = "stop-post-sigterm", - [SOCKET_STOP_POST_SIGKILL] = "stop-post-sigkill", + [SOCKET_FINAL_SIGTERM] = "final-sigterm", + [SOCKET_FINAL_SIGKILL] = "final-sigkill", [SOCKET_MAINTAINANCE] = "maintainance" }; +static void socket_unwatch_control_pid(Socket *s) { + assert(s); + + if (s->control_pid <= 0) + return; + + unit_unwatch_pid(UNIT(s), s->control_pid); + s->control_pid = 0; +} + static void socket_done(Unit *u) { Socket *s = SOCKET(u); SocketPort *p; @@ -79,61 +92,83 @@ static void socket_done(Unit *u) { } exec_context_done(&s->exec_context); - exec_command_free_array(s->exec_command, _SOCKET_EXEC_MAX); + exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX); s->control_command = NULL; - if (s->control_pid > 0) { - unit_unwatch_pid(u, s->control_pid); - s->control_pid = 0; - } + socket_unwatch_control_pid(s); s->service = NULL; free(s->bind_to_device); + s->bind_to_device = NULL; unit_unwatch_timer(u, &s->timer_watch); } -static int socket_init(Unit *u, UnitLoadState *new_state) { +static void socket_init(Unit *u) { Socket *s = SOCKET(u); - char *t; - int r; - /* First, reset everything to the defaults, in case this is a - * reload */ + assert(u); + assert(u->meta.load_state == UNIT_STUB); - s->state = 0; s->timer_watch.type = WATCH_INVALID; - s->bind_ipv6_only = false; s->backlog = SOMAXCONN; s->timeout_usec = DEFAULT_TIMEOUT_USEC; s->directory_mode = 0755; s->socket_mode = 0666; + exec_context_init(&s->exec_context); +} - if ((r = unit_load_fragment(u, new_state)) < 0) - return r; +static bool have_non_accept_socket(Socket *s) { + SocketPort *p; - if (*new_state == UNIT_STUB) - return -ENOENT; + assert(s); - if ((r = unit_load_dropin(unit_follow_merge(u))) < 0) - return r; + if (!s->accept) + return true; - /* This is a new unit? Then let's add in some extras */ - if (*new_state == UNIT_LOADED) { + LIST_FOREACH(port, p, s->ports) + if (!socket_address_can_accept(&p->address)) + return true; - if (!(t = unit_name_change_suffix(unit_id(u), ".service"))) - return -ENOMEM; + return false; +} - r = manager_load_unit(u->meta.manager, t, (Unit**) &s->service); - free(t); +static int socket_verify(Socket *s) { + assert(s); - if (r < 0) - return r; + if (UNIT(s)->meta.load_state != UNIT_LOADED) + return 0; - if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service))) < 0) - return r; + if (!s->ports) { + log_error("%s lacks Listen setting. Refusing.", UNIT(s)->meta.id); + return -EINVAL; + } + + return 0; +} + +static int socket_load(Unit *u) { + Socket *s = SOCKET(u); + int r; + + assert(u); + assert(u->meta.load_state == UNIT_STUB); + + if ((r = unit_load_fragment_and_dropin(u)) < 0) + return r; + + /* This is a new unit? Then let's add in some extras */ + if (u->meta.load_state == UNIT_LOADED) { + + if (have_non_accept_socket(s)) { + if ((r = unit_load_related_unit(u, ".service", (Unit**) &s->service))) + return r; + + if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service))) < 0) + return r; + } if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0) return r; @@ -142,7 +177,7 @@ static int socket_init(Unit *u, UnitLoadState *new_state) { return r; } - return 0; + return socket_verify(s); } static const char* listen_lookup(int type) { @@ -160,7 +195,7 @@ static const char* listen_lookup(int type) { static void socket_dump(Unit *u, FILE *f, const char *prefix) { - static const char* const command_table[_SOCKET_EXEC_MAX] = { + static const char* const command_table[_SOCKET_EXEC_COMMAND_MAX] = { [SOCKET_EXEC_START_PRE] = "StartPre", [SOCKET_EXEC_START_POST] = "StartPost", [SOCKET_EXEC_STOP_PRE] = "StopPre", @@ -183,19 +218,31 @@ static void socket_dump(Unit *u, FILE *f, const char *prefix) { "%sSocket State: %s\n" "%sBindIPv6Only: %s\n" "%sBacklog: %u\n" + "%sKillMode: %s\n" "%sSocketMode: %04o\n" "%sDirectoryMode: %04o\n", prefix, state_string_table[s->state], prefix, yes_no(s->bind_ipv6_only), prefix, s->backlog, + prefix, kill_mode_to_string(s->kill_mode), prefix, s->socket_mode, prefix, s->directory_mode); + if (s->control_pid > 0) + fprintf(f, + "%sControl PID: %llu\n", + prefix, (unsigned long long) s->control_pid); + if (s->bind_to_device) fprintf(f, "%sBindToDevice: %s\n", prefix, s->bind_to_device); + if (s->accept) + fprintf(f, + "%sAccepted: %u\n", + prefix, s->n_accepted); + LIST_FOREACH(port, p, s->ports) { if (p->type == SOCKET_SOCKET) { @@ -216,7 +263,7 @@ static void socket_dump(Unit *u, FILE *f, const char *prefix) { exec_context_dump(&s->exec_context, f, prefix); - for (c = 0; c < _SOCKET_EXEC_MAX; c++) { + for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) { if (!s->exec_command[c]) continue; @@ -229,6 +276,87 @@ static void socket_dump(Unit *u, FILE *f, const char *prefix) { free(p2); } +static int instance_from_socket(int fd, unsigned nr, char **instance) { + socklen_t l; + char *r; + union { + struct sockaddr sa; + struct sockaddr_un un; + struct sockaddr_in in; + struct sockaddr_in6 in6; + struct sockaddr_storage storage; + } local, remote; + + assert(fd >= 0); + assert(instance); + + l = sizeof(local); + if (getsockname(fd, &local.sa, &l) < 0) + return -errno; + + l = sizeof(remote); + if (getpeername(fd, &remote.sa, &l) < 0) + return -errno; + + switch (local.sa.sa_family) { + + case AF_INET: { + uint32_t + a = ntohl(local.in.sin_addr.s_addr), + b = ntohl(remote.in.sin_addr.s_addr); + + if (asprintf(&r, + "%u-%u.%u.%u.%u-%u-%u.%u.%u.%u-%u", + nr, + a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF, + ntohs(local.in.sin_port), + b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF, + ntohs(remote.in.sin_port)) < 0) + return -ENOMEM; + + break; + } + + case AF_INET6: { + char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN]; + + if (asprintf(&r, + "%u-%s-%u-%s-%u", + nr, + inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)), + ntohs(local.in6.sin6_port), + inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)), + ntohs(remote.in6.sin6_port)) < 0) + return -ENOMEM; + + break; + } + + case AF_UNIX: { + struct ucred ucred; + + l = sizeof(ucred); + if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0) + return -errno; + + if (asprintf(&r, + "%u-%llu-%llu", + nr, + (unsigned long long) ucred.pid, + (unsigned long long) ucred.uid) < 0) + return -ENOMEM; + + break; + } + + default: + assert_not_reached("Unhandled socket type."); + } + + *instance = r; + return 0; +} + static void socket_close_fds(Socket *s) { SocketPort *p; @@ -328,6 +456,10 @@ static int socket_watch_fds(Socket *s) { if (p->fd < 0) continue; + p->fd_watch.data.socket_accept = + s->accept && + socket_address_can_accept(&p->address); + if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0) goto fail; } @@ -352,28 +484,12 @@ static void socket_set_state(Socket *s, SocketState state) { state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_STOP_PRE_SIGKILL && state != SOCKET_STOP_POST && - state != SOCKET_STOP_POST_SIGTERM && - state != SOCKET_STOP_POST_SIGKILL) + state != SOCKET_FINAL_SIGTERM && + state != SOCKET_FINAL_SIGKILL) { unit_unwatch_timer(UNIT(s), &s->timer_watch); - - if (state != SOCKET_START_PRE && - state != SOCKET_START_POST && - state != SOCKET_STOP_PRE && - state != SOCKET_STOP_PRE_SIGTERM && - state != SOCKET_STOP_PRE_SIGKILL && - state != SOCKET_STOP_POST && - state != SOCKET_STOP_POST_SIGTERM && - state != SOCKET_STOP_POST_SIGKILL) - if (s->control_pid > 0) { - unit_unwatch_pid(UNIT(s), s->control_pid); - s->control_pid = 0; - } - - if (state != SOCKET_START_PRE && - state != SOCKET_START_POST && - state != SOCKET_STOP_PRE && - state != SOCKET_STOP_POST) + socket_unwatch_control_pid(s); s->control_command = NULL; + } if (state != SOCKET_START_POST && state != SOCKET_LISTENING && @@ -386,32 +502,41 @@ static void socket_set_state(Socket *s, SocketState state) { if (state != SOCKET_LISTENING) socket_unwatch_fds(s); - log_debug("%s changed %s → %s", unit_id(UNIT(s)), state_string_table[old_state], state_string_table[state]); + if (state != old_state) + log_debug("%s changed %s → %s", s->meta.id, state_string_table[old_state], state_string_table[state]); unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]); } -static int socket_spawn(Socket *s, ExecCommand *c, bool timeout, pid_t *_pid) { +static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) { pid_t pid; int r; + char **argv; assert(s); assert(c); assert(_pid); - if (timeout) { - if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0) - goto fail; - } else - unit_unwatch_timer(UNIT(s), &s->timer_watch); + if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0) + goto fail; + + if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) { + r = -ENOMEM; + goto fail; + } - if ((r = exec_spawn(c, - &s->exec_context, - NULL, 0, - true, - true, - UNIT(s)->meta.cgroup_bondings, - &pid)) < 0) + r = exec_spawn(c, + argv, + &s->exec_context, + NULL, 0, + true, + true, + UNIT(s)->meta.manager->confirm_spawn, + UNIT(s)->meta.cgroup_bondings, + &pid); + + strv_free(argv); + if (r < 0) goto fail; if ((r = unit_watch_pid(UNIT(s), pid)) < 0) @@ -423,8 +548,7 @@ static int socket_spawn(Socket *s, ExecCommand *c, bool timeout, pid_t *_pid) { return 0; fail: - if (timeout) - unit_unwatch_timer(UNIT(s), &s->timer_watch); + unit_unwatch_timer(UNIT(s), &s->timer_watch); return r; } @@ -438,6 +562,8 @@ static void socket_enter_dead(Socket *s, bool success) { socket_set_state(s, s->failure ? SOCKET_MAINTAINANCE : SOCKET_DEAD); } +static void socket_enter_signal(Socket *s, SocketState state, bool success); + static void socket_enter_stop_post(Socket *s, bool success) { int r; assert(s); @@ -445,50 +571,65 @@ static void socket_enter_stop_post(Socket *s, bool success) { if (!success) s->failure = true; - if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) - if ((r = socket_spawn(s, s->control_command, true, &s->control_pid)) < 0) - goto fail; + socket_unwatch_control_pid(s); - socket_set_state(s, SOCKET_STOP_POST); + if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) { + if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) + goto fail; - if (!s->control_command) - socket_enter_dead(s, true); + socket_set_state(s, SOCKET_STOP_POST); + } else + socket_enter_signal(s, SOCKET_FINAL_SIGTERM, true); return; fail: - log_warning("%s failed to run stop-post executable: %s", unit_id(UNIT(s)), strerror(-r)); - socket_enter_dead(s, false); + log_warning("%s failed to run stop-post executable: %s", s->meta.id, strerror(-r)); + socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false); } static void socket_enter_signal(Socket *s, SocketState state, bool success) { int r; + bool sent = false; assert(s); if (!success) s->failure = true; - if (s->control_pid > 0) { - int sig; + if (s->kill_mode != KILL_NONE) { + int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? SIGTERM : SIGKILL; - sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_POST_SIGTERM) ? SIGTERM : SIGKILL; + if (s->kill_mode == KILL_CONTROL_GROUP) { - if (kill(s->control_pid, sig) < 0 && errno != ESRCH) { - r = -errno; - goto fail; + if ((r = cgroup_bonding_kill_list(UNIT(s)->meta.cgroup_bondings, sig)) < 0) { + if (r != -EAGAIN && r != -ESRCH) + goto fail; + } else + sent = true; } + + if (!sent && s->control_pid > 0) + if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH) { + r = -errno; + goto fail; + } } - socket_set_state(s, state); + if (sent) { + if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0) + goto fail; - if (s->control_pid <= 0) + socket_set_state(s, state); + } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL) + socket_enter_stop_post(s, true); + else socket_enter_dead(s, true); return; fail: - log_warning("%s failed to kill processes: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r)); if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL) socket_enter_stop_post(s, false); @@ -503,19 +644,20 @@ static void socket_enter_stop_pre(Socket *s, bool success) { if (!success) s->failure = true; - if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) - if ((r = socket_spawn(s, s->control_command, true, &s->control_pid)) < 0) - goto fail; + socket_unwatch_control_pid(s); - socket_set_state(s, SOCKET_STOP_PRE); + if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) { + if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) + goto fail; - if (!s->control_command) + socket_set_state(s, SOCKET_STOP_PRE); + } else socket_enter_stop_post(s, true); return; fail: - log_warning("%s failed to run stop-pre executable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run stop-pre executable: %s", s->meta.id, strerror(-r)); socket_enter_stop_post(s, false); } @@ -524,7 +666,7 @@ static void socket_enter_listening(Socket *s) { assert(s); if ((r = socket_watch_fds(s)) < 0) { - log_warning("%s failed to watch sockets: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to watch sockets: %s", s->meta.id, strerror(-r)); goto fail; } @@ -540,19 +682,20 @@ static void socket_enter_start_post(Socket *s) { assert(s); if ((r = socket_open_fds(s)) < 0) { - log_warning("%s failed to listen on sockets: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to listen on sockets: %s", s->meta.id, strerror(-r)); goto fail; } - if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) - if ((r = socket_spawn(s, s->control_command, true, &s->control_pid)) < 0) { - log_warning("%s failed to run start-post executable: %s", unit_id(UNIT(s)), strerror(-r)); + socket_unwatch_control_pid(s); + + if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) { + if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) { + log_warning("%s failed to run start-post executable: %s", s->meta.id, strerror(-r)); goto fail; } - socket_set_state(s, SOCKET_START_POST); - - if (!s->control_command) + socket_set_state(s, SOCKET_START_POST); + } else socket_enter_listening(s); return; @@ -565,36 +708,76 @@ static void socket_enter_start_pre(Socket *s) { int r; assert(s); - if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) - if ((r = socket_spawn(s, s->control_command, true, &s->control_pid)) < 0) - goto fail; + socket_unwatch_control_pid(s); - socket_set_state(s, SOCKET_START_PRE); + if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) { + if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) + goto fail; - if (!s->control_command) + socket_set_state(s, SOCKET_START_PRE); + } else socket_enter_start_post(s); return; fail: - log_warning("%s failed to run start-pre exectuable: %s", unit_id(UNIT(s)), strerror(-r)); + log_warning("%s failed to run start-pre exectuable: %s", s->meta.id, strerror(-r)); socket_enter_dead(s, false); } -static void socket_enter_running(Socket *s) { +static void socket_enter_running(Socket *s, int cfd) { int r; assert(s); - if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, NULL)) < 0) - goto fail; + if (cfd < 0) { + if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, NULL)) < 0) + goto fail; + + socket_set_state(s, SOCKET_RUNNING); + } else { + Unit *u; + char *prefix, *instance, *name; + + if ((r = instance_from_socket(cfd, s->n_accepted++, &instance))) + goto fail; + + if (!(prefix = unit_name_to_prefix(UNIT(s)->meta.id))) { + free(instance); + r = -ENOMEM; + goto fail; + } + + name = unit_name_build(prefix, instance, ".service"); + free(prefix); + free(instance); + + if (!name) + r = -ENOMEM; + + r = manager_load_unit(UNIT(s)->meta.manager, name, NULL, &u); + free(name); + + if (r < 0) + goto fail; + + if ((r = service_set_socket_fd(SERVICE(u), cfd) < 0)) + goto fail; + + cfd = -1; + + if ((r = manager_add_job(u->meta.manager, JOB_START, u, JOB_REPLACE, true, NULL)) < 0) + goto fail; + } - socket_set_state(s, SOCKET_RUNNING); return; fail: - log_warning("%s failed to queue socket startup job: %s", unit_id(UNIT(s)), strerror(-r)); - socket_enter_dead(s, false); + log_warning("%s failed to queue socket startup job: %s", s->meta.id, strerror(-r)); + socket_enter_stop_pre(s, false); + + if (cfd >= 0) + close_nointr_nofail(cfd); } static void socket_run_next(Socket *s, bool success) { @@ -607,20 +790,24 @@ static void socket_run_next(Socket *s, bool success) { if (!success) s->failure = true; + socket_unwatch_control_pid(s); + s->control_command = s->control_command->command_next; - if ((r = socket_spawn(s, s->control_command, true, &s->control_pid)) < 0) + if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) goto fail; return; fail: - if (s->state == SOCKET_STOP_PRE) - socket_enter_stop_post(s, false); + log_warning("%s failed to run spawn next executable: %s", s->meta.id, strerror(-r)); + + if (s->state == SOCKET_START_POST) + socket_enter_stop_pre(s, false); else if (s->state == SOCKET_STOP_POST) socket_enter_dead(s, false); else - socket_enter_stop_pre(s, false); + socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false); } static int socket_start(Unit *u) { @@ -634,8 +821,8 @@ static int socket_start(Unit *u) { s->state == SOCKET_STOP_PRE_SIGKILL || s->state == SOCKET_STOP_PRE_SIGTERM || s->state == SOCKET_STOP_POST || - s->state == SOCKET_STOP_POST_SIGTERM || - s->state == SOCKET_STOP_POST_SIGKILL) + s->state == SOCKET_FINAL_SIGTERM || + s->state == SOCKET_FINAL_SIGKILL) return -EAGAIN; if (s->state == SOCKET_START_PRE || @@ -643,8 +830,17 @@ static int socket_start(Unit *u) { return 0; /* Cannot run this without the service being around */ - if (s->service->meta.load_state != UNIT_LOADED) - return -ENOENT; + if (s->service) { + if (s->service->meta.load_state != UNIT_LOADED) + return -ENOENT; + + /* If the service is alredy actvie we cannot start the + * socket */ + if (s->service->state != SERVICE_DEAD && + s->service->state != SERVICE_MAINTAINANCE && + s->service->state != SERVICE_AUTO_RESTART) + return -EBUSY; + } assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE); @@ -664,6 +860,15 @@ static int socket_stop(Unit *u) { s->state == SOCKET_START_POST) return -EAGAIN; + /* Already on it */ + if (s->state == SOCKET_STOP_PRE || + s->state == SOCKET_STOP_PRE_SIGTERM || + s->state == SOCKET_STOP_PRE_SIGKILL || + s->state == SOCKET_STOP_POST || + s->state == SOCKET_FINAL_SIGTERM || + s->state == SOCKET_FINAL_SIGTERM) + return 0; + assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING); socket_enter_stop_pre(s, true); @@ -676,17 +881,47 @@ static UnitActiveState socket_active_state(Unit *u) { return state_translation_table[SOCKET(u)->state]; } +static const char *socket_sub_state_to_string(Unit *u) { + assert(u); + + return state_string_table[SOCKET(u)->state]; +} + static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) { Socket *s = SOCKET(u); + int cfd = -1; assert(s); + assert(fd >= 0); - log_debug("Incoming traffic on %s", unit_id(u)); + log_debug("Incoming traffic on %s", u->meta.id); - if (events != EPOLLIN) - socket_enter_stop_pre(s, false); + if (events != EPOLLIN) { + log_error("Got invalid poll event on socket."); + goto fail; + } + + if (w->data.socket_accept) { + for (;;) { + + if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) { + + if (errno == EINTR) + continue; + + log_error("Failed to accept socket: %m"); + goto fail; + } - socket_enter_running(s); + break; + } + } + + socket_enter_running(s, cfd); + return; + +fail: + socket_enter_stop_pre(s, false); } static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) { @@ -705,17 +940,16 @@ static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) { exec_status_fill(&s->control_command->exec_status, pid, code, status); s->control_pid = 0; - log_debug("%s control process exited, code=%s status=%i", unit_id(u), sigchld_code_to_string(code), status); + log_debug("%s control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status); - if (s->control_command->command_next && - (success || (s->state == SOCKET_STOP_PRE || s->state == SOCKET_STOP_POST))) { - log_debug("%s running next command for the state %s", unit_id(u), state_string_table[s->state]); + if (s->control_command->command_next && success) { + log_debug("%s running next command for state %s", u->meta.id, state_string_table[s->state]); socket_run_next(s, success); } else { /* No further commands for this step, so let's figure * out what to do next */ - log_debug("%s got final SIGCHLD for state %s", unit_id(u), state_string_table[s->state]); + log_debug("%s got final SIGCHLD for state %s", u->meta.id, state_string_table[s->state]); switch (s->state) { @@ -723,7 +957,7 @@ static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) { if (success) socket_enter_start_post(s); else - socket_enter_stop_pre(s, false); + socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false); break; case SOCKET_START_POST: @@ -740,8 +974,8 @@ static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) { break; case SOCKET_STOP_POST: - case SOCKET_STOP_POST_SIGTERM: - case SOCKET_STOP_POST_SIGKILL: + case SOCKET_FINAL_SIGTERM: + case SOCKET_FINAL_SIGKILL: socket_enter_dead(s, success); break; @@ -756,44 +990,46 @@ static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) { assert(s); assert(elapsed == 1); - assert(w == &s->timer_watch); switch (s->state) { case SOCKET_START_PRE: + log_warning("%s starting timed out. Terminating.", u->meta.id); + socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false); + case SOCKET_START_POST: - log_warning("%s operation timed out. Stopping.", unit_id(u)); + log_warning("%s starting timed out. Stopping.", u->meta.id); socket_enter_stop_pre(s, false); break; case SOCKET_STOP_PRE: - log_warning("%s stopping timed out. Terminating.", unit_id(u)); + log_warning("%s stopping timed out. Terminating.", u->meta.id); socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, false); break; case SOCKET_STOP_PRE_SIGTERM: - log_warning("%s stopping timed out. Killing.", unit_id(u)); + log_warning("%s stopping timed out. Killing.", u->meta.id); socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, false); break; case SOCKET_STOP_PRE_SIGKILL: - log_warning("%s still around after SIGKILL. Ignoring.", unit_id(u)); + log_warning("%s still around after SIGKILL. Ignoring.", u->meta.id); socket_enter_stop_post(s, false); break; case SOCKET_STOP_POST: - log_warning("%s stopping timed out (2). Terminating.", unit_id(u)); - socket_enter_signal(s, SOCKET_STOP_POST_SIGTERM, false); + log_warning("%s stopping timed out (2). Terminating.", u->meta.id); + socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false); break; - case SOCKET_STOP_POST_SIGTERM: - log_warning("%s stopping timed out (2). Killing.", unit_id(u)); - socket_enter_signal(s, SOCKET_STOP_POST_SIGKILL, false); + case SOCKET_FINAL_SIGTERM: + log_warning("%s stopping timed out (2). Killing.", u->meta.id); + socket_enter_signal(s, SOCKET_FINAL_SIGKILL, false); break; - case SOCKET_STOP_POST_SIGKILL: - log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", unit_id(u)); + case SOCKET_FINAL_SIGKILL: + log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id); socket_enter_dead(s, false); break; @@ -840,7 +1076,7 @@ void socket_notify_service_dead(Socket *s) { /* The service is dead. Dang. */ if (s->state == SOCKET_RUNNING) { - log_debug("%s got notified about service death.", unit_id(UNIT(s))); + log_debug("%s got notified about service death.", s->meta.id); socket_enter_listening(s); } } @@ -849,6 +1085,7 @@ const UnitVTable socket_vtable = { .suffix = ".socket", .init = socket_init, + .load = socket_load, .done = socket_done, .dump = socket_dump, @@ -857,6 +1094,7 @@ const UnitVTable socket_vtable = { .stop = socket_stop, .active_state = socket_active_state, + .sub_state_to_string = socket_sub_state_to_string, .fd_event = socket_fd_event, .sigchld_event = socket_sigchld_event,