1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
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 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/types.h>
27 #include <sys/epoll.h>
33 #include "load-dropin.h"
34 #include "load-fragment.h"
37 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
38 [SOCKET_DEAD] = UNIT_INACTIVE,
39 [SOCKET_START_PRE] = UNIT_ACTIVATING,
40 [SOCKET_START_POST] = UNIT_ACTIVATING,
41 [SOCKET_LISTENING] = UNIT_ACTIVE,
42 [SOCKET_RUNNING] = UNIT_ACTIVE,
43 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
44 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
45 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
46 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
47 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
48 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
49 [SOCKET_MAINTAINANCE] = UNIT_INACTIVE,
52 static const char* const state_string_table[_SOCKET_STATE_MAX] = {
53 [SOCKET_DEAD] = "dead",
54 [SOCKET_START_PRE] = "start-pre",
55 [SOCKET_START_POST] = "start-post",
56 [SOCKET_LISTENING] = "listening",
57 [SOCKET_RUNNING] = "running",
58 [SOCKET_STOP_PRE] = "stop-pre",
59 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
60 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
61 [SOCKET_STOP_POST] = "stop-post",
62 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
63 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
64 [SOCKET_MAINTAINANCE] = "maintainance"
67 static void socket_unwatch_control_pid(Socket *s) {
70 if (s->control_pid <= 0)
73 unit_unwatch_pid(UNIT(s), s->control_pid);
77 static void socket_done(Unit *u) {
78 Socket *s = SOCKET(u);
83 while ((p = s->ports)) {
84 LIST_REMOVE(SocketPort, port, s->ports, p);
92 exec_context_done(&s->exec_context);
93 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
94 s->control_command = NULL;
96 socket_unwatch_control_pid(s);
100 free(s->bind_to_device);
101 s->bind_to_device = NULL;
103 unit_unwatch_timer(u, &s->timer_watch);
106 static void socket_init(Unit *u) {
107 Socket *s = SOCKET(u);
110 assert(u->meta.load_state == UNIT_STUB);
113 s->timer_watch.type = WATCH_INVALID;
114 s->bind_ipv6_only = false;
115 s->backlog = SOMAXCONN;
116 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
117 s->directory_mode = 0755;
118 s->socket_mode = 0666;
123 exec_context_init(&s->exec_context);
126 static int socket_load(Unit *u) {
127 Socket *s = SOCKET(u);
131 assert(u->meta.load_state == UNIT_STUB);
133 if ((r = unit_load_fragment_and_dropin(u)) < 0)
136 /* This is a new unit? Then let's add in some extras */
137 if (u->meta.load_state == UNIT_LOADED) {
139 if ((r = unit_load_related_unit(u, ".service", (Unit**) &s->service)))
142 if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service))) < 0)
145 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
148 if ((r = unit_add_default_cgroup(u)) < 0)
155 static const char* listen_lookup(int type) {
157 if (type == SOCK_STREAM)
158 return "ListenStream";
159 else if (type == SOCK_DGRAM)
160 return "ListenDatagram";
161 else if (type == SOCK_SEQPACKET)
162 return "ListenSequentialPacket";
164 assert_not_reached("Unknown socket type");
168 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
170 static const char* const command_table[_SOCKET_EXEC_COMMAND_MAX] = {
171 [SOCKET_EXEC_START_PRE] = "StartPre",
172 [SOCKET_EXEC_START_POST] = "StartPost",
173 [SOCKET_EXEC_STOP_PRE] = "StopPre",
174 [SOCKET_EXEC_STOP_POST] = "StopPost"
178 Socket *s = SOCKET(u);
186 p2 = strappend(prefix, "\t");
187 prefix2 = p2 ? p2 : prefix;
190 "%sSocket State: %s\n"
191 "%sBindIPv6Only: %s\n"
194 "%sSocketMode: %04o\n"
195 "%sDirectoryMode: %04o\n",
196 prefix, state_string_table[s->state],
197 prefix, yes_no(s->bind_ipv6_only),
199 prefix, kill_mode_to_string(s->kill_mode),
200 prefix, s->socket_mode,
201 prefix, s->directory_mode);
203 if (s->control_pid > 0)
205 "%sControl PID: %llu\n",
206 prefix, (unsigned long long) s->control_pid);
208 if (s->bind_to_device)
210 "%sBindToDevice: %s\n",
211 prefix, s->bind_to_device);
213 LIST_FOREACH(port, p, s->ports) {
215 if (p->type == SOCKET_SOCKET) {
220 if ((r = socket_address_print(&p->address, &k)) < 0)
225 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(p->address.type), k);
228 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
231 exec_context_dump(&s->exec_context, f, prefix);
233 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
234 if (!s->exec_command[c])
237 fprintf(f, "%s→ %s:\n",
238 prefix, command_table[c]);
240 exec_command_dump_list(s->exec_command[c], f, prefix2);
246 static void socket_close_fds(Socket *s) {
251 LIST_FOREACH(port, p, s->ports) {
255 unit_unwatch_fd(UNIT(s), &p->fd_watch);
256 assert_se(close_nointr(p->fd) >= 0);
262 static int socket_open_fds(Socket *s) {
268 LIST_FOREACH(port, p, s->ports) {
273 if (p->type == SOCKET_SOCKET) {
275 if ((r = socket_address_listen(
287 assert(p->type == SOCKET_FIFO);
289 mkdir_parents(p->path, s->directory_mode);
291 if (mkfifo(p->path, s->socket_mode) < 0 && errno != EEXIST) {
296 if ((p->fd = open(p->path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
301 if (fstat(p->fd, &st) < 0) {
306 /* FIXME verify user, access mode */
308 if (!S_ISFIFO(st.st_mode)) {
322 static void socket_unwatch_fds(Socket *s) {
327 LIST_FOREACH(port, p, s->ports) {
331 unit_unwatch_fd(UNIT(s), &p->fd_watch);
335 static int socket_watch_fds(Socket *s) {
341 LIST_FOREACH(port, p, s->ports) {
345 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
352 socket_unwatch_fds(s);
356 static void socket_set_state(Socket *s, SocketState state) {
357 SocketState old_state;
360 old_state = s->state;
363 if (state != SOCKET_START_PRE &&
364 state != SOCKET_START_POST &&
365 state != SOCKET_STOP_PRE &&
366 state != SOCKET_STOP_PRE_SIGTERM &&
367 state != SOCKET_STOP_PRE_SIGKILL &&
368 state != SOCKET_STOP_POST &&
369 state != SOCKET_FINAL_SIGTERM &&
370 state != SOCKET_FINAL_SIGKILL) {
371 unit_unwatch_timer(UNIT(s), &s->timer_watch);
372 socket_unwatch_control_pid(s);
373 s->control_command = NULL;
376 if (state != SOCKET_START_POST &&
377 state != SOCKET_LISTENING &&
378 state != SOCKET_RUNNING &&
379 state != SOCKET_STOP_PRE &&
380 state != SOCKET_STOP_PRE_SIGTERM &&
381 state != SOCKET_STOP_PRE_SIGKILL)
384 if (state != SOCKET_LISTENING)
385 socket_unwatch_fds(s);
387 if (state != old_state)
388 log_debug("%s changed %s → %s", s->meta.id, state_string_table[old_state], state_string_table[state]);
390 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]);
393 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
402 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
405 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
416 UNIT(s)->meta.manager->confirm_spawn,
417 UNIT(s)->meta.cgroup_bondings,
424 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
425 /* FIXME: we need to do something here */
433 unit_unwatch_timer(UNIT(s), &s->timer_watch);
438 static void socket_enter_dead(Socket *s, bool success) {
444 socket_set_state(s, s->failure ? SOCKET_MAINTAINANCE : SOCKET_DEAD);
447 static void socket_enter_signal(Socket *s, SocketState state, bool success);
449 static void socket_enter_stop_post(Socket *s, bool success) {
456 socket_unwatch_control_pid(s);
458 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
459 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
462 socket_set_state(s, SOCKET_STOP_POST);
464 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, true);
469 log_warning("%s failed to run stop-post executable: %s", s->meta.id, strerror(-r));
470 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
473 static void socket_enter_signal(Socket *s, SocketState state, bool success) {
482 if (s->kill_mode != KILL_NONE) {
483 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
485 if (s->kill_mode == KILL_CONTROL_GROUP) {
487 if ((r = cgroup_bonding_kill_list(UNIT(s)->meta.cgroup_bondings, sig)) < 0) {
488 if (r != -EAGAIN && r != -ESRCH)
494 if (!sent && s->control_pid > 0)
495 if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH) {
502 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
505 socket_set_state(s, state);
506 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
507 socket_enter_stop_post(s, true);
509 socket_enter_dead(s, true);
514 log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r));
516 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
517 socket_enter_stop_post(s, false);
519 socket_enter_dead(s, false);
522 static void socket_enter_stop_pre(Socket *s, bool success) {
529 socket_unwatch_control_pid(s);
531 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
532 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
535 socket_set_state(s, SOCKET_STOP_PRE);
537 socket_enter_stop_post(s, true);
542 log_warning("%s failed to run stop-pre executable: %s", s->meta.id, strerror(-r));
543 socket_enter_stop_post(s, false);
546 static void socket_enter_listening(Socket *s) {
550 if ((r = socket_watch_fds(s)) < 0) {
551 log_warning("%s failed to watch sockets: %s", s->meta.id, strerror(-r));
555 socket_set_state(s, SOCKET_LISTENING);
559 socket_enter_stop_pre(s, false);
562 static void socket_enter_start_post(Socket *s) {
566 if ((r = socket_open_fds(s)) < 0) {
567 log_warning("%s failed to listen on sockets: %s", s->meta.id, strerror(-r));
571 socket_unwatch_control_pid(s);
573 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
574 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) {
575 log_warning("%s failed to run start-post executable: %s", s->meta.id, strerror(-r));
579 socket_set_state(s, SOCKET_START_POST);
581 socket_enter_listening(s);
586 socket_enter_stop_pre(s, false);
589 static void socket_enter_start_pre(Socket *s) {
593 socket_unwatch_control_pid(s);
595 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
596 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
599 socket_set_state(s, SOCKET_START_PRE);
601 socket_enter_start_post(s);
606 log_warning("%s failed to run start-pre exectuable: %s", s->meta.id, strerror(-r));
607 socket_enter_dead(s, false);
610 static void socket_enter_running(Socket *s) {
615 if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, NULL)) < 0)
618 socket_set_state(s, SOCKET_RUNNING);
622 log_warning("%s failed to queue socket startup job: %s", s->meta.id, strerror(-r));
623 socket_enter_stop_pre(s, false);
626 static void socket_run_next(Socket *s, bool success) {
630 assert(s->control_command);
631 assert(s->control_command->command_next);
636 socket_unwatch_control_pid(s);
638 s->control_command = s->control_command->command_next;
640 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
646 log_warning("%s failed to run spawn next executable: %s", s->meta.id, strerror(-r));
648 if (s->state == SOCKET_START_POST)
649 socket_enter_stop_pre(s, false);
650 else if (s->state == SOCKET_STOP_POST)
651 socket_enter_dead(s, false);
653 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
656 static int socket_start(Unit *u) {
657 Socket *s = SOCKET(u);
661 /* We cannot fulfill this request right now, try again later
663 if (s->state == SOCKET_STOP_PRE ||
664 s->state == SOCKET_STOP_PRE_SIGKILL ||
665 s->state == SOCKET_STOP_PRE_SIGTERM ||
666 s->state == SOCKET_STOP_POST ||
667 s->state == SOCKET_FINAL_SIGTERM ||
668 s->state == SOCKET_FINAL_SIGKILL)
671 if (s->state == SOCKET_START_PRE ||
672 s->state == SOCKET_START_POST)
675 /* Cannot run this without the service being around */
676 if (s->service->meta.load_state != UNIT_LOADED)
679 /* If the service is alredy actvie we cannot start the
681 if (s->service->state != SERVICE_DEAD &&
682 s->service->state != SERVICE_MAINTAINANCE &&
683 s->service->state != SERVICE_AUTO_RESTART)
686 assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE);
689 socket_enter_start_pre(s);
693 static int socket_stop(Unit *u) {
694 Socket *s = SOCKET(u);
698 /* We cannot fulfill this request right now, try again later
700 if (s->state == SOCKET_START_PRE ||
701 s->state == SOCKET_START_POST)
705 if (s->state == SOCKET_STOP_PRE ||
706 s->state == SOCKET_STOP_PRE_SIGTERM ||
707 s->state == SOCKET_STOP_PRE_SIGKILL ||
708 s->state == SOCKET_STOP_POST ||
709 s->state == SOCKET_FINAL_SIGTERM ||
710 s->state == SOCKET_FINAL_SIGTERM)
713 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
715 socket_enter_stop_pre(s, true);
719 static UnitActiveState socket_active_state(Unit *u) {
722 return state_translation_table[SOCKET(u)->state];
725 static const char *socket_sub_state_to_string(Unit *u) {
728 return state_string_table[SOCKET(u)->state];
731 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
732 Socket *s = SOCKET(u);
736 log_debug("Incoming traffic on %s", u->meta.id);
738 if (events != EPOLLIN)
739 socket_enter_stop_pre(s, false);
741 socket_enter_running(s);
744 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
745 Socket *s = SOCKET(u);
751 success = code == CLD_EXITED && status == 0;
752 s->failure = s->failure || !success;
754 assert(s->control_pid == pid);
755 assert(s->control_command);
757 exec_status_fill(&s->control_command->exec_status, pid, code, status);
760 log_debug("%s control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
762 if (s->control_command->command_next && success) {
763 log_debug("%s running next command for state %s", u->meta.id, state_string_table[s->state]);
764 socket_run_next(s, success);
766 /* No further commands for this step, so let's figure
767 * out what to do next */
769 log_debug("%s got final SIGCHLD for state %s", u->meta.id, state_string_table[s->state]);
773 case SOCKET_START_PRE:
775 socket_enter_start_post(s);
777 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
780 case SOCKET_START_POST:
782 socket_enter_listening(s);
784 socket_enter_stop_pre(s, false);
787 case SOCKET_STOP_PRE:
788 case SOCKET_STOP_PRE_SIGTERM:
789 case SOCKET_STOP_PRE_SIGKILL:
790 socket_enter_stop_post(s, success);
793 case SOCKET_STOP_POST:
794 case SOCKET_FINAL_SIGTERM:
795 case SOCKET_FINAL_SIGKILL:
796 socket_enter_dead(s, success);
800 assert_not_reached("Uh, control process died at wrong time.");
805 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
806 Socket *s = SOCKET(u);
809 assert(elapsed == 1);
810 assert(w == &s->timer_watch);
814 case SOCKET_START_PRE:
815 log_warning("%s starting timed out. Terminating.", u->meta.id);
816 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
818 case SOCKET_START_POST:
819 log_warning("%s starting timed out. Stopping.", u->meta.id);
820 socket_enter_stop_pre(s, false);
823 case SOCKET_STOP_PRE:
824 log_warning("%s stopping timed out. Terminating.", u->meta.id);
825 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, false);
828 case SOCKET_STOP_PRE_SIGTERM:
829 log_warning("%s stopping timed out. Killing.", u->meta.id);
830 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, false);
833 case SOCKET_STOP_PRE_SIGKILL:
834 log_warning("%s still around after SIGKILL. Ignoring.", u->meta.id);
835 socket_enter_stop_post(s, false);
838 case SOCKET_STOP_POST:
839 log_warning("%s stopping timed out (2). Terminating.", u->meta.id);
840 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
843 case SOCKET_FINAL_SIGTERM:
844 log_warning("%s stopping timed out (2). Killing.", u->meta.id);
845 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, false);
848 case SOCKET_FINAL_SIGKILL:
849 log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id);
850 socket_enter_dead(s, false);
854 assert_not_reached("Timeout at wrong time.");
858 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
867 /* Called from the service code for requesting our fds */
870 LIST_FOREACH(port, p, s->ports)
874 if (!(rfds = new(int, rn_fds)) < 0)
878 LIST_FOREACH(port, p, s->ports)
890 void socket_notify_service_dead(Socket *s) {
893 /* The service is dead. Dang. */
895 if (s->state == SOCKET_RUNNING) {
896 log_debug("%s got notified about service death.", s->meta.id);
897 socket_enter_listening(s);
901 const UnitVTable socket_vtable = {
910 .start = socket_start,
913 .active_state = socket_active_state,
914 .sub_state_to_string = socket_sub_state_to_string,
916 .fd_event = socket_fd_event,
917 .sigchld_event = socket_sigchld_event,
918 .timer_event = socket_timer_event