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>
32 #include <attr/xattr.h>
37 #include "netinet/tcp.h"
39 #include "load-dropin.h"
40 #include "load-fragment.h"
43 #include "path-util.h"
44 #include "unit-name.h"
45 #include "unit-printf.h"
46 #include "dbus-socket.h"
49 #include "dbus-common.h"
51 #include "exit-status.h"
53 #include "smack-util.h"
55 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
56 [SOCKET_DEAD] = UNIT_INACTIVE,
57 [SOCKET_START_PRE] = UNIT_ACTIVATING,
58 [SOCKET_START_POST] = UNIT_ACTIVATING,
59 [SOCKET_LISTENING] = UNIT_ACTIVE,
60 [SOCKET_RUNNING] = UNIT_ACTIVE,
61 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
64 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
65 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
66 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
67 [SOCKET_FAILED] = UNIT_FAILED
70 static void socket_init(Unit *u) {
71 Socket *s = SOCKET(u);
74 assert(u->load_state == UNIT_STUB);
76 s->backlog = SOMAXCONN;
77 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
78 s->directory_mode = 0755;
79 s->socket_mode = 0666;
81 s->max_connections = 64;
88 exec_context_init(&s->exec_context);
89 s->exec_context.std_output = u->manager->default_std_output;
90 s->exec_context.std_error = u->manager->default_std_error;
91 kill_context_init(&s->kill_context);
92 cgroup_context_init(&s->cgroup_context);
94 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
97 static void socket_unwatch_control_pid(Socket *s) {
100 if (s->control_pid <= 0)
103 unit_unwatch_pid(UNIT(s), s->control_pid);
107 void socket_free_ports(Socket *s) {
112 while ((p = s->ports)) {
113 LIST_REMOVE(SocketPort, port, s->ports, p);
116 unit_unwatch_fd(UNIT(s), &p->fd_watch);
117 close_nointr_nofail(p->fd);
125 static void socket_done(Unit *u) {
126 Socket *s = SOCKET(u);
130 socket_free_ports(s);
132 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
133 cgroup_context_init(&s->cgroup_context);
135 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
136 s->control_command = NULL;
138 socket_unwatch_control_pid(s);
140 unit_ref_unset(&s->service);
142 free(s->tcp_congestion);
143 s->tcp_congestion = NULL;
145 free(s->bind_to_device);
146 s->bind_to_device = NULL;
149 free(s->smack_ip_in);
150 free(s->smack_ip_out);
152 unit_unwatch_timer(u, &s->timer_watch);
155 static int socket_instantiate_service(Socket *s) {
162 /* This fills in s->service if it isn't filled in yet. For
163 * Accept=yes sockets we create the next connection service
164 * here. For Accept=no this is mostly a NOP since the service
165 * is figured out at load time anyway. */
167 if (UNIT_DEREF(s->service))
172 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
175 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
181 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
187 #ifdef HAVE_SYSV_COMPAT
188 if (SERVICE(u)->is_sysv) {
189 log_error("Using SysV services for socket activation is not supported. Refusing.");
195 unit_ref_set(&s->service, u);
197 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
200 static bool have_non_accept_socket(Socket *s) {
208 LIST_FOREACH(port, p, s->ports) {
210 if (p->type != SOCKET_SOCKET)
213 if (!socket_address_can_accept(&p->address))
220 static int socket_verify(Socket *s) {
223 if (UNIT(s)->load_state != UNIT_LOADED)
227 log_error_unit(UNIT(s)->id,
228 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
232 if (s->accept && have_non_accept_socket(s)) {
233 log_error_unit(UNIT(s)->id,
234 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
239 if (s->accept && s->max_connections <= 0) {
240 log_error_unit(UNIT(s)->id,
241 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
245 if (s->accept && UNIT_DEREF(s->service)) {
246 log_error_unit(UNIT(s)->id,
247 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
252 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
253 log_error_unit(UNIT(s)->id,
254 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
262 static int socket_add_mount_links(Socket *s) {
268 LIST_FOREACH(port, p, s->ports) {
269 const char *path = NULL;
271 if (p->type == SOCKET_SOCKET)
272 path = socket_address_get_path(&p->address);
273 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
279 r = unit_require_mounts_for(UNIT(s), path);
287 static int socket_add_device_link(Socket *s) {
293 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
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 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
313 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
314 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
319 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
322 _pure_ static bool socket_has_exec(Socket *s) {
326 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
327 if (s->exec_command[i])
333 static int socket_load(Unit *u) {
334 Socket *s = SOCKET(u);
338 assert(u->load_state == UNIT_STUB);
340 if ((r = unit_load_fragment_and_dropin(u)) < 0)
343 /* This is a new unit? Then let's add in some extras */
344 if (u->load_state == UNIT_LOADED) {
346 if (have_non_accept_socket(s)) {
348 if (!UNIT_DEREF(s->service)) {
351 r = unit_load_related_unit(u, ".service", &x);
355 unit_ref_set(&s->service, x);
358 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
363 if ((r = socket_add_mount_links(s)) < 0)
366 if ((r = socket_add_device_link(s)) < 0)
369 if (socket_has_exec(s))
370 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
373 r = unit_add_default_slice(u);
377 if (UNIT(s)->default_dependencies)
378 if ((r = socket_add_default_dependencies(s)) < 0)
381 r = unit_exec_context_defaults(u, &s->exec_context);
386 return socket_verify(s);
389 _const_ static const char* listen_lookup(int family, int type) {
391 if (family == AF_NETLINK)
392 return "ListenNetlink";
394 if (type == SOCK_STREAM)
395 return "ListenStream";
396 else if (type == SOCK_DGRAM)
397 return "ListenDatagram";
398 else if (type == SOCK_SEQPACKET)
399 return "ListenSequentialPacket";
401 assert_not_reached("Unknown socket type");
405 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
408 Socket *s = SOCKET(u);
416 p2 = strappend(prefix, "\t");
417 prefix2 = p2 ? p2 : prefix;
420 "%sSocket State: %s\n"
422 "%sBindIPv6Only: %s\n"
424 "%sSocketMode: %04o\n"
425 "%sDirectoryMode: %04o\n"
428 "%sTransparent: %s\n"
430 "%sPassCredentials: %s\n"
431 "%sPassSecurity: %s\n"
432 "%sTCPCongestion: %s\n",
433 prefix, socket_state_to_string(s->state),
434 prefix, socket_result_to_string(s->result),
435 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
437 prefix, s->socket_mode,
438 prefix, s->directory_mode,
439 prefix, yes_no(s->keep_alive),
440 prefix, yes_no(s->free_bind),
441 prefix, yes_no(s->transparent),
442 prefix, yes_no(s->broadcast),
443 prefix, yes_no(s->pass_cred),
444 prefix, yes_no(s->pass_sec),
445 prefix, strna(s->tcp_congestion));
447 if (s->control_pid > 0)
449 "%sControl PID: %lu\n",
450 prefix, (unsigned long) s->control_pid);
452 if (s->bind_to_device)
454 "%sBindToDevice: %s\n",
455 prefix, s->bind_to_device);
460 "%sNConnections: %u\n"
461 "%sMaxConnections: %u\n",
462 prefix, s->n_accepted,
463 prefix, s->n_connections,
464 prefix, s->max_connections);
466 if (s->priority >= 0)
469 prefix, s->priority);
471 if (s->receive_buffer > 0)
473 "%sReceiveBuffer: %zu\n",
474 prefix, s->receive_buffer);
476 if (s->send_buffer > 0)
478 "%sSendBuffer: %zu\n",
479 prefix, s->send_buffer);
491 if (s->pipe_size > 0)
494 prefix, s->pipe_size);
501 if (s->mq_maxmsg > 0)
503 "%sMessageQueueMaxMessages: %li\n",
504 prefix, s->mq_maxmsg);
506 if (s->mq_msgsize > 0)
508 "%sMessageQueueMessageSize: %li\n",
509 prefix, s->mq_msgsize);
514 prefix, yes_no(s->reuseport));
518 "%sSmackLabel: %s\n",
523 "%sSmackLabelIPIn: %s\n",
524 prefix, s->smack_ip_in);
528 "%sSmackLabelIPOut: %s\n",
529 prefix, s->smack_ip_out);
531 LIST_FOREACH(port, p, s->ports) {
533 if (p->type == SOCKET_SOCKET) {
538 if ((r = socket_address_print(&p->address, &k)) < 0)
543 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
545 } else if (p->type == SOCKET_SPECIAL)
546 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
547 else if (p->type == SOCKET_MQUEUE)
548 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
550 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
553 exec_context_dump(&s->exec_context, f, prefix);
554 kill_context_dump(&s->kill_context, f, prefix);
556 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
557 if (!s->exec_command[c])
560 fprintf(f, "%s-> %s:\n",
561 prefix, socket_exec_command_to_string(c));
563 exec_command_dump_list(s->exec_command[c], f, prefix2);
569 static int instance_from_socket(int fd, unsigned nr, char **instance) {
574 struct sockaddr_un un;
575 struct sockaddr_in in;
576 struct sockaddr_in6 in6;
577 struct sockaddr_storage storage;
584 if (getsockname(fd, &local.sa, &l) < 0)
588 if (getpeername(fd, &remote.sa, &l) < 0)
591 switch (local.sa.sa_family) {
595 a = ntohl(local.in.sin_addr.s_addr),
596 b = ntohl(remote.in.sin_addr.s_addr);
599 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
601 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
602 ntohs(local.in.sin_port),
603 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
604 ntohs(remote.in.sin_port)) < 0)
611 static const unsigned char ipv4_prefix[] = {
612 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
615 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
616 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
618 *a = local.in6.sin6_addr.s6_addr+12,
619 *b = remote.in6.sin6_addr.s6_addr+12;
622 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
624 a[0], a[1], a[2], a[3],
625 ntohs(local.in6.sin6_port),
626 b[0], b[1], b[2], b[3],
627 ntohs(remote.in6.sin6_port)) < 0)
630 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
635 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
636 ntohs(local.in6.sin6_port),
637 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
638 ntohs(remote.in6.sin6_port)) < 0)
649 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
655 (unsigned long) ucred.pid,
656 (unsigned long) ucred.uid) < 0)
663 assert_not_reached("Unhandled socket type.");
670 static void socket_close_fds(Socket *s) {
675 LIST_FOREACH(port, p, s->ports) {
679 unit_unwatch_fd(UNIT(s), &p->fd_watch);
680 close_nointr_nofail(p->fd);
682 /* One little note: we should never delete any sockets
683 * in the file system here! After all some other
684 * process we spawned might still have a reference of
685 * this fd and wants to continue to use it. Therefore
686 * we delete sockets in the file system before we
687 * create a new one, not after we stopped using
694 static void socket_apply_socket_options(Socket *s, int fd) {
699 int b = s->keep_alive;
700 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
701 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
706 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
707 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
712 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
713 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
718 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
719 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
722 if (s->priority >= 0)
723 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
726 if (s->receive_buffer > 0) {
727 int value = (int) s->receive_buffer;
729 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
731 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
732 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
733 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
736 if (s->send_buffer > 0) {
737 int value = (int) s->send_buffer;
738 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
739 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
740 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
744 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
745 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
748 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
749 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
751 if (s->ip_ttl >= 0) {
754 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
756 if (socket_ipv6_is_supported())
757 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
760 errno = EAFNOSUPPORT;
764 log_warning_unit(UNIT(s)->id,
765 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
768 if (s->tcp_congestion)
769 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
770 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
773 int b = s->reuseport;
774 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)))
775 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
779 if (s->smack_ip_in && use_smack())
780 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
781 log_error_unit(UNIT(s)->id,
782 "fsetxattr(\"security.SMACK64IPIN\"): %m");
784 if (s->smack_ip_out && use_smack())
785 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
786 log_error_unit(UNIT(s)->id,
787 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
791 static void socket_apply_fifo_options(Socket *s, int fd) {
795 if (s->pipe_size > 0)
796 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
797 log_warning_unit(UNIT(s)->id,
801 if (s->smack && use_smack())
802 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
803 log_error_unit(UNIT(s)->id,
804 "fsetxattr(\"security.SMACK64\"): %m");
808 static int fifo_address_create(
810 mode_t directory_mode,
821 mkdir_parents_label(path, directory_mode);
823 r = label_context_set(path, S_IFIFO);
827 /* Enforce the right access mode for the fifo */
828 old_mask = umask(~ socket_mode);
830 /* Include the original umask in our mask */
831 umask(~socket_mode | old_mask);
833 r = mkfifo(path, socket_mode);
836 if (r < 0 && errno != EEXIST) {
841 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
846 label_context_clear();
848 if (fstat(fd, &st) < 0) {
853 if (!S_ISFIFO(st.st_mode) ||
854 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
855 st.st_uid != getuid() ||
856 st.st_gid != getgid()) {
866 label_context_clear();
869 close_nointr_nofail(fd);
874 static int special_address_create(
884 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
889 if (fstat(fd, &st) < 0) {
894 /* Check whether this is a /proc, /sys or /dev file or char device */
895 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
905 close_nointr_nofail(fd);
910 static int mq_address_create(
920 struct mq_attr _attr, *attr = NULL;
925 if (maxmsg > 0 && msgsize > 0) {
927 _attr.mq_flags = O_NONBLOCK;
928 _attr.mq_maxmsg = maxmsg;
929 _attr.mq_msgsize = msgsize;
933 /* Enforce the right access mode for the mq */
934 old_mask = umask(~ mq_mode);
936 /* Include the original umask in our mask */
937 umask(~mq_mode | old_mask);
939 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
947 if (fstat(fd, &st) < 0) {
952 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
953 st.st_uid != getuid() ||
954 st.st_gid != getgid()) {
965 close_nointr_nofail(fd);
970 static int socket_open_fds(Socket *s) {
974 bool know_label = false;
978 LIST_FOREACH(port, p, s->ports) {
983 if (p->type == SOCKET_SOCKET) {
987 if ((r = socket_instantiate_service(s)) < 0)
990 if (UNIT_ISSET(s->service) &&
991 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
992 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1003 if ((r = socket_address_listen(
1016 socket_apply_socket_options(s, p->fd);
1018 } else if (p->type == SOCKET_SPECIAL) {
1020 if ((r = special_address_create(
1025 } else if (p->type == SOCKET_FIFO) {
1027 if ((r = fifo_address_create(
1034 socket_apply_fifo_options(s, p->fd);
1035 } else if (p->type == SOCKET_MQUEUE) {
1037 if ((r = mq_address_create(
1045 assert_not_reached("Unknown port type");
1052 socket_close_fds(s);
1057 static void socket_unwatch_fds(Socket *s) {
1062 LIST_FOREACH(port, p, s->ports) {
1066 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1070 static int socket_watch_fds(Socket *s) {
1076 LIST_FOREACH(port, p, s->ports) {
1080 p->fd_watch.socket_accept =
1082 p->type == SOCKET_SOCKET &&
1083 socket_address_can_accept(&p->address);
1085 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1092 socket_unwatch_fds(s);
1096 static void socket_set_state(Socket *s, SocketState state) {
1097 SocketState old_state;
1100 old_state = s->state;
1103 if (state != SOCKET_START_PRE &&
1104 state != SOCKET_START_POST &&
1105 state != SOCKET_STOP_PRE &&
1106 state != SOCKET_STOP_PRE_SIGTERM &&
1107 state != SOCKET_STOP_PRE_SIGKILL &&
1108 state != SOCKET_STOP_POST &&
1109 state != SOCKET_FINAL_SIGTERM &&
1110 state != SOCKET_FINAL_SIGKILL) {
1111 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1112 socket_unwatch_control_pid(s);
1113 s->control_command = NULL;
1114 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1117 if (state != SOCKET_LISTENING)
1118 socket_unwatch_fds(s);
1120 if (state != SOCKET_START_POST &&
1121 state != SOCKET_LISTENING &&
1122 state != SOCKET_RUNNING &&
1123 state != SOCKET_STOP_PRE &&
1124 state != SOCKET_STOP_PRE_SIGTERM &&
1125 state != SOCKET_STOP_PRE_SIGKILL)
1126 socket_close_fds(s);
1128 if (state != old_state)
1129 log_debug_unit(UNIT(s)->id,
1130 "%s changed %s -> %s", UNIT(s)->id,
1131 socket_state_to_string(old_state),
1132 socket_state_to_string(state));
1134 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1137 static int socket_coldplug(Unit *u) {
1138 Socket *s = SOCKET(u);
1142 assert(s->state == SOCKET_DEAD);
1144 if (s->deserialized_state != s->state) {
1146 if (s->deserialized_state == SOCKET_START_PRE ||
1147 s->deserialized_state == SOCKET_START_POST ||
1148 s->deserialized_state == SOCKET_STOP_PRE ||
1149 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1150 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1151 s->deserialized_state == SOCKET_STOP_POST ||
1152 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1153 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1155 if (s->control_pid <= 0)
1158 r = unit_watch_pid(UNIT(s), s->control_pid);
1162 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1167 if (s->deserialized_state == SOCKET_START_POST ||
1168 s->deserialized_state == SOCKET_LISTENING ||
1169 s->deserialized_state == SOCKET_RUNNING ||
1170 s->deserialized_state == SOCKET_STOP_PRE ||
1171 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1172 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1173 if ((r = socket_open_fds(s)) < 0)
1176 if (s->deserialized_state == SOCKET_LISTENING)
1177 if ((r = socket_watch_fds(s)) < 0)
1180 socket_set_state(s, s->deserialized_state);
1186 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1195 unit_realize_cgroup(UNIT(s));
1197 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1201 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1209 UNIT(s)->manager->environment,
1213 UNIT(s)->manager->confirm_spawn,
1214 UNIT(s)->manager->cgroup_supported,
1215 UNIT(s)->cgroup_path,
1224 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1225 /* FIXME: we need to do something here */
1233 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1238 static void socket_enter_dead(Socket *s, SocketResult f) {
1241 if (f != SOCKET_SUCCESS)
1244 exec_context_tmp_dirs_done(&s->exec_context);
1245 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1248 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1250 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1254 if (f != SOCKET_SUCCESS)
1257 socket_unwatch_control_pid(s);
1259 s->control_command_id = SOCKET_EXEC_STOP_POST;
1261 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1262 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1265 socket_set_state(s, SOCKET_STOP_POST);
1267 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1272 log_warning_unit(UNIT(s)->id,
1273 "%s failed to run 'stop-post' task: %s",
1274 UNIT(s)->id, strerror(-r));
1275 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1278 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1283 if (f != SOCKET_SUCCESS)
1286 r = unit_kill_context(
1289 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1297 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1301 socket_set_state(s, state);
1302 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1303 socket_enter_stop_post(s, SOCKET_SUCCESS);
1305 socket_enter_dead(s, SOCKET_SUCCESS);
1310 log_warning_unit(UNIT(s)->id,
1311 "%s failed to kill processes: %s",
1312 UNIT(s)->id, strerror(-r));
1314 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1315 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1317 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1320 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1324 if (f != SOCKET_SUCCESS)
1327 socket_unwatch_control_pid(s);
1329 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1331 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1332 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1335 socket_set_state(s, SOCKET_STOP_PRE);
1337 socket_enter_stop_post(s, SOCKET_SUCCESS);
1342 log_warning_unit(UNIT(s)->id,
1343 "%s failed to run 'stop-pre' task: %s",
1344 UNIT(s)->id, strerror(-r));
1345 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1348 static void socket_enter_listening(Socket *s) {
1352 r = socket_watch_fds(s);
1354 log_warning_unit(UNIT(s)->id,
1355 "%s failed to watch sockets: %s",
1356 UNIT(s)->id, strerror(-r));
1360 socket_set_state(s, SOCKET_LISTENING);
1364 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1367 static void socket_enter_start_post(Socket *s) {
1371 r = socket_open_fds(s);
1373 log_warning_unit(UNIT(s)->id,
1374 "%s failed to listen on sockets: %s",
1375 UNIT(s)->id, strerror(-r));
1379 socket_unwatch_control_pid(s);
1381 s->control_command_id = SOCKET_EXEC_START_POST;
1383 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1384 r = socket_spawn(s, s->control_command, &s->control_pid);
1386 log_warning_unit(UNIT(s)->id,
1387 "%s failed to run 'start-post' task: %s",
1388 UNIT(s)->id, strerror(-r));
1392 socket_set_state(s, SOCKET_START_POST);
1394 socket_enter_listening(s);
1399 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1402 static void socket_enter_start_pre(Socket *s) {
1406 socket_unwatch_control_pid(s);
1408 s->control_command_id = SOCKET_EXEC_START_PRE;
1410 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1411 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1414 socket_set_state(s, SOCKET_START_PRE);
1416 socket_enter_start_post(s);
1421 log_warning_unit(UNIT(s)->id,
1422 "%s failed to run 'start-pre' task: %s",
1423 UNIT(s)->id, strerror(-r));
1424 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1427 static void socket_enter_running(Socket *s, int cfd) {
1432 dbus_error_init(&error);
1434 /* We don't take connections anymore if we are supposed to
1435 * shut down anyway */
1436 if (unit_stop_pending(UNIT(s))) {
1437 log_debug_unit(UNIT(s)->id,
1438 "Suppressing connection request on %s since unit stop is scheduled.",
1442 close_nointr_nofail(cfd);
1444 /* Flush all sockets by closing and reopening them */
1445 socket_close_fds(s);
1447 r = socket_watch_fds(s);
1449 log_warning_unit(UNIT(s)->id,
1450 "%s failed to watch sockets: %s",
1451 UNIT(s)->id, strerror(-r));
1452 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1462 bool pending = false;
1464 /* If there's already a start pending don't bother to
1466 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1467 if (unit_active_or_pending(u)) {
1473 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1478 socket_set_state(s, SOCKET_RUNNING);
1480 char *prefix, *instance = NULL, *name;
1483 if (s->n_connections >= s->max_connections) {
1484 log_warning_unit(UNIT(s)->id,
1485 "%s: Too many incoming connections (%u)",
1486 UNIT(s)->id, s->n_connections);
1487 close_nointr_nofail(cfd);
1491 r = socket_instantiate_service(s);
1495 r = instance_from_socket(cfd, s->n_accepted, &instance);
1500 /* ENOTCONN is legitimate if TCP RST was received.
1501 * This connection is over, but the socket unit lives on. */
1502 close_nointr_nofail(cfd);
1506 prefix = unit_name_to_prefix(UNIT(s)->id);
1513 name = unit_name_build(prefix, instance, ".service");
1522 r = unit_add_name(UNIT_DEREF(s->service), name);
1528 service = SERVICE(UNIT_DEREF(s->service));
1529 unit_ref_unset(&s->service);
1532 UNIT(service)->no_gc = false;
1534 unit_choose_id(UNIT(service), name);
1537 r = service_set_socket_fd(service, cfd, s);
1542 s->n_connections ++;
1544 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1548 /* Notify clients about changed counters */
1549 unit_add_to_dbus_queue(UNIT(s));
1555 log_warning_unit(UNIT(s)->id,
1556 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1558 cfd >= 0 ? "template" : "non-template",
1559 bus_error(&error, r));
1560 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1563 close_nointr_nofail(cfd);
1565 dbus_error_free(&error);
1568 static void socket_run_next(Socket *s) {
1572 assert(s->control_command);
1573 assert(s->control_command->command_next);
1575 socket_unwatch_control_pid(s);
1577 s->control_command = s->control_command->command_next;
1579 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1585 log_warning_unit(UNIT(s)->id,
1586 "%s failed to run next task: %s",
1587 UNIT(s)->id, strerror(-r));
1589 if (s->state == SOCKET_START_POST)
1590 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1591 else if (s->state == SOCKET_STOP_POST)
1592 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1594 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1597 static int socket_start(Unit *u) {
1598 Socket *s = SOCKET(u);
1602 /* We cannot fulfill this request right now, try again later
1604 if (s->state == SOCKET_STOP_PRE ||
1605 s->state == SOCKET_STOP_PRE_SIGKILL ||
1606 s->state == SOCKET_STOP_PRE_SIGTERM ||
1607 s->state == SOCKET_STOP_POST ||
1608 s->state == SOCKET_FINAL_SIGTERM ||
1609 s->state == SOCKET_FINAL_SIGKILL)
1612 if (s->state == SOCKET_START_PRE ||
1613 s->state == SOCKET_START_POST)
1616 /* Cannot run this without the service being around */
1617 if (UNIT_ISSET(s->service)) {
1620 service = SERVICE(UNIT_DEREF(s->service));
1622 if (UNIT(service)->load_state != UNIT_LOADED) {
1623 log_error_unit(u->id,
1624 "Socket service %s not loaded, refusing.",
1629 /* If the service is already active we cannot start the
1631 if (service->state != SERVICE_DEAD &&
1632 service->state != SERVICE_FAILED &&
1633 service->state != SERVICE_AUTO_RESTART) {
1634 log_error_unit(u->id,
1635 "Socket service %s already active, refusing.",
1640 #ifdef HAVE_SYSV_COMPAT
1641 if (service->is_sysv) {
1642 log_error_unit(u->id,
1643 "Using SysV services for socket activation is not supported. Refusing.");
1649 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1651 s->result = SOCKET_SUCCESS;
1652 socket_enter_start_pre(s);
1656 static int socket_stop(Unit *u) {
1657 Socket *s = SOCKET(u);
1662 if (s->state == SOCKET_STOP_PRE ||
1663 s->state == SOCKET_STOP_PRE_SIGTERM ||
1664 s->state == SOCKET_STOP_PRE_SIGKILL ||
1665 s->state == SOCKET_STOP_POST ||
1666 s->state == SOCKET_FINAL_SIGTERM ||
1667 s->state == SOCKET_FINAL_SIGKILL)
1670 /* If there's already something running we go directly into
1672 if (s->state == SOCKET_START_PRE ||
1673 s->state == SOCKET_START_POST) {
1674 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1678 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1680 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1684 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1685 Socket *s = SOCKET(u);
1693 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1694 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1695 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1697 if (s->control_pid > 0)
1698 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1700 if (s->control_command_id >= 0)
1701 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1703 LIST_FOREACH(port, p, s->ports) {
1709 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1712 if (p->type == SOCKET_SOCKET) {
1715 r = socket_address_print(&p->address, &t);
1719 if (socket_address_family(&p->address) == AF_NETLINK)
1720 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1722 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1724 } else if (p->type == SOCKET_SPECIAL)
1725 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1726 else if (p->type == SOCKET_MQUEUE)
1727 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1729 assert(p->type == SOCKET_FIFO);
1730 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1734 exec_context_serialize(&s->exec_context, UNIT(s), f);
1739 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1740 Socket *s = SOCKET(u);
1747 if (streq(key, "state")) {
1750 state = socket_state_from_string(value);
1752 log_debug_unit(u->id,
1753 "Failed to parse state value %s", value);
1755 s->deserialized_state = state;
1756 } else if (streq(key, "result")) {
1759 f = socket_result_from_string(value);
1761 log_debug_unit(u->id,
1762 "Failed to parse result value %s", value);
1763 else if (f != SOCKET_SUCCESS)
1766 } else if (streq(key, "n-accepted")) {
1769 if (safe_atou(value, &k) < 0)
1770 log_debug_unit(u->id,
1771 "Failed to parse n-accepted value %s", value);
1774 } else if (streq(key, "control-pid")) {
1777 if (parse_pid(value, &pid) < 0)
1778 log_debug_unit(u->id,
1779 "Failed to parse control-pid value %s", value);
1781 s->control_pid = pid;
1782 } else if (streq(key, "control-command")) {
1783 SocketExecCommand id;
1785 id = socket_exec_command_from_string(value);
1787 log_debug_unit(u->id,
1788 "Failed to parse exec-command value %s", value);
1790 s->control_command_id = id;
1791 s->control_command = s->exec_command[id];
1793 } else if (streq(key, "fifo")) {
1797 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1798 log_debug_unit(u->id,
1799 "Failed to parse fifo value %s", value);
1802 LIST_FOREACH(port, p, s->ports)
1803 if (p->type == SOCKET_FIFO &&
1804 streq_ptr(p->path, value+skip))
1809 close_nointr_nofail(p->fd);
1810 p->fd = fdset_remove(fds, fd);
1814 } else if (streq(key, "special")) {
1818 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1819 log_debug_unit(u->id,
1820 "Failed to parse special value %s", value);
1823 LIST_FOREACH(port, p, s->ports)
1824 if (p->type == SOCKET_SPECIAL &&
1825 streq_ptr(p->path, value+skip))
1830 close_nointr_nofail(p->fd);
1831 p->fd = fdset_remove(fds, fd);
1835 } else if (streq(key, "mqueue")) {
1839 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1840 log_debug_unit(u->id,
1841 "Failed to parse mqueue value %s", value);
1844 LIST_FOREACH(port, p, s->ports)
1845 if (p->type == SOCKET_MQUEUE &&
1846 streq_ptr(p->path, value+skip))
1851 close_nointr_nofail(p->fd);
1852 p->fd = fdset_remove(fds, fd);
1856 } else if (streq(key, "socket")) {
1857 int fd, type, skip = 0;
1860 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1861 log_debug_unit(u->id,
1862 "Failed to parse socket value %s", value);
1865 LIST_FOREACH(port, p, s->ports)
1866 if (socket_address_is(&p->address, value+skip, type))
1871 close_nointr_nofail(p->fd);
1872 p->fd = fdset_remove(fds, fd);
1876 } else if (streq(key, "netlink")) {
1880 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1881 log_debug_unit(u->id,
1882 "Failed to parse socket value %s", value);
1885 LIST_FOREACH(port, p, s->ports)
1886 if (socket_address_is_netlink(&p->address, value+skip))
1891 close_nointr_nofail(p->fd);
1892 p->fd = fdset_remove(fds, fd);
1895 } else if (streq(key, "tmp-dir")) {
1902 s->exec_context.tmp_dir = t;
1903 } else if (streq(key, "var-tmp-dir")) {
1910 s->exec_context.var_tmp_dir = t;
1912 log_debug_unit(UNIT(s)->id,
1913 "Unknown serialization key '%s'", key);
1918 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1919 Socket *s = SOCKET(u);
1924 LIST_FOREACH(port, p, s->ports) {
1928 if (p->type != SOCKET_SOCKET)
1934 FDSET_FOREACH(fd, fds, i) {
1935 if (socket_address_matches_fd(&p->address, fd)) {
1936 p->fd = fdset_remove(fds, fd);
1937 s->deserialized_state = SOCKET_LISTENING;
1946 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1949 return state_translation_table[SOCKET(u)->state];
1952 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1955 return socket_state_to_string(SOCKET(u)->state);
1958 const char* socket_port_type_to_string(SocketPort *p) {
1964 switch (p->address.type) {
1965 case SOCK_STREAM: return "Stream";
1966 case SOCK_DGRAM: return "Datagram";
1967 case SOCK_SEQPACKET: return "SequentialPacket";
1969 if (socket_address_family(&p->address) == AF_NETLINK)
1971 default: return "Invalid";
1973 case SOCKET_SPECIAL: return "Special";
1974 case SOCKET_MQUEUE: return "MessageQueue";
1975 case SOCKET_FIFO: return "FIFO";
1976 default: return NULL;
1980 _pure_ static bool socket_check_gc(Unit *u) {
1981 Socket *s = SOCKET(u);
1985 return s->n_connections > 0;
1988 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1989 Socket *s = SOCKET(u);
1995 if (s->state != SOCKET_LISTENING)
1998 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2000 if (events != EPOLLIN) {
2002 if (events & EPOLLHUP)
2003 log_error_unit(u->id,
2004 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2007 log_error_unit(u->id,
2008 "%s: Got unexpected poll event (0x%x) on socket.",
2014 if (w->socket_accept) {
2017 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2023 log_error_unit(u->id,
2024 "Failed to accept socket: %m");
2031 socket_apply_socket_options(s, cfd);
2034 socket_enter_running(s, cfd);
2038 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2041 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2042 Socket *s = SOCKET(u);
2048 if (pid != s->control_pid)
2053 if (is_clean_exit(code, status, NULL))
2055 else if (code == CLD_EXITED)
2056 f = SOCKET_FAILURE_EXIT_CODE;
2057 else if (code == CLD_KILLED)
2058 f = SOCKET_FAILURE_SIGNAL;
2059 else if (code == CLD_DUMPED)
2060 f = SOCKET_FAILURE_CORE_DUMP;
2062 assert_not_reached("Unknown code");
2064 if (s->control_command) {
2065 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2067 if (s->control_command->ignore)
2071 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2073 "%s control process exited, code=%s status=%i",
2074 u->id, sigchld_code_to_string(code), status);
2076 if (f != SOCKET_SUCCESS)
2079 if (s->control_command &&
2080 s->control_command->command_next &&
2081 f == SOCKET_SUCCESS) {
2083 log_debug_unit(u->id,
2084 "%s running next command for state %s",
2085 u->id, socket_state_to_string(s->state));
2088 s->control_command = NULL;
2089 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2091 /* No further commands for this step, so let's figure
2092 * out what to do next */
2094 log_debug_unit(u->id,
2095 "%s got final SIGCHLD for state %s",
2096 u->id, socket_state_to_string(s->state));
2100 case SOCKET_START_PRE:
2101 if (f == SOCKET_SUCCESS)
2102 socket_enter_start_post(s);
2104 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2107 case SOCKET_START_POST:
2108 if (f == SOCKET_SUCCESS)
2109 socket_enter_listening(s);
2111 socket_enter_stop_pre(s, f);
2114 case SOCKET_STOP_PRE:
2115 case SOCKET_STOP_PRE_SIGTERM:
2116 case SOCKET_STOP_PRE_SIGKILL:
2117 socket_enter_stop_post(s, f);
2120 case SOCKET_STOP_POST:
2121 case SOCKET_FINAL_SIGTERM:
2122 case SOCKET_FINAL_SIGKILL:
2123 socket_enter_dead(s, f);
2127 assert_not_reached("Uh, control process died at wrong time.");
2131 /* Notify clients about changed exit status */
2132 unit_add_to_dbus_queue(u);
2135 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2136 Socket *s = SOCKET(u);
2139 assert(elapsed == 1);
2140 assert(w == &s->timer_watch);
2144 case SOCKET_START_PRE:
2145 log_warning_unit(u->id,
2146 "%s starting timed out. Terminating.", u->id);
2147 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2150 case SOCKET_START_POST:
2151 log_warning_unit(u->id,
2152 "%s starting timed out. Stopping.", u->id);
2153 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2156 case SOCKET_STOP_PRE:
2157 log_warning_unit(u->id,
2158 "%s stopping timed out. Terminating.", u->id);
2159 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2162 case SOCKET_STOP_PRE_SIGTERM:
2163 if (s->kill_context.send_sigkill) {
2164 log_warning_unit(u->id,
2165 "%s stopping timed out. Killing.", u->id);
2166 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2168 log_warning_unit(u->id,
2169 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2171 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2175 case SOCKET_STOP_PRE_SIGKILL:
2176 log_warning_unit(u->id,
2177 "%s still around after SIGKILL. Ignoring.", u->id);
2178 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2181 case SOCKET_STOP_POST:
2182 log_warning_unit(u->id,
2183 "%s stopping timed out (2). Terminating.", u->id);
2184 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2187 case SOCKET_FINAL_SIGTERM:
2188 if (s->kill_context.send_sigkill) {
2189 log_warning_unit(u->id,
2190 "%s stopping timed out (2). Killing.", u->id);
2191 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2193 log_warning_unit(u->id,
2194 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2196 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2200 case SOCKET_FINAL_SIGKILL:
2201 log_warning_unit(u->id,
2202 "%s still around after SIGKILL (2). Entering failed mode.",
2204 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2208 assert_not_reached("Timeout at wrong time.");
2212 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2221 /* Called from the service code for requesting our fds */
2224 LIST_FOREACH(port, p, s->ports)
2234 if (!(rfds = new(int, rn_fds)))
2238 LIST_FOREACH(port, p, s->ports)
2242 assert(k == rn_fds);
2250 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2253 /* The service is dead. Dang!
2255 * This is strictly for one-instance-for-all-connections
2258 if (s->state == SOCKET_RUNNING) {
2259 log_debug_unit(UNIT(s)->id,
2260 "%s got notified about service death (failed permanently: %s)",
2261 UNIT(s)->id, yes_no(failed_permanent));
2262 if (failed_permanent)
2263 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2265 socket_enter_listening(s);
2269 void socket_connection_unref(Socket *s) {
2272 /* The service is dead. Yay!
2274 * This is strictly for one-instance-per-connection
2277 assert(s->n_connections > 0);
2280 log_debug_unit(UNIT(s)->id,
2281 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2284 static void socket_reset_failed(Unit *u) {
2285 Socket *s = SOCKET(u);
2289 if (s->state == SOCKET_FAILED)
2290 socket_set_state(s, SOCKET_DEAD);
2292 s->result = SOCKET_SUCCESS;
2295 static void socket_trigger_notify(Unit *u, Unit *other) {
2296 Socket *s = SOCKET(u);
2297 Service *se = SERVICE(other);
2302 /* Don't propagate state changes from the service if we are
2303 already down or accepting connections */
2304 if ((s->state != SOCKET_RUNNING &&
2305 s->state != SOCKET_LISTENING) ||
2309 if (other->load_state != UNIT_LOADED ||
2310 other->type != UNIT_SERVICE)
2313 if (se->state == SERVICE_FAILED)
2314 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2316 if (se->state == SERVICE_DEAD ||
2317 se->state == SERVICE_STOP ||
2318 se->state == SERVICE_STOP_SIGTERM ||
2319 se->state == SERVICE_STOP_SIGKILL ||
2320 se->state == SERVICE_STOP_POST ||
2321 se->state == SERVICE_FINAL_SIGTERM ||
2322 se->state == SERVICE_FINAL_SIGKILL ||
2323 se->state == SERVICE_AUTO_RESTART)
2324 socket_notify_service_dead(s, false);
2326 if (se->state == SERVICE_RUNNING)
2327 socket_set_state(s, SOCKET_RUNNING);
2330 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2331 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2334 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2335 [SOCKET_DEAD] = "dead",
2336 [SOCKET_START_PRE] = "start-pre",
2337 [SOCKET_START_POST] = "start-post",
2338 [SOCKET_LISTENING] = "listening",
2339 [SOCKET_RUNNING] = "running",
2340 [SOCKET_STOP_PRE] = "stop-pre",
2341 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2342 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2343 [SOCKET_STOP_POST] = "stop-post",
2344 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2345 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2346 [SOCKET_FAILED] = "failed"
2349 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2351 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2352 [SOCKET_EXEC_START_PRE] = "StartPre",
2353 [SOCKET_EXEC_START_POST] = "StartPost",
2354 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2355 [SOCKET_EXEC_STOP_POST] = "StopPost"
2358 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2360 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2361 [SOCKET_SUCCESS] = "success",
2362 [SOCKET_FAILURE_RESOURCES] = "resources",
2363 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2364 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2365 [SOCKET_FAILURE_SIGNAL] = "signal",
2366 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2367 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2370 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2372 const UnitVTable socket_vtable = {
2373 .object_size = sizeof(Socket),
2380 .private_section = "Socket",
2381 .exec_context_offset = offsetof(Socket, exec_context),
2382 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2384 .init = socket_init,
2385 .done = socket_done,
2386 .load = socket_load,
2388 .kill = socket_kill,
2390 .coldplug = socket_coldplug,
2392 .dump = socket_dump,
2394 .start = socket_start,
2395 .stop = socket_stop,
2397 .serialize = socket_serialize,
2398 .deserialize_item = socket_deserialize_item,
2399 .distribute_fds = socket_distribute_fds,
2401 .active_state = socket_active_state,
2402 .sub_state_to_string = socket_sub_state_to_string,
2404 .check_gc = socket_check_gc,
2406 .fd_event = socket_fd_event,
2407 .sigchld_event = socket_sigchld_event,
2408 .timer_event = socket_timer_event,
2410 .trigger_notify = socket_trigger_notify,
2412 .reset_failed = socket_reset_failed,
2414 .bus_interface = "org.freedesktop.systemd1.Socket",
2415 .bus_message_handler = bus_socket_message_handler,
2416 .bus_invalidating_properties = bus_socket_invalidating_properties,
2417 .bus_set_property = bus_socket_set_property,
2418 .bus_commit_properties = bus_socket_commit_properties,
2420 .status_message_formats = {
2421 /*.starting_stopping = {
2422 [0] = "Starting socket %s...",
2423 [1] = "Stopping socket %s...",
2425 .finished_start_job = {
2426 [JOB_DONE] = "Listening on %s.",
2427 [JOB_FAILED] = "Failed to listen on %s.",
2428 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2429 [JOB_TIMEOUT] = "Timed out starting %s.",
2431 .finished_stop_job = {
2432 [JOB_DONE] = "Closed %s.",
2433 [JOB_FAILED] = "Failed stopping %s.",
2434 [JOB_TIMEOUT] = "Timed out stopping %s.",