1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
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 Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser 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>
29 #include <arpa/inet.h>
34 #include "netinet/tcp.h"
36 #include "load-dropin.h"
37 #include "load-fragment.h"
40 #include "path-util.h"
41 #include "unit-name.h"
42 #include "unit-printf.h"
43 #include "dbus-socket.h"
46 #include "bus-errors.h"
48 #include "exit-status.h"
51 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
52 [SOCKET_DEAD] = UNIT_INACTIVE,
53 [SOCKET_START_PRE] = UNIT_ACTIVATING,
54 [SOCKET_START_POST] = UNIT_ACTIVATING,
55 [SOCKET_LISTENING] = UNIT_ACTIVE,
56 [SOCKET_RUNNING] = UNIT_ACTIVE,
57 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
58 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
59 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
60 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
61 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
62 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
63 [SOCKET_FAILED] = UNIT_FAILED
66 static void socket_init(Unit *u) {
67 Socket *s = SOCKET(u);
70 assert(u->load_state == UNIT_STUB);
72 s->backlog = SOMAXCONN;
73 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
74 s->directory_mode = 0755;
75 s->socket_mode = 0666;
77 s->max_connections = 64;
84 exec_context_init(&s->exec_context);
85 s->exec_context.std_output = u->manager->default_std_output;
86 s->exec_context.std_error = u->manager->default_std_error;
87 kill_context_init(&s->kill_context);
89 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
92 static void socket_unwatch_control_pid(Socket *s) {
95 if (s->control_pid <= 0)
98 unit_unwatch_pid(UNIT(s), s->control_pid);
102 static void socket_done(Unit *u) {
103 Socket *s = SOCKET(u);
108 while ((p = s->ports)) {
109 LIST_REMOVE(SocketPort, port, s->ports, p);
112 unit_unwatch_fd(UNIT(s), &p->fd_watch);
113 close_nointr_nofail(p->fd);
120 exec_context_done(&s->exec_context);
121 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
122 s->control_command = NULL;
124 socket_unwatch_control_pid(s);
126 unit_ref_unset(&s->service);
128 free(s->tcp_congestion);
129 s->tcp_congestion = NULL;
131 free(s->bind_to_device);
132 s->bind_to_device = NULL;
134 unit_unwatch_timer(u, &s->timer_watch);
137 static int socket_instantiate_service(Socket *s) {
144 /* This fills in s->service if it isn't filled in yet. For
145 * Accept=yes sockets we create the next connection service
146 * here. For Accept=no this is mostly a NOP since the service
147 * is figured out at load time anyway. */
149 if (UNIT_DEREF(s->service))
154 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
157 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
163 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
169 #ifdef HAVE_SYSV_COMPAT
170 if (SERVICE(u)->is_sysv) {
171 log_error("Using SysV services for socket activation is not supported. Refusing.");
177 unit_ref_set(&s->service, u);
179 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
182 static bool have_non_accept_socket(Socket *s) {
190 LIST_FOREACH(port, p, s->ports) {
192 if (p->type != SOCKET_SOCKET)
195 if (!socket_address_can_accept(&p->address))
202 static int socket_verify(Socket *s) {
205 if (UNIT(s)->load_state != UNIT_LOADED)
209 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
213 if (s->accept && have_non_accept_socket(s)) {
214 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
218 if (s->accept && s->max_connections <= 0) {
219 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
223 if (s->accept && UNIT_DEREF(s->service)) {
224 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
228 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
229 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
236 static bool socket_needs_mount(Socket *s, const char *prefix) {
241 LIST_FOREACH(port, p, s->ports) {
243 if (p->type == SOCKET_SOCKET) {
244 if (socket_address_needs_mount(&p->address, prefix))
246 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
247 if (path_startswith(p->path, prefix))
255 int socket_add_one_mount_link(Socket *s, Mount *m) {
261 if (UNIT(s)->load_state != UNIT_LOADED ||
262 UNIT(m)->load_state != UNIT_LOADED)
265 if (!socket_needs_mount(s, m->where))
268 if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
274 static int socket_add_mount_links(Socket *s) {
280 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
281 if ((r = socket_add_one_mount_link(s, MOUNT(other))) < 0)
287 static int socket_add_device_link(Socket *s) {
293 if (!s->bind_to_device)
296 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
299 r = unit_add_node_link(UNIT(s), t, false);
305 static int socket_add_default_dependencies(Socket *s) {
309 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
310 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
313 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
317 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
320 static bool socket_has_exec(Socket *s) {
324 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
325 if (s->exec_command[i])
331 static int socket_load(Unit *u) {
332 Socket *s = SOCKET(u);
336 assert(u->load_state == UNIT_STUB);
338 if ((r = unit_load_fragment_and_dropin(u)) < 0)
341 /* This is a new unit? Then let's add in some extras */
342 if (u->load_state == UNIT_LOADED) {
344 if (have_non_accept_socket(s)) {
346 if (!UNIT_DEREF(s->service)) {
349 r = unit_load_related_unit(u, ".service", &x);
353 unit_ref_set(&s->service, x);
356 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
361 if ((r = socket_add_mount_links(s)) < 0)
364 if ((r = socket_add_device_link(s)) < 0)
367 if (socket_has_exec(s))
368 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
371 if ((r = unit_add_default_cgroups(u)) < 0)
374 if (UNIT(s)->default_dependencies)
375 if ((r = socket_add_default_dependencies(s)) < 0)
378 r = unit_exec_context_defaults(u, &s->exec_context);
383 return socket_verify(s);
386 static const char* listen_lookup(int family, int type) {
388 if (family == AF_NETLINK)
389 return "ListenNetlink";
391 if (type == SOCK_STREAM)
392 return "ListenStream";
393 else if (type == SOCK_DGRAM)
394 return "ListenDatagram";
395 else if (type == SOCK_SEQPACKET)
396 return "ListenSequentialPacket";
398 assert_not_reached("Unknown socket type");
402 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
405 Socket *s = SOCKET(u);
413 p2 = strappend(prefix, "\t");
414 prefix2 = p2 ? p2 : prefix;
417 "%sSocket State: %s\n"
419 "%sBindIPv6Only: %s\n"
421 "%sSocketMode: %04o\n"
422 "%sDirectoryMode: %04o\n"
425 "%sTransparent: %s\n"
427 "%sPassCredentials: %s\n"
428 "%sPassSecurity: %s\n"
429 "%sTCPCongestion: %s\n",
430 prefix, socket_state_to_string(s->state),
431 prefix, socket_result_to_string(s->result),
432 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
434 prefix, s->socket_mode,
435 prefix, s->directory_mode,
436 prefix, yes_no(s->keep_alive),
437 prefix, yes_no(s->free_bind),
438 prefix, yes_no(s->transparent),
439 prefix, yes_no(s->broadcast),
440 prefix, yes_no(s->pass_cred),
441 prefix, yes_no(s->pass_sec),
442 prefix, strna(s->tcp_congestion));
444 if (s->control_pid > 0)
446 "%sControl PID: %lu\n",
447 prefix, (unsigned long) s->control_pid);
449 if (s->bind_to_device)
451 "%sBindToDevice: %s\n",
452 prefix, s->bind_to_device);
457 "%sNConnections: %u\n"
458 "%sMaxConnections: %u\n",
459 prefix, s->n_accepted,
460 prefix, s->n_connections,
461 prefix, s->max_connections);
463 if (s->priority >= 0)
466 prefix, s->priority);
468 if (s->receive_buffer > 0)
470 "%sReceiveBuffer: %zu\n",
471 prefix, s->receive_buffer);
473 if (s->send_buffer > 0)
475 "%sSendBuffer: %zu\n",
476 prefix, s->send_buffer);
488 if (s->pipe_size > 0)
491 prefix, s->pipe_size);
498 if (s->mq_maxmsg > 0)
500 "%sMessageQueueMaxMessages: %li\n",
501 prefix, s->mq_maxmsg);
503 if (s->mq_msgsize > 0)
505 "%sMessageQueueMessageSize: %li\n",
506 prefix, s->mq_msgsize);
508 LIST_FOREACH(port, p, s->ports) {
510 if (p->type == SOCKET_SOCKET) {
515 if ((r = socket_address_print(&p->address, &k)) < 0)
520 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
522 } else if (p->type == SOCKET_SPECIAL)
523 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
524 else if (p->type == SOCKET_MQUEUE)
525 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
527 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
530 exec_context_dump(&s->exec_context, f, prefix);
531 kill_context_dump(&s->kill_context, f, prefix);
533 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
534 if (!s->exec_command[c])
537 fprintf(f, "%s-> %s:\n",
538 prefix, socket_exec_command_to_string(c));
540 exec_command_dump_list(s->exec_command[c], f, prefix2);
546 static int instance_from_socket(int fd, unsigned nr, char **instance) {
551 struct sockaddr_un un;
552 struct sockaddr_in in;
553 struct sockaddr_in6 in6;
554 struct sockaddr_storage storage;
561 if (getsockname(fd, &local.sa, &l) < 0)
565 if (getpeername(fd, &remote.sa, &l) < 0)
568 switch (local.sa.sa_family) {
572 a = ntohl(local.in.sin_addr.s_addr),
573 b = ntohl(remote.in.sin_addr.s_addr);
576 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
578 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
579 ntohs(local.in.sin_port),
580 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
581 ntohs(remote.in.sin_port)) < 0)
588 static const unsigned char ipv4_prefix[] = {
589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
592 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
593 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
595 *a = local.in6.sin6_addr.s6_addr+12,
596 *b = remote.in6.sin6_addr.s6_addr+12;
599 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
601 a[0], a[1], a[2], a[3],
602 ntohs(local.in6.sin6_port),
603 b[0], b[1], b[2], b[3],
604 ntohs(remote.in6.sin6_port)) < 0)
607 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
612 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
613 ntohs(local.in6.sin6_port),
614 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
615 ntohs(remote.in6.sin6_port)) < 0)
626 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
632 (unsigned long) ucred.pid,
633 (unsigned long) ucred.uid) < 0)
640 assert_not_reached("Unhandled socket type.");
647 static void socket_close_fds(Socket *s) {
652 LIST_FOREACH(port, p, s->ports) {
656 unit_unwatch_fd(UNIT(s), &p->fd_watch);
657 close_nointr_nofail(p->fd);
659 /* One little note: we should never delete any sockets
660 * in the file system here! After all some other
661 * process we spawned might still have a reference of
662 * this fd and wants to continue to use it. Therefore
663 * we delete sockets in the file system before we
664 * create a new one, not after we stopped using
671 static void socket_apply_socket_options(Socket *s, int fd) {
676 int b = s->keep_alive;
677 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
678 log_warning("SO_KEEPALIVE failed: %m");
683 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
684 log_warning("SO_BROADCAST failed: %m");
689 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
690 log_warning("SO_PASSCRED failed: %m");
695 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
696 log_warning("SO_PASSSEC failed: %m");
699 if (s->priority >= 0)
700 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
701 log_warning("SO_PRIORITY failed: %m");
703 if (s->receive_buffer > 0) {
704 int value = (int) s->receive_buffer;
706 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
708 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
709 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
710 log_warning("SO_RCVBUF failed: %m");
713 if (s->send_buffer > 0) {
714 int value = (int) s->send_buffer;
715 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
716 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
717 log_warning("SO_SNDBUF failed: %m");
721 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
722 log_warning("SO_MARK failed: %m");
725 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
726 log_warning("IP_TOS failed: %m");
728 if (s->ip_ttl >= 0) {
731 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
733 if (socket_ipv6_is_supported())
734 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
737 errno = EAFNOSUPPORT;
741 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
744 if (s->tcp_congestion)
745 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
746 log_warning("TCP_CONGESTION failed: %m");
749 static void socket_apply_fifo_options(Socket *s, int fd) {
753 if (s->pipe_size > 0)
754 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
755 log_warning("F_SETPIPE_SZ: %m");
758 static int fifo_address_create(
760 mode_t directory_mode,
771 mkdir_parents_label(path, directory_mode);
773 r = label_context_set(path, S_IFIFO);
777 /* Enforce the right access mode for the fifo */
778 old_mask = umask(~ socket_mode);
780 /* Include the original umask in our mask */
781 umask(~socket_mode | old_mask);
783 r = mkfifo(path, socket_mode);
786 if (r < 0 && errno != EEXIST) {
791 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
796 label_context_clear();
798 if (fstat(fd, &st) < 0) {
803 if (!S_ISFIFO(st.st_mode) ||
804 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
805 st.st_uid != getuid() ||
806 st.st_gid != getgid()) {
816 label_context_clear();
819 close_nointr_nofail(fd);
824 static int special_address_create(
834 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
839 if (fstat(fd, &st) < 0) {
844 /* Check whether this is a /proc, /sys or /dev file or char device */
845 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
855 close_nointr_nofail(fd);
860 static int mq_address_create(
870 struct mq_attr _attr, *attr = NULL;
875 if (maxmsg > 0 && msgsize > 0) {
877 _attr.mq_flags = O_NONBLOCK;
878 _attr.mq_maxmsg = maxmsg;
879 _attr.mq_msgsize = msgsize;
883 /* Enforce the right access mode for the mq */
884 old_mask = umask(~ mq_mode);
886 /* Include the original umask in our mask */
887 umask(~mq_mode | old_mask);
889 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
897 if (fstat(fd, &st) < 0) {
902 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
903 st.st_uid != getuid() ||
904 st.st_gid != getgid()) {
915 close_nointr_nofail(fd);
920 static int socket_open_fds(Socket *s) {
924 bool know_label = false;
928 LIST_FOREACH(port, p, s->ports) {
933 if (p->type == SOCKET_SOCKET) {
937 if ((r = socket_instantiate_service(s)) < 0)
940 if (UNIT_DEREF(s->service) &&
941 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
942 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
953 if ((r = socket_address_listen(
966 socket_apply_socket_options(s, p->fd);
968 } else if (p->type == SOCKET_SPECIAL) {
970 if ((r = special_address_create(
975 } else if (p->type == SOCKET_FIFO) {
977 if ((r = fifo_address_create(
984 socket_apply_fifo_options(s, p->fd);
985 } else if (p->type == SOCKET_MQUEUE) {
987 if ((r = mq_address_create(
995 assert_not_reached("Unknown port type");
1002 socket_close_fds(s);
1007 static void socket_unwatch_fds(Socket *s) {
1012 LIST_FOREACH(port, p, s->ports) {
1016 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1020 static int socket_watch_fds(Socket *s) {
1026 LIST_FOREACH(port, p, s->ports) {
1030 p->fd_watch.socket_accept =
1032 p->type == SOCKET_SOCKET &&
1033 socket_address_can_accept(&p->address);
1035 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1042 socket_unwatch_fds(s);
1046 static void socket_set_state(Socket *s, SocketState state) {
1047 SocketState old_state;
1050 old_state = s->state;
1053 if (state != SOCKET_START_PRE &&
1054 state != SOCKET_START_POST &&
1055 state != SOCKET_STOP_PRE &&
1056 state != SOCKET_STOP_PRE_SIGTERM &&
1057 state != SOCKET_STOP_PRE_SIGKILL &&
1058 state != SOCKET_STOP_POST &&
1059 state != SOCKET_FINAL_SIGTERM &&
1060 state != SOCKET_FINAL_SIGKILL) {
1061 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1062 socket_unwatch_control_pid(s);
1063 s->control_command = NULL;
1064 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1067 if (state != SOCKET_LISTENING)
1068 socket_unwatch_fds(s);
1070 if (state != SOCKET_START_POST &&
1071 state != SOCKET_LISTENING &&
1072 state != SOCKET_RUNNING &&
1073 state != SOCKET_STOP_PRE &&
1074 state != SOCKET_STOP_PRE_SIGTERM &&
1075 state != SOCKET_STOP_PRE_SIGKILL)
1076 socket_close_fds(s);
1078 if (state != old_state)
1079 log_debug("%s changed %s -> %s",
1081 socket_state_to_string(old_state),
1082 socket_state_to_string(state));
1084 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1087 static int socket_coldplug(Unit *u) {
1088 Socket *s = SOCKET(u);
1092 assert(s->state == SOCKET_DEAD);
1094 if (s->deserialized_state != s->state) {
1096 if (s->deserialized_state == SOCKET_START_PRE ||
1097 s->deserialized_state == SOCKET_START_POST ||
1098 s->deserialized_state == SOCKET_STOP_PRE ||
1099 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1100 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1101 s->deserialized_state == SOCKET_STOP_POST ||
1102 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1103 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1105 if (s->control_pid <= 0)
1108 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1111 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1115 if (s->deserialized_state == SOCKET_START_POST ||
1116 s->deserialized_state == SOCKET_LISTENING ||
1117 s->deserialized_state == SOCKET_RUNNING ||
1118 s->deserialized_state == SOCKET_STOP_PRE ||
1119 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1120 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1121 if ((r = socket_open_fds(s)) < 0)
1124 if (s->deserialized_state == SOCKET_LISTENING)
1125 if ((r = socket_watch_fds(s)) < 0)
1128 socket_set_state(s, s->deserialized_state);
1134 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1143 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1146 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1155 UNIT(s)->manager->environment,
1159 UNIT(s)->manager->confirm_spawn,
1160 UNIT(s)->cgroup_bondings,
1161 UNIT(s)->cgroup_attributes,
1171 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1172 /* FIXME: we need to do something here */
1180 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1185 static void socket_enter_dead(Socket *s, SocketResult f) {
1188 if (f != SOCKET_SUCCESS)
1191 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1194 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1196 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1200 if (f != SOCKET_SUCCESS)
1203 socket_unwatch_control_pid(s);
1205 s->control_command_id = SOCKET_EXEC_STOP_POST;
1207 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1208 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1211 socket_set_state(s, SOCKET_STOP_POST);
1213 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1218 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1219 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1222 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1224 Set *pid_set = NULL;
1225 bool wait_for_exit = false;
1229 if (f != SOCKET_SUCCESS)
1232 if (s->kill_context.kill_mode != KILL_NONE) {
1233 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1235 if (s->control_pid > 0) {
1236 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1238 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1240 wait_for_exit = true;
1243 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1245 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1250 /* Exclude the control pid from being killed via the cgroup */
1251 if (s->control_pid > 0)
1252 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1255 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1257 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1258 log_warning("Failed to kill control group: %s", strerror(-r));
1260 wait_for_exit = true;
1267 if (wait_for_exit) {
1268 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1271 socket_set_state(s, state);
1272 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1273 socket_enter_stop_post(s, SOCKET_SUCCESS);
1275 socket_enter_dead(s, SOCKET_SUCCESS);
1280 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1282 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1283 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1285 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1291 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1295 if (f != SOCKET_SUCCESS)
1298 socket_unwatch_control_pid(s);
1300 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1302 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1303 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1306 socket_set_state(s, SOCKET_STOP_PRE);
1308 socket_enter_stop_post(s, SOCKET_SUCCESS);
1313 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1314 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1317 static void socket_enter_listening(Socket *s) {
1321 r = socket_watch_fds(s);
1323 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1327 socket_set_state(s, SOCKET_LISTENING);
1331 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1334 static void socket_enter_start_post(Socket *s) {
1338 r = socket_open_fds(s);
1340 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1344 socket_unwatch_control_pid(s);
1346 s->control_command_id = SOCKET_EXEC_START_POST;
1348 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1349 r = socket_spawn(s, s->control_command, &s->control_pid);
1351 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1355 socket_set_state(s, SOCKET_START_POST);
1357 socket_enter_listening(s);
1362 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1365 static void socket_enter_start_pre(Socket *s) {
1369 socket_unwatch_control_pid(s);
1371 s->control_command_id = SOCKET_EXEC_START_PRE;
1373 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1374 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1377 socket_set_state(s, SOCKET_START_PRE);
1379 socket_enter_start_post(s);
1384 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1385 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1388 static void socket_enter_running(Socket *s, int cfd) {
1393 dbus_error_init(&error);
1395 /* We don't take connections anymore if we are supposed to
1396 * shut down anyway */
1397 if (unit_pending_inactive(UNIT(s))) {
1398 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1401 close_nointr_nofail(cfd);
1403 /* Flush all sockets by closing and reopening them */
1404 socket_close_fds(s);
1406 r = socket_watch_fds(s);
1408 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1409 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1419 bool pending = false;
1421 /* If there's already a start pending don't bother to
1423 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1424 if (unit_pending_active(u)) {
1430 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1435 socket_set_state(s, SOCKET_RUNNING);
1437 char *prefix, *instance = NULL, *name;
1440 if (s->n_connections >= s->max_connections) {
1441 log_warning("Too many incoming connections (%u)", s->n_connections);
1442 close_nointr_nofail(cfd);
1446 r = socket_instantiate_service(s);
1450 r = instance_from_socket(cfd, s->n_accepted, &instance);
1455 /* ENOTCONN is legitimate if TCP RST was received.
1456 * This connection is over, but the socket unit lives on. */
1457 close_nointr_nofail(cfd);
1461 prefix = unit_name_to_prefix(UNIT(s)->id);
1468 name = unit_name_build(prefix, instance, ".service");
1477 r = unit_add_name(UNIT_DEREF(s->service), name);
1483 service = SERVICE(UNIT_DEREF(s->service));
1484 unit_ref_unset(&s->service);
1487 UNIT(service)->no_gc = false;
1489 unit_choose_id(UNIT(service), name);
1492 r = service_set_socket_fd(service, cfd, s);
1497 s->n_connections ++;
1499 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1503 /* Notify clients about changed counters */
1504 unit_add_to_dbus_queue(UNIT(s));
1510 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1511 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1514 close_nointr_nofail(cfd);
1516 dbus_error_free(&error);
1519 static void socket_run_next(Socket *s) {
1523 assert(s->control_command);
1524 assert(s->control_command->command_next);
1526 socket_unwatch_control_pid(s);
1528 s->control_command = s->control_command->command_next;
1530 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1536 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1538 if (s->state == SOCKET_START_POST)
1539 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1540 else if (s->state == SOCKET_STOP_POST)
1541 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1543 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1546 static int socket_start(Unit *u) {
1547 Socket *s = SOCKET(u);
1551 /* We cannot fulfill this request right now, try again later
1553 if (s->state == SOCKET_STOP_PRE ||
1554 s->state == SOCKET_STOP_PRE_SIGKILL ||
1555 s->state == SOCKET_STOP_PRE_SIGTERM ||
1556 s->state == SOCKET_STOP_POST ||
1557 s->state == SOCKET_FINAL_SIGTERM ||
1558 s->state == SOCKET_FINAL_SIGKILL)
1561 if (s->state == SOCKET_START_PRE ||
1562 s->state == SOCKET_START_POST)
1565 /* Cannot run this without the service being around */
1566 if (UNIT_DEREF(s->service)) {
1569 service = SERVICE(UNIT_DEREF(s->service));
1571 if (UNIT(service)->load_state != UNIT_LOADED) {
1572 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1576 /* If the service is already active we cannot start the
1578 if (service->state != SERVICE_DEAD &&
1579 service->state != SERVICE_FAILED &&
1580 service->state != SERVICE_AUTO_RESTART) {
1581 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1585 #ifdef HAVE_SYSV_COMPAT
1586 if (service->is_sysv) {
1587 log_error("Using SysV services for socket activation is not supported. Refusing.");
1593 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1595 s->result = SOCKET_SUCCESS;
1596 socket_enter_start_pre(s);
1600 static int socket_stop(Unit *u) {
1601 Socket *s = SOCKET(u);
1606 if (s->state == SOCKET_STOP_PRE ||
1607 s->state == SOCKET_STOP_PRE_SIGTERM ||
1608 s->state == SOCKET_STOP_PRE_SIGKILL ||
1609 s->state == SOCKET_STOP_POST ||
1610 s->state == SOCKET_FINAL_SIGTERM ||
1611 s->state == SOCKET_FINAL_SIGKILL)
1614 /* If there's already something running we go directly into
1616 if (s->state == SOCKET_START_PRE ||
1617 s->state == SOCKET_START_POST) {
1618 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1622 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1624 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1628 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1629 Socket *s = SOCKET(u);
1637 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1638 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1639 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1641 if (s->control_pid > 0)
1642 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1644 if (s->control_command_id >= 0)
1645 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1647 LIST_FOREACH(port, p, s->ports) {
1653 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1656 if (p->type == SOCKET_SOCKET) {
1659 if ((r = socket_address_print(&p->address, &t)) < 0)
1662 if (socket_address_family(&p->address) == AF_NETLINK)
1663 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1665 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1667 } else if (p->type == SOCKET_SPECIAL)
1668 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1670 assert(p->type == SOCKET_FIFO);
1671 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1678 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1679 Socket *s = SOCKET(u);
1686 if (streq(key, "state")) {
1689 if ((state = socket_state_from_string(value)) < 0)
1690 log_debug("Failed to parse state value %s", value);
1692 s->deserialized_state = state;
1693 } else if (streq(key, "result")) {
1696 f = socket_result_from_string(value);
1698 log_debug("Failed to parse result value %s", value);
1699 else if (f != SOCKET_SUCCESS)
1702 } else if (streq(key, "n-accepted")) {
1705 if (safe_atou(value, &k) < 0)
1706 log_debug("Failed to parse n-accepted value %s", value);
1709 } else if (streq(key, "control-pid")) {
1712 if (parse_pid(value, &pid) < 0)
1713 log_debug("Failed to parse control-pid value %s", value);
1715 s->control_pid = pid;
1716 } else if (streq(key, "control-command")) {
1717 SocketExecCommand id;
1719 if ((id = socket_exec_command_from_string(value)) < 0)
1720 log_debug("Failed to parse exec-command value %s", value);
1722 s->control_command_id = id;
1723 s->control_command = s->exec_command[id];
1725 } else if (streq(key, "fifo")) {
1729 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1730 log_debug("Failed to parse fifo value %s", value);
1733 LIST_FOREACH(port, p, s->ports)
1734 if (p->type == SOCKET_FIFO &&
1735 streq_ptr(p->path, value+skip))
1740 close_nointr_nofail(p->fd);
1741 p->fd = fdset_remove(fds, fd);
1745 } else if (streq(key, "special")) {
1749 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1750 log_debug("Failed to parse special value %s", value);
1753 LIST_FOREACH(port, p, s->ports)
1754 if (p->type == SOCKET_SPECIAL &&
1755 streq_ptr(p->path, value+skip))
1760 close_nointr_nofail(p->fd);
1761 p->fd = fdset_remove(fds, fd);
1765 } else if (streq(key, "socket")) {
1766 int fd, type, skip = 0;
1769 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1770 log_debug("Failed to parse socket value %s", value);
1773 LIST_FOREACH(port, p, s->ports)
1774 if (socket_address_is(&p->address, value+skip, type))
1779 close_nointr_nofail(p->fd);
1780 p->fd = fdset_remove(fds, fd);
1784 } else if (streq(key, "netlink")) {
1788 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1789 log_debug("Failed to parse socket value %s", value);
1792 LIST_FOREACH(port, p, s->ports)
1793 if (socket_address_is_netlink(&p->address, value+skip))
1798 close_nointr_nofail(p->fd);
1799 p->fd = fdset_remove(fds, fd);
1804 log_debug("Unknown serialization key '%s'", key);
1809 static UnitActiveState socket_active_state(Unit *u) {
1812 return state_translation_table[SOCKET(u)->state];
1815 static const char *socket_sub_state_to_string(Unit *u) {
1818 return socket_state_to_string(SOCKET(u)->state);
1821 static bool socket_check_gc(Unit *u) {
1822 Socket *s = SOCKET(u);
1826 return s->n_connections > 0;
1829 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1830 Socket *s = SOCKET(u);
1836 if (s->state != SOCKET_LISTENING)
1839 log_debug("Incoming traffic on %s", u->id);
1841 if (events != EPOLLIN) {
1843 if (events & EPOLLHUP)
1844 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1846 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1851 if (w->socket_accept) {
1854 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1860 log_error("Failed to accept socket: %m");
1867 socket_apply_socket_options(s, cfd);
1870 socket_enter_running(s, cfd);
1874 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1877 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1878 Socket *s = SOCKET(u);
1884 if (pid != s->control_pid)
1889 if (is_clean_exit(code, status, NULL))
1891 else if (code == CLD_EXITED)
1892 f = SOCKET_FAILURE_EXIT_CODE;
1893 else if (code == CLD_KILLED)
1894 f = SOCKET_FAILURE_SIGNAL;
1895 else if (code == CLD_DUMPED)
1896 f = SOCKET_FAILURE_CORE_DUMP;
1898 assert_not_reached("Unknown code");
1900 if (s->control_command) {
1901 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1903 if (s->control_command->ignore)
1907 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1908 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1910 if (f != SOCKET_SUCCESS)
1913 if (s->control_command &&
1914 s->control_command->command_next &&
1915 f == SOCKET_SUCCESS) {
1917 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1920 s->control_command = NULL;
1921 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1923 /* No further commands for this step, so let's figure
1924 * out what to do next */
1926 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1930 case SOCKET_START_PRE:
1931 if (f == SOCKET_SUCCESS)
1932 socket_enter_start_post(s);
1934 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1937 case SOCKET_START_POST:
1938 if (f == SOCKET_SUCCESS)
1939 socket_enter_listening(s);
1941 socket_enter_stop_pre(s, f);
1944 case SOCKET_STOP_PRE:
1945 case SOCKET_STOP_PRE_SIGTERM:
1946 case SOCKET_STOP_PRE_SIGKILL:
1947 socket_enter_stop_post(s, f);
1950 case SOCKET_STOP_POST:
1951 case SOCKET_FINAL_SIGTERM:
1952 case SOCKET_FINAL_SIGKILL:
1953 socket_enter_dead(s, f);
1957 assert_not_reached("Uh, control process died at wrong time.");
1961 /* Notify clients about changed exit status */
1962 unit_add_to_dbus_queue(u);
1965 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1966 Socket *s = SOCKET(u);
1969 assert(elapsed == 1);
1970 assert(w == &s->timer_watch);
1974 case SOCKET_START_PRE:
1975 log_warning("%s starting timed out. Terminating.", u->id);
1976 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1979 case SOCKET_START_POST:
1980 log_warning("%s starting timed out. Stopping.", u->id);
1981 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1984 case SOCKET_STOP_PRE:
1985 log_warning("%s stopping timed out. Terminating.", u->id);
1986 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1989 case SOCKET_STOP_PRE_SIGTERM:
1990 if (s->kill_context.send_sigkill) {
1991 log_warning("%s stopping timed out. Killing.", u->id);
1992 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1994 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1995 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1999 case SOCKET_STOP_PRE_SIGKILL:
2000 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2001 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2004 case SOCKET_STOP_POST:
2005 log_warning("%s stopping timed out (2). Terminating.", u->id);
2006 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2009 case SOCKET_FINAL_SIGTERM:
2010 if (s->kill_context.send_sigkill) {
2011 log_warning("%s stopping timed out (2). Killing.", u->id);
2012 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2014 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2015 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2019 case SOCKET_FINAL_SIGKILL:
2020 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2021 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2025 assert_not_reached("Timeout at wrong time.");
2029 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2038 /* Called from the service code for requesting our fds */
2041 LIST_FOREACH(port, p, s->ports)
2051 if (!(rfds = new(int, rn_fds)))
2055 LIST_FOREACH(port, p, s->ports)
2059 assert(k == rn_fds);
2067 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2070 /* The service is dead. Dang!
2072 * This is strictly for one-instance-for-all-connections
2075 if (s->state == SOCKET_RUNNING) {
2076 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2077 if (failed_permanent)
2078 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2080 socket_enter_listening(s);
2084 void socket_connection_unref(Socket *s) {
2087 /* The service is dead. Yay!
2089 * This is strictly for one-instance-per-connection
2092 assert(s->n_connections > 0);
2095 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2098 static void socket_reset_failed(Unit *u) {
2099 Socket *s = SOCKET(u);
2103 if (s->state == SOCKET_FAILED)
2104 socket_set_state(s, SOCKET_DEAD);
2106 s->result = SOCKET_SUCCESS;
2109 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2110 Socket *s = SOCKET(u);
2112 Set *pid_set = NULL;
2116 if (who == KILL_MAIN) {
2117 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2121 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2122 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2126 if (who == KILL_CONTROL || who == KILL_ALL)
2127 if (s->control_pid > 0)
2128 if (kill(s->control_pid, signo) < 0)
2131 if (who == KILL_ALL) {
2134 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2138 /* Exclude the control pid from being killed via the cgroup */
2139 if (s->control_pid > 0) {
2140 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2147 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2148 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2159 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2160 [SOCKET_DEAD] = "dead",
2161 [SOCKET_START_PRE] = "start-pre",
2162 [SOCKET_START_POST] = "start-post",
2163 [SOCKET_LISTENING] = "listening",
2164 [SOCKET_RUNNING] = "running",
2165 [SOCKET_STOP_PRE] = "stop-pre",
2166 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2167 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2168 [SOCKET_STOP_POST] = "stop-post",
2169 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2170 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2171 [SOCKET_FAILED] = "failed"
2174 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2176 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2177 [SOCKET_EXEC_START_PRE] = "StartPre",
2178 [SOCKET_EXEC_START_POST] = "StartPost",
2179 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2180 [SOCKET_EXEC_STOP_POST] = "StopPost"
2183 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2185 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2186 [SOCKET_SUCCESS] = "success",
2187 [SOCKET_FAILURE_RESOURCES] = "resources",
2188 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2189 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2190 [SOCKET_FAILURE_SIGNAL] = "signal",
2191 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2192 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2195 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2197 const UnitVTable socket_vtable = {
2198 .object_size = sizeof(Socket),
2199 .exec_context_offset = offsetof(Socket, exec_context),
2206 .init = socket_init,
2207 .done = socket_done,
2208 .load = socket_load,
2210 .kill = socket_kill,
2212 .coldplug = socket_coldplug,
2214 .dump = socket_dump,
2216 .start = socket_start,
2217 .stop = socket_stop,
2219 .serialize = socket_serialize,
2220 .deserialize_item = socket_deserialize_item,
2222 .active_state = socket_active_state,
2223 .sub_state_to_string = socket_sub_state_to_string,
2225 .check_gc = socket_check_gc,
2227 .fd_event = socket_fd_event,
2228 .sigchld_event = socket_sigchld_event,
2229 .timer_event = socket_timer_event,
2231 .reset_failed = socket_reset_failed,
2233 .bus_interface = "org.freedesktop.systemd1.Socket",
2234 .bus_message_handler = bus_socket_message_handler,
2235 .bus_invalidating_properties = bus_socket_invalidating_properties,
2237 .status_message_formats = {
2238 /*.starting_stopping = {
2239 [0] = "Starting socket %s...",
2240 [1] = "Stopping socket %s...",
2242 .finished_start_job = {
2243 [JOB_DONE] = "Listening on %s.",
2244 [JOB_FAILED] = "Failed to listen on %s.",
2245 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2246 [JOB_TIMEOUT] = "Timed out starting %s.",
2248 .finished_stop_job = {
2249 [JOB_DONE] = "Closed %s.",
2250 [JOB_FAILED] = "Failed stopping %s.",
2251 [JOB_TIMEOUT] = "Timed out stopping %s.",