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"
36 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
37 [SOCKET_DEAD] = UNIT_INACTIVE,
38 [SOCKET_START_PRE] = UNIT_ACTIVATING,
39 [SOCKET_START_POST] = UNIT_ACTIVATING,
40 [SOCKET_LISTENING] = UNIT_ACTIVE,
41 [SOCKET_RUNNING] = UNIT_ACTIVE,
42 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
43 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
44 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
45 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
46 [SOCKET_STOP_POST_SIGTERM] = UNIT_DEACTIVATING,
47 [SOCKET_STOP_POST_SIGKILL] = UNIT_DEACTIVATING,
48 [SOCKET_MAINTAINANCE] = UNIT_INACTIVE,
51 static const char* const state_string_table[_SOCKET_STATE_MAX] = {
52 [SOCKET_DEAD] = "dead",
53 [SOCKET_START_PRE] = "start-pre",
54 [SOCKET_START_POST] = "start-post",
55 [SOCKET_LISTENING] = "listening",
56 [SOCKET_RUNNING] = "running",
57 [SOCKET_STOP_PRE] = "stop-pre",
58 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
59 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
60 [SOCKET_STOP_POST] = "stop-post",
61 [SOCKET_STOP_POST_SIGTERM] = "stop-post-sigterm",
62 [SOCKET_STOP_POST_SIGKILL] = "stop-post-sigkill",
63 [SOCKET_MAINTAINANCE] = "maintainance"
66 static void socket_done(Unit *u) {
67 Socket *s = SOCKET(u);
72 while ((p = s->ports)) {
73 LIST_REMOVE(SocketPort, port, s->ports, p);
81 exec_context_done(&s->exec_context);
82 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
83 s->control_command = NULL;
85 if (s->control_pid > 0) {
86 unit_unwatch_pid(u, s->control_pid);
92 free(s->bind_to_device);
93 s->bind_to_device = NULL;
95 unit_unwatch_timer(u, &s->timer_watch);
98 static void socket_init(Unit *u) {
99 Socket *s = SOCKET(u);
102 assert(u->meta.load_state == UNIT_STUB);
105 s->timer_watch.type = WATCH_INVALID;
106 s->bind_ipv6_only = false;
107 s->backlog = SOMAXCONN;
108 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
109 s->directory_mode = 0755;
110 s->socket_mode = 0666;
115 exec_context_init(&s->exec_context);
118 static int socket_load(Unit *u) {
119 Socket *s = SOCKET(u);
123 assert(u->meta.load_state == UNIT_STUB);
125 if ((r = unit_load_fragment_and_dropin(u)) < 0)
128 /* This is a new unit? Then let's add in some extras */
129 if (u->meta.load_state == UNIT_LOADED) {
131 if ((r = unit_load_related_unit(u, ".service", (Unit**) &s->service)))
134 if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service))) < 0)
137 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
140 if ((r = unit_add_default_cgroup(u)) < 0)
147 static const char* listen_lookup(int type) {
149 if (type == SOCK_STREAM)
150 return "ListenStream";
151 else if (type == SOCK_DGRAM)
152 return "ListenDatagram";
153 else if (type == SOCK_SEQPACKET)
154 return "ListenSequentialPacket";
156 assert_not_reached("Unknown socket type");
160 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
162 static const char* const command_table[_SOCKET_EXEC_COMMAND_MAX] = {
163 [SOCKET_EXEC_START_PRE] = "StartPre",
164 [SOCKET_EXEC_START_POST] = "StartPost",
165 [SOCKET_EXEC_STOP_PRE] = "StopPre",
166 [SOCKET_EXEC_STOP_POST] = "StopPost"
170 Socket *s = SOCKET(u);
178 p2 = strappend(prefix, "\t");
179 prefix2 = p2 ? p2 : prefix;
182 "%sSocket State: %s\n"
183 "%sBindIPv6Only: %s\n"
186 "%sSocketMode: %04o\n"
187 "%sDirectoryMode: %04o\n",
188 prefix, state_string_table[s->state],
189 prefix, yes_no(s->bind_ipv6_only),
191 prefix, kill_mode_to_string(s->kill_mode),
192 prefix, s->socket_mode,
193 prefix, s->directory_mode);
195 if (s->control_pid > 0)
197 "%sControl PID: %llu\n",
198 prefix, (unsigned long long) s->control_pid);
200 if (s->bind_to_device)
202 "%sBindToDevice: %s\n",
203 prefix, s->bind_to_device);
205 LIST_FOREACH(port, p, s->ports) {
207 if (p->type == SOCKET_SOCKET) {
212 if ((r = socket_address_print(&p->address, &k)) < 0)
217 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(p->address.type), k);
220 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
223 exec_context_dump(&s->exec_context, f, prefix);
225 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
226 if (!s->exec_command[c])
229 fprintf(f, "%s→ %s:\n",
230 prefix, command_table[c]);
232 exec_command_dump_list(s->exec_command[c], f, prefix2);
238 static void socket_close_fds(Socket *s) {
243 LIST_FOREACH(port, p, s->ports) {
247 unit_unwatch_fd(UNIT(s), &p->fd_watch);
248 assert_se(close_nointr(p->fd) >= 0);
254 static int socket_open_fds(Socket *s) {
260 LIST_FOREACH(port, p, s->ports) {
265 if (p->type == SOCKET_SOCKET) {
267 if ((r = socket_address_listen(
279 assert(p->type == SOCKET_FIFO);
281 mkdir_parents(p->path, s->directory_mode);
283 if (mkfifo(p->path, s->socket_mode) < 0 && errno != EEXIST) {
288 if ((p->fd = open(p->path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
293 if (fstat(p->fd, &st) < 0) {
298 /* FIXME verify user, access mode */
300 if (!S_ISFIFO(st.st_mode)) {
314 static void socket_unwatch_fds(Socket *s) {
319 LIST_FOREACH(port, p, s->ports) {
323 unit_unwatch_fd(UNIT(s), &p->fd_watch);
327 static int socket_watch_fds(Socket *s) {
333 LIST_FOREACH(port, p, s->ports) {
337 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
344 socket_unwatch_fds(s);
348 static void socket_set_state(Socket *s, SocketState state) {
349 SocketState old_state;
352 old_state = s->state;
355 if (state != SOCKET_START_PRE &&
356 state != SOCKET_START_POST &&
357 state != SOCKET_STOP_PRE &&
358 state != SOCKET_STOP_PRE_SIGTERM &&
359 state != SOCKET_STOP_PRE_SIGKILL &&
360 state != SOCKET_STOP_POST &&
361 state != SOCKET_STOP_POST_SIGTERM &&
362 state != SOCKET_STOP_POST_SIGKILL) {
363 unit_unwatch_timer(UNIT(s), &s->timer_watch);
365 if (s->control_pid > 0) {
366 unit_unwatch_pid(UNIT(s), s->control_pid);
370 s->control_command = NULL;
373 if (state != SOCKET_START_POST &&
374 state != SOCKET_LISTENING &&
375 state != SOCKET_RUNNING &&
376 state != SOCKET_STOP_PRE &&
377 state != SOCKET_STOP_PRE_SIGTERM &&
378 state != SOCKET_STOP_PRE_SIGKILL)
381 if (state != SOCKET_LISTENING)
382 socket_unwatch_fds(s);
384 if (state != old_state)
385 log_debug("%s changed %s → %s", unit_id(UNIT(s)), state_string_table[old_state], state_string_table[state]);
387 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]);
390 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
398 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
401 if ((r = exec_spawn(c,
406 UNIT(s)->meta.cgroup_bondings,
410 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
411 /* FIXME: we need to do something here */
419 unit_unwatch_timer(UNIT(s), &s->timer_watch);
424 static void socket_enter_dead(Socket *s, bool success) {
430 socket_set_state(s, s->failure ? SOCKET_MAINTAINANCE : SOCKET_DEAD);
433 static void socket_enter_stop_post(Socket *s, bool success) {
440 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST]))
441 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
444 socket_set_state(s, SOCKET_STOP_POST);
446 if (!s->control_command)
447 socket_enter_dead(s, true);
452 log_warning("%s failed to run stop-post executable: %s", unit_id(UNIT(s)), strerror(-r));
453 socket_enter_dead(s, false);
456 static void socket_enter_signal(Socket *s, SocketState state, bool success) {
464 if (s->control_pid > 0) {
468 sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_POST_SIGTERM) ? SIGTERM : SIGKILL;
470 if (s->kill_mode == KILL_CONTROL_GROUP) {
472 if ((r = cgroup_bonding_kill_list(UNIT(s)->meta.cgroup_bondings, sig)) < 0) {
473 if (r != -EAGAIN && r != -ESRCH)
480 if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH) {
486 socket_set_state(s, state);
488 if (s->control_pid <= 0)
489 socket_enter_dead(s, true);
494 log_warning("%s failed to kill processes: %s", unit_id(UNIT(s)), strerror(-r));
496 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
497 socket_enter_stop_post(s, false);
499 socket_enter_dead(s, false);
502 static void socket_enter_stop_pre(Socket *s, bool success) {
509 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE]))
510 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
513 socket_set_state(s, SOCKET_STOP_PRE);
515 if (!s->control_command)
516 socket_enter_stop_post(s, true);
521 log_warning("%s failed to run stop-pre executable: %s", unit_id(UNIT(s)), strerror(-r));
522 socket_enter_stop_post(s, false);
525 static void socket_enter_listening(Socket *s) {
529 if ((r = socket_watch_fds(s)) < 0) {
530 log_warning("%s failed to watch sockets: %s", unit_id(UNIT(s)), strerror(-r));
534 socket_set_state(s, SOCKET_LISTENING);
538 socket_enter_stop_pre(s, false);
541 static void socket_enter_start_post(Socket *s) {
545 if ((r = socket_open_fds(s)) < 0) {
546 log_warning("%s failed to listen on sockets: %s", unit_id(UNIT(s)), strerror(-r));
550 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST]))
551 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) {
552 log_warning("%s failed to run start-post executable: %s", unit_id(UNIT(s)), strerror(-r));
556 socket_set_state(s, SOCKET_START_POST);
558 if (!s->control_command)
559 socket_enter_listening(s);
564 socket_enter_stop_pre(s, false);
567 static void socket_enter_start_pre(Socket *s) {
571 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE]))
572 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
575 socket_set_state(s, SOCKET_START_PRE);
577 if (!s->control_command)
578 socket_enter_start_post(s);
583 log_warning("%s failed to run start-pre exectuable: %s", unit_id(UNIT(s)), strerror(-r));
584 socket_enter_dead(s, false);
587 static void socket_enter_running(Socket *s) {
592 if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, NULL)) < 0)
595 socket_set_state(s, SOCKET_RUNNING);
599 log_warning("%s failed to queue socket startup job: %s", unit_id(UNIT(s)), strerror(-r));
600 socket_enter_dead(s, false);
603 static void socket_run_next(Socket *s, bool success) {
607 assert(s->control_command);
608 assert(s->control_command->command_next);
613 s->control_command = s->control_command->command_next;
615 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
621 if (s->state == SOCKET_STOP_PRE)
622 socket_enter_stop_post(s, false);
623 else if (s->state == SOCKET_STOP_POST)
624 socket_enter_dead(s, false);
626 socket_enter_stop_pre(s, false);
629 static int socket_start(Unit *u) {
630 Socket *s = SOCKET(u);
634 /* We cannot fulfill this request right now, try again later
636 if (s->state == SOCKET_STOP_PRE ||
637 s->state == SOCKET_STOP_PRE_SIGKILL ||
638 s->state == SOCKET_STOP_PRE_SIGTERM ||
639 s->state == SOCKET_STOP_POST ||
640 s->state == SOCKET_STOP_POST_SIGTERM ||
641 s->state == SOCKET_STOP_POST_SIGKILL)
644 if (s->state == SOCKET_START_PRE ||
645 s->state == SOCKET_START_POST)
648 /* Cannot run this without the service being around */
649 if (s->service->meta.load_state != UNIT_LOADED)
652 /* If the service is alredy actvie we cannot start the
654 if (s->service->state != SERVICE_DEAD &&
655 s->service->state != SERVICE_MAINTAINANCE &&
656 s->service->state != SERVICE_AUTO_RESTART)
659 assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE);
662 socket_enter_start_pre(s);
666 static int socket_stop(Unit *u) {
667 Socket *s = SOCKET(u);
671 /* We cannot fulfill this request right now, try again later
673 if (s->state == SOCKET_START_PRE ||
674 s->state == SOCKET_START_POST)
678 if (s->state == SOCKET_STOP_PRE ||
679 s->state == SOCKET_STOP_PRE_SIGTERM ||
680 s->state == SOCKET_STOP_PRE_SIGKILL ||
681 s->state == SOCKET_STOP_POST ||
682 s->state == SOCKET_STOP_POST_SIGTERM ||
683 s->state == SOCKET_STOP_POST_SIGTERM)
686 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
688 socket_enter_stop_pre(s, true);
692 static UnitActiveState socket_active_state(Unit *u) {
695 return state_translation_table[SOCKET(u)->state];
698 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
699 Socket *s = SOCKET(u);
703 log_debug("Incoming traffic on %s", unit_id(u));
705 if (events != EPOLLIN)
706 socket_enter_stop_pre(s, false);
708 socket_enter_running(s);
711 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
712 Socket *s = SOCKET(u);
718 success = code == CLD_EXITED && status == 0;
719 s->failure = s->failure || !success;
721 assert(s->control_pid == pid);
722 assert(s->control_command);
724 exec_status_fill(&s->control_command->exec_status, pid, code, status);
727 log_debug("%s control process exited, code=%s status=%i", unit_id(u), sigchld_code_to_string(code), status);
729 if (s->control_command->command_next &&
730 (success || (s->state == SOCKET_STOP_PRE || s->state == SOCKET_STOP_POST))) {
731 log_debug("%s running next command for the state %s", unit_id(u), state_string_table[s->state]);
732 socket_run_next(s, success);
734 /* No further commands for this step, so let's figure
735 * out what to do next */
737 log_debug("%s got final SIGCHLD for state %s", unit_id(u), state_string_table[s->state]);
741 case SOCKET_START_PRE:
743 socket_enter_start_post(s);
745 socket_enter_stop_pre(s, false);
748 case SOCKET_START_POST:
750 socket_enter_listening(s);
752 socket_enter_stop_pre(s, false);
755 case SOCKET_STOP_PRE:
756 case SOCKET_STOP_PRE_SIGTERM:
757 case SOCKET_STOP_PRE_SIGKILL:
758 socket_enter_stop_post(s, success);
761 case SOCKET_STOP_POST:
762 case SOCKET_STOP_POST_SIGTERM:
763 case SOCKET_STOP_POST_SIGKILL:
764 socket_enter_dead(s, success);
768 assert_not_reached("Uh, control process died at wrong time.");
773 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
774 Socket *s = SOCKET(u);
777 assert(elapsed == 1);
778 assert(w == &s->timer_watch);
782 case SOCKET_START_PRE:
783 case SOCKET_START_POST:
784 log_warning("%s starting timed out. Stopping.", unit_id(u));
785 socket_enter_stop_pre(s, false);
788 case SOCKET_STOP_PRE:
789 log_warning("%s stopping timed out. Terminating.", unit_id(u));
790 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, false);
793 case SOCKET_STOP_PRE_SIGTERM:
794 log_warning("%s stopping timed out. Killing.", unit_id(u));
795 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, false);
798 case SOCKET_STOP_PRE_SIGKILL:
799 log_warning("%s still around after SIGKILL. Ignoring.", unit_id(u));
800 socket_enter_stop_post(s, false);
803 case SOCKET_STOP_POST:
804 log_warning("%s stopping timed out (2). Terminating.", unit_id(u));
805 socket_enter_signal(s, SOCKET_STOP_POST_SIGTERM, false);
808 case SOCKET_STOP_POST_SIGTERM:
809 log_warning("%s stopping timed out (2). Killing.", unit_id(u));
810 socket_enter_signal(s, SOCKET_STOP_POST_SIGKILL, false);
813 case SOCKET_STOP_POST_SIGKILL:
814 log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", unit_id(u));
815 socket_enter_dead(s, false);
819 assert_not_reached("Timeout at wrong time.");
823 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
832 /* Called from the service code for requesting our fds */
835 LIST_FOREACH(port, p, s->ports)
839 if (!(rfds = new(int, rn_fds)) < 0)
843 LIST_FOREACH(port, p, s->ports)
855 void socket_notify_service_dead(Socket *s) {
858 /* The service is dead. Dang. */
860 if (s->state == SOCKET_RUNNING) {
861 log_debug("%s got notified about service death.", unit_id(UNIT(s)));
862 socket_enter_listening(s);
866 const UnitVTable socket_vtable = {
875 .start = socket_start,
878 .active_state = socket_active_state,
880 .fd_event = socket_fd_event,
881 .sigchld_event = socket_sigchld_event,
882 .timer_event = socket_timer_event