X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=socket.c;h=3d02f414115de9adadec0f89327a2c4e4cba5b53;hp=ac0ea124b4f081af0994cbd4d50205173ddd296b;hb=87f0e418cf2c58b3201d06a60e3696ec672d2662;hpb=9152c765065184d0c1267ed2499e3fe4cac53755 diff --git a/socket.c b/socket.c index ac0ea124b..3d02f4141 100644 --- a/socket.c +++ b/socket.c @@ -6,29 +6,93 @@ #include #include #include +#include -#include "name.h" +#include "unit.h" #include "socket.h" #include "log.h" -static const NameActiveState state_table[_SOCKET_STATE_MAX] = { - [SOCKET_DEAD] = NAME_INACTIVE, - [SOCKET_START_PRE] = NAME_ACTIVATING, - [SOCKET_START_POST] = NAME_ACTIVATING, - [SOCKET_LISTENING] = NAME_ACTIVE, - [SOCKET_RUNNING] = NAME_ACTIVE, - [SOCKET_STOP_PRE] = NAME_DEACTIVATING, - [SOCKET_STOP_POST] = NAME_DEACTIVATING, - [SOCKET_MAINTAINANCE] = NAME_INACTIVE, +static const UnitActiveState state_table[_SOCKET_STATE_MAX] = { + [SOCKET_DEAD] = UNIT_INACTIVE, + [SOCKET_START_PRE] = UNIT_ACTIVATING, + [SOCKET_START_POST] = UNIT_ACTIVATING, + [SOCKET_LISTENING] = UNIT_ACTIVE, + [SOCKET_RUNNING] = UNIT_ACTIVE, + [SOCKET_STOP_PRE] = UNIT_DEACTIVATING, + [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_MAINTAINANCE] = UNIT_INACTIVE, }; -static int socket_load(Name *n) { - Socket *s = SOCKET(n); +static void socket_done(Unit *u) { + Socket *s = SOCKET(u); + SocketPort *p; + + assert(s); + + while ((p = s->ports)) { + LIST_REMOVE(SocketPort, port, s->ports, p); + + if (p->fd >= 0) + close_nointr(p->fd); + free(p->path); + free(p); + } + + exec_context_done(&s->exec_context); + exec_command_free_array(s->exec_command, _SOCKET_EXEC_MAX); + s->control_command = NULL; + + if (s->control_pid > 0) { + unit_unwatch_pid(u, s->control_pid); + s->control_pid = 0; + } + + s->service = NULL; + + unit_unwatch_timer(u, &s->timer_id); +} - exec_context_defaults(&s->exec_context); +static int socket_init(Unit *u) { + Socket *s = SOCKET(u); + char *t; + int r; + + /* First, reset everything to the defaults, in case this is a + * reload */ + + s->state = 0; + s->timer_id = -1; + s->bind_ipv6_only = false; s->backlog = SOMAXCONN; + s->timeout_usec = DEFAULT_TIMEOUT_USEC; + exec_context_init(&s->exec_context); + + if ((r = unit_load_fragment_and_dropin(u)) < 0) + goto fail; + + if (!(t = unit_name_change_suffix(unit_id(u), ".service"))) { + r = -ENOMEM; + goto fail; + } - return name_load_fragment_and_dropin(n); + r = manager_load_unit(u->meta.manager, t, (Unit**) &s->service); + free(t); + + if (r < 0) + goto fail; + + if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service))) < 0) + goto fail; + + return 0; + +fail: + socket_done(u); + return r; } static const char* listen_lookup(int type) { @@ -40,11 +104,11 @@ static const char* listen_lookup(int type) { else if (type == SOCK_SEQPACKET) return "ListenSequentialPacket"; - assert_not_reached("Unkown socket type"); + assert_not_reached("Unknown socket type"); return NULL; } -static void socket_dump(Name *n, FILE *f, const char *prefix) { +static void socket_dump(Unit *u, FILE *f, const char *prefix) { static const char* const state_table[_SOCKET_STATE_MAX] = { [SOCKET_DEAD] = "dead", @@ -53,7 +117,11 @@ static void socket_dump(Name *n, FILE *f, const char *prefix) { [SOCKET_LISTENING] = "listening", [SOCKET_RUNNING] = "running", [SOCKET_STOP_PRE] = "stop-pre", + [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_MAINTAINANCE] = "maintainance" }; @@ -65,7 +133,7 @@ static void socket_dump(Name *n, FILE *f, const char *prefix) { }; SocketExecCommand c; - Socket *s = SOCKET(n); + Socket *s = SOCKET(u); SocketPort *p; assert(s); @@ -78,7 +146,7 @@ static void socket_dump(Name *n, FILE *f, const char *prefix) { prefix, yes_no(s->bind_ipv6_only), prefix, s->backlog); - LIST_FOREACH(p, s->ports) { + LIST_FOREACH(port, p, s->ports) { if (p->type == SOCKET_SOCKET) { const char *t; @@ -101,61 +169,37 @@ static void socket_dump(Name *n, FILE *f, const char *prefix) { for (c = 0; c < _SOCKET_EXEC_MAX; c++) { ExecCommand *i; - LIST_FOREACH(i, s->exec_command[c]) + LIST_FOREACH(command, i, s->exec_command[c]) fprintf(f, "%s%s: %s\n", prefix, command_table[c], i->path); } } -static void socket_set_state(Socket *s, SocketState state) { - SocketState old_state; - assert(s); - - old_state = s->state; - s->state = state; - - name_notify(NAME(s), state_table[old_state], state_table[s->state]); -} - -static void close_fds(Socket *s) { +static void socket_close_fds(Socket *s) { SocketPort *p; assert(s); - LIST_FOREACH(p, s->ports) { + LIST_FOREACH(port, p, s->ports) { if (p->fd < 0) continue; - name_unwatch_fd(NAME(s), p->fd); + unit_unwatch_fd(UNIT(s), p->fd); assert_se(close_nointr(p->fd) >= 0); p->fd = -1; } } -static int socket_start(Name *n) { - Socket *s = SOCKET(n); +static int socket_open_fds(Socket *s) { SocketPort *p; int r; assert(s); - if (s->state == SOCKET_START_PRE || - s->state == SOCKET_START_POST) - return 0; - - if (s->state == SOCKET_LISTENING || - s->state == SOCKET_RUNNING) - return -EALREADY; - - if (s->state == SOCKET_STOP_PRE || - s->state == SOCKET_STOP_POST) - return -EAGAIN; - - assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE); - - LIST_FOREACH(p, s->ports) { + LIST_FOREACH(port, p, s->ports) { - assert(p->fd < 0); + if (p->fd >= 0) + continue; if (p->type == SOCKET_SOCKET) { @@ -188,110 +232,530 @@ static int socket_start(Name *n) { goto rollback; } } + } + + return 0; + +rollback: + socket_close_fds(s); + return r; +} + +static void socket_unwatch_fds(Socket *s) { + SocketPort *p; + + assert(s); - if ((r = name_watch_fd(n, p->fd, POLLIN)) < 0) - goto rollback; + LIST_FOREACH(port, p, s->ports) { + if (p->fd < 0) + continue; + + unit_unwatch_fd(UNIT(s), p->fd); } +} - socket_set_state(s, SOCKET_LISTENING); +static int socket_watch_fds(Socket *s) { + SocketPort *p; + int r; + + assert(s); + + LIST_FOREACH(port, p, s->ports) { + if (p->fd < 0) + continue; + + if ((r = unit_watch_fd(UNIT(s), p->fd, POLLIN)) < 0) + goto fail; + } return 0; -rollback: - close_fds(s); +fail: + socket_unwatch_fds(s); + return r; +} + +static void socket_set_state(Socket *s, SocketState state) { + SocketState old_state; + assert(s); + + old_state = s->state; + s->state = state; - socket_set_state(s, SOCKET_MAINTAINANCE); + 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) + unit_unwatch_timer(UNIT(s), &s->timer_id); + + 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) + s->control_command = NULL; + + if (state != SOCKET_START_POST && + state != SOCKET_LISTENING && + state != SOCKET_RUNNING && + state != SOCKET_STOP_PRE && + state != SOCKET_STOP_PRE_SIGTERM && + state != SOCKET_STOP_PRE_SIGKILL) + socket_close_fds(s); + + if (state != SOCKET_LISTENING) + socket_unwatch_fds(s); + + unit_notify(UNIT(s), state_table[old_state], state_table[s->state]); +} + +static int socket_spawn(Socket *s, ExecCommand *c, bool timeout, pid_t *_pid) { + pid_t pid; + int r; + + assert(s); + assert(c); + assert(_pid); + + if (timeout) { + if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_id)) < 0) + goto fail; + } else + unit_unwatch_timer(UNIT(s), &s->timer_id); + + if ((r = exec_spawn(c, &s->exec_context, NULL, 0, &pid)) < 0) + goto fail; + + if ((r = unit_watch_pid(UNIT(s), pid)) < 0) + /* FIXME: we need to do something here */ + goto fail; + + *_pid = pid; + + return 0; + +fail: + if (timeout) + unit_unwatch_timer(UNIT(s), &s->timer_id); return r; } -static int socket_stop(Name *n) { - Socket *s = SOCKET(n); +static void socket_enter_dead(Socket *s, bool success) { + assert(s); + + if (!success) + s->failure = true; + + socket_set_state(s, s->failure ? SOCKET_MAINTAINANCE : SOCKET_DEAD); +} +static void socket_enter_stop_post(Socket *s, bool success) { + int r; assert(s); - if (s->state == SOCKET_START_PRE || - s->state == SOCKET_START_POST) - return -EAGAIN; + 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_set_state(s, SOCKET_STOP_POST); + } else + socket_enter_dead(s, true); + + return; + +fail: + log_warning("%s failed to run stop-post executable: %s", unit_id(UNIT(s)), strerror(-r)); + socket_enter_dead(s, false); +} + +static void socket_enter_signal(Socket *s, SocketState state, bool success) { + int r; + + assert(s); - if (s->state == SOCKET_DEAD || - s->state == SOCKET_MAINTAINANCE) - return -EALREADY; + if (!success) + s->failure = true; + if (s->control_pid > 0) { + int sig; + + sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_POST_SIGTERM) ? SIGTERM : SIGKILL; + + if (kill(s->control_pid, sig) < 0 && errno != ESRCH) { + r = -errno; + goto fail; + } + + socket_set_state(s, state); + } else + socket_enter_dead(s, true); + + return; + +fail: + log_warning("%s failed to kill processes: %s", unit_id(UNIT(s)), strerror(-r)); + + if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL) + socket_enter_stop_post(s, false); + else + socket_enter_dead(s, false); +} + +static void socket_enter_stop_pre(Socket *s, bool success) { + int r; + assert(s); + + 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_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)); + socket_enter_stop_post(s, false); +} + +static void socket_enter_start_post(Socket *s) { + int r; + assert(s); + + if ((r = socket_open_fds(s)) < 0 || + (r = socket_watch_fds(s)) < 0) { + log_warning("%s failed to listen on sockets: %s", unit_id(UNIT(s)), 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)); + goto fail; + } + + socket_set_state(s, SOCKET_START_POST); + } else + socket_set_state(s, SOCKET_LISTENING); + + return; + +fail: + socket_enter_stop_pre(s, false); +} + +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_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)); + socket_enter_dead(s, false); +} + +static void socket_enter_running(Socket *s) { + 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; + + 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); +} + +static void socket_run_next(Socket *s, bool success) { + int r; + + assert(s); + assert(s->control_command); + assert(s->control_command->command_next); + + if (!success) + s->failure = true; + + s->control_command = s->control_command->command_next; + + if ((r = socket_spawn(s, s->control_command, true, &s->control_pid)) < 0) + goto fail; + + return; + +fail: + if (s->state == SOCKET_STOP_PRE) + socket_enter_stop_post(s, false); + else if (s->state == SOCKET_STOP_POST) + socket_enter_dead(s, false); + else + socket_enter_stop_pre(s, false); +} + +static int socket_start(Unit *u) { + Socket *s = SOCKET(u); + + assert(s); + + /* We cannot fulfill this request right now, try again later + * please! */ if (s->state == SOCKET_STOP_PRE || - s->state == SOCKET_STOP_POST) + 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) + return -EAGAIN; + + if (s->state == SOCKET_START_PRE || + s->state == SOCKET_START_POST) return 0; - assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING); + /* Cannot run this without the service being around */ + if (s->service->meta.load_state != UNIT_LOADED) + return -ENOENT; - close_fds(s); + assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE); + + s->failure = false; + socket_enter_start_pre(s); + return 0; +} + +static int socket_stop(Unit *u) { + Socket *s = SOCKET(u); + + assert(s); + + /* We cannot fulfill this request right now, try again later + * please! */ + if (s->state == SOCKET_START_PRE || + s->state == SOCKET_START_POST) + return -EAGAIN; - socket_set_state(s, SOCKET_DEAD); + assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING); + socket_enter_stop_pre(s, true); return 0; } -static NameActiveState socket_active_state(Name *n) { - assert(n); +static UnitActiveState socket_active_state(Unit *u) { + assert(u); - return state_table[SOCKET(n)->state]; + return state_table[SOCKET(u)->state]; } -static void socket_fd_event(Name *n, int fd, uint32_t events) { - Socket *s = SOCKET(n); +static void socket_fd_event(Unit *u, int fd, uint32_t events) { + Socket *s = SOCKET(u); - assert(n); + assert(s); + + log_info("Incoming traffic on %s", unit_id(u)); if (events != POLLIN) - goto fail; + socket_enter_stop_pre(s, false); + + socket_enter_running(s); +} - log_info("POLLIN on %s", name_id(n)); +static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) { + Socket *s = SOCKET(u); + bool success; - return; + assert(s); + assert(pid >= 0); -fail: - close_fds(s); - socket_set_state(s, SOCKET_MAINTAINANCE); + success = code == CLD_EXITED || status == 0; + s->failure = s->failure || !success; + + assert(s->control_pid == pid); + assert(s->control_command); + + 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(code), status); + + if (s->control_command->command_next && + (success || (s->state == SOCKET_EXEC_STOP_PRE || s->state == SOCKET_EXEC_STOP_POST))) + socket_run_next(s, success); + else { + /* No further commands for this step, so let's figure + * out what to do next */ + + switch (s->state) { + + case SOCKET_START_PRE: + if (success) + socket_enter_start_pre(s); + else + socket_enter_stop_pre(s, false); + break; + + case SOCKET_START_POST: + if (success) + socket_set_state(s, SOCKET_LISTENING); + else + socket_enter_stop_pre(s, false); + break; + + case SOCKET_STOP_PRE: + case SOCKET_STOP_PRE_SIGTERM: + case SOCKET_STOP_PRE_SIGKILL: + socket_enter_stop_post(s, success); + break; + + case SOCKET_STOP_POST: + case SOCKET_STOP_POST_SIGTERM: + case SOCKET_STOP_POST_SIGKILL: + socket_enter_dead(s, success); + break; + + default: + assert_not_reached("Uh, control process died at wrong time."); + } + } } -static void socket_free_hook(Name *n) { - SocketExecCommand c; - Socket *s = SOCKET(n); +static void socket_timer_event(Unit *u, int id, uint64_t elapsed) { + Socket *s = SOCKET(u); + + assert(s); + assert(elapsed == 1); + + assert(s->timer_id == id); + + switch (s->state) { + + case SOCKET_START_PRE: + case SOCKET_START_POST: + log_warning("%s operation timed out. Stopping.", unit_id(u)); + socket_enter_stop_pre(s, false); + break; + + case SOCKET_STOP_PRE: + log_warning("%s stopping timed out. Terminating.", unit_id(u)); + 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)); + 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)); + 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); + 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); + break; + + case SOCKET_STOP_POST_SIGKILL: + log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", unit_id(u)); + socket_enter_dead(s, false); + break; + + default: + assert_not_reached("Timeout at wrong time."); + } +} + +int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) { + int *rfds; + unsigned rn_fds, k; SocketPort *p; assert(s); + assert(fds); + assert(n_fds); - while ((p = s->ports)) { - LIST_REMOVE(SocketPort, s->ports, p); + /* Called from the service code for requesting our fds */ + rn_fds = 0; + LIST_FOREACH(port, p, s->ports) if (p->fd >= 0) - close_nointr(p->fd); - free(p->path); - free(p); - } + rn_fds++; + + if (!(rfds = new(int, rn_fds)) < 0) + return -ENOMEM; + + k = 0; + LIST_FOREACH(port, p, s->ports) + if (p->fd >= 0) + rfds[k++] = p->fd; - exec_context_free(&s->exec_context); + assert(k == rn_fds); - for (c = 0; c < _SOCKET_EXEC_MAX; c++) - exec_command_free_list(s->exec_command[c]); + *fds = rfds; + *n_fds = rn_fds; - if (s->service) - s->service->socket = NULL; + return 0; } -const NameVTable socket_vtable = { +const UnitVTable socket_vtable = { .suffix = ".socket", - .load = socket_load, + .init = socket_init, + .done = socket_done, + .dump = socket_dump, .start = socket_start, .stop = socket_stop, - .reload = NULL, .active_state = socket_active_state, .fd_event = socket_fd_event, - - .free_hook = socket_free_hook + .sigchld_event = socket_sigchld_event, + .timer_event = socket_timer_event };