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"
54 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
55 [SOCKET_DEAD] = UNIT_INACTIVE,
56 [SOCKET_START_PRE] = UNIT_ACTIVATING,
57 [SOCKET_START_POST] = UNIT_ACTIVATING,
58 [SOCKET_LISTENING] = UNIT_ACTIVE,
59 [SOCKET_RUNNING] = UNIT_ACTIVE,
60 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
61 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
62 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
63 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
64 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
65 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
66 [SOCKET_FAILED] = UNIT_FAILED
69 static void socket_init(Unit *u) {
70 Socket *s = SOCKET(u);
73 assert(u->load_state == UNIT_STUB);
75 s->backlog = SOMAXCONN;
76 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
77 s->directory_mode = 0755;
78 s->socket_mode = 0666;
80 s->max_connections = 64;
87 exec_context_init(&s->exec_context);
88 s->exec_context.std_output = u->manager->default_std_output;
89 s->exec_context.std_error = u->manager->default_std_error;
90 kill_context_init(&s->kill_context);
91 cgroup_context_init(&s->cgroup_context);
93 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
96 static void socket_unwatch_control_pid(Socket *s) {
99 if (s->control_pid <= 0)
102 unit_unwatch_pid(UNIT(s), s->control_pid);
106 void socket_free_ports(Socket *s) {
111 while ((p = s->ports)) {
112 LIST_REMOVE(SocketPort, port, s->ports, p);
115 unit_unwatch_fd(UNIT(s), &p->fd_watch);
116 close_nointr_nofail(p->fd);
124 static void socket_done(Unit *u) {
125 Socket *s = SOCKET(u);
129 socket_free_ports(s);
131 exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
132 cgroup_context_init(&s->cgroup_context);
134 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
135 s->control_command = NULL;
137 socket_unwatch_control_pid(s);
139 unit_ref_unset(&s->service);
141 free(s->tcp_congestion);
142 s->tcp_congestion = NULL;
144 free(s->bind_to_device);
145 s->bind_to_device = NULL;
148 free(s->smack_ip_in);
149 free(s->smack_ip_out);
151 unit_unwatch_timer(u, &s->timer_watch);
154 static int socket_instantiate_service(Socket *s) {
161 /* This fills in s->service if it isn't filled in yet. For
162 * Accept=yes sockets we create the next connection service
163 * here. For Accept=no this is mostly a NOP since the service
164 * is figured out at load time anyway. */
166 if (UNIT_DEREF(s->service))
171 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
174 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
180 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
186 #ifdef HAVE_SYSV_COMPAT
187 if (SERVICE(u)->is_sysv) {
188 log_error("Using SysV services for socket activation is not supported. Refusing.");
194 unit_ref_set(&s->service, u);
196 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
199 static bool have_non_accept_socket(Socket *s) {
207 LIST_FOREACH(port, p, s->ports) {
209 if (p->type != SOCKET_SOCKET)
212 if (!socket_address_can_accept(&p->address))
219 static int socket_verify(Socket *s) {
222 if (UNIT(s)->load_state != UNIT_LOADED)
226 log_error_unit(UNIT(s)->id,
227 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
231 if (s->accept && have_non_accept_socket(s)) {
232 log_error_unit(UNIT(s)->id,
233 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
238 if (s->accept && s->max_connections <= 0) {
239 log_error_unit(UNIT(s)->id,
240 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
244 if (s->accept && UNIT_DEREF(s->service)) {
245 log_error_unit(UNIT(s)->id,
246 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
251 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
252 log_error_unit(UNIT(s)->id,
253 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
261 static int socket_add_mount_links(Socket *s) {
267 LIST_FOREACH(port, p, s->ports) {
268 const char *path = NULL;
270 if (p->type == SOCKET_SOCKET)
271 path = socket_address_get_path(&p->address);
272 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
278 r = unit_require_mounts_for(UNIT(s), path);
286 static int socket_add_device_link(Socket *s) {
292 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
295 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
298 r = unit_add_node_link(UNIT(s), t, false);
304 static int socket_add_default_dependencies(Socket *s) {
308 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
312 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
313 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
318 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
321 _pure_ static bool socket_has_exec(Socket *s) {
325 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
326 if (s->exec_command[i])
332 static int socket_load(Unit *u) {
333 Socket *s = SOCKET(u);
337 assert(u->load_state == UNIT_STUB);
339 if ((r = unit_load_fragment_and_dropin(u)) < 0)
342 /* This is a new unit? Then let's add in some extras */
343 if (u->load_state == UNIT_LOADED) {
345 if (have_non_accept_socket(s)) {
347 if (!UNIT_DEREF(s->service)) {
350 r = unit_load_related_unit(u, ".service", &x);
354 unit_ref_set(&s->service, x);
357 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
362 if ((r = socket_add_mount_links(s)) < 0)
365 if ((r = socket_add_device_link(s)) < 0)
368 if (socket_has_exec(s))
369 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
372 r = unit_add_default_slice(u);
376 if (UNIT(s)->default_dependencies)
377 if ((r = socket_add_default_dependencies(s)) < 0)
380 r = unit_exec_context_defaults(u, &s->exec_context);
385 return socket_verify(s);
388 _const_ static const char* listen_lookup(int family, int type) {
390 if (family == AF_NETLINK)
391 return "ListenNetlink";
393 if (type == SOCK_STREAM)
394 return "ListenStream";
395 else if (type == SOCK_DGRAM)
396 return "ListenDatagram";
397 else if (type == SOCK_SEQPACKET)
398 return "ListenSequentialPacket";
400 assert_not_reached("Unknown socket type");
404 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
407 Socket *s = SOCKET(u);
415 p2 = strappend(prefix, "\t");
416 prefix2 = p2 ? p2 : prefix;
419 "%sSocket State: %s\n"
421 "%sBindIPv6Only: %s\n"
423 "%sSocketMode: %04o\n"
424 "%sDirectoryMode: %04o\n"
427 "%sTransparent: %s\n"
429 "%sPassCredentials: %s\n"
430 "%sPassSecurity: %s\n"
431 "%sTCPCongestion: %s\n",
432 prefix, socket_state_to_string(s->state),
433 prefix, socket_result_to_string(s->result),
434 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
436 prefix, s->socket_mode,
437 prefix, s->directory_mode,
438 prefix, yes_no(s->keep_alive),
439 prefix, yes_no(s->free_bind),
440 prefix, yes_no(s->transparent),
441 prefix, yes_no(s->broadcast),
442 prefix, yes_no(s->pass_cred),
443 prefix, yes_no(s->pass_sec),
444 prefix, strna(s->tcp_congestion));
446 if (s->control_pid > 0)
448 "%sControl PID: %lu\n",
449 prefix, (unsigned long) s->control_pid);
451 if (s->bind_to_device)
453 "%sBindToDevice: %s\n",
454 prefix, s->bind_to_device);
459 "%sNConnections: %u\n"
460 "%sMaxConnections: %u\n",
461 prefix, s->n_accepted,
462 prefix, s->n_connections,
463 prefix, s->max_connections);
465 if (s->priority >= 0)
468 prefix, s->priority);
470 if (s->receive_buffer > 0)
472 "%sReceiveBuffer: %zu\n",
473 prefix, s->receive_buffer);
475 if (s->send_buffer > 0)
477 "%sSendBuffer: %zu\n",
478 prefix, s->send_buffer);
490 if (s->pipe_size > 0)
493 prefix, s->pipe_size);
500 if (s->mq_maxmsg > 0)
502 "%sMessageQueueMaxMessages: %li\n",
503 prefix, s->mq_maxmsg);
505 if (s->mq_msgsize > 0)
507 "%sMessageQueueMessageSize: %li\n",
508 prefix, s->mq_msgsize);
513 prefix, yes_no(s->reuseport));
517 "%sSmackLabel: %s\n",
522 "%sSmackLabelIPIn: %s\n",
523 prefix, s->smack_ip_in);
527 "%sSmackLabelIPOut: %s\n",
528 prefix, s->smack_ip_out);
530 LIST_FOREACH(port, p, s->ports) {
532 if (p->type == SOCKET_SOCKET) {
537 if ((r = socket_address_print(&p->address, &k)) < 0)
542 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
544 } else if (p->type == SOCKET_SPECIAL)
545 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
546 else if (p->type == SOCKET_MQUEUE)
547 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
549 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
552 exec_context_dump(&s->exec_context, f, prefix);
553 kill_context_dump(&s->kill_context, f, prefix);
555 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
556 if (!s->exec_command[c])
559 fprintf(f, "%s-> %s:\n",
560 prefix, socket_exec_command_to_string(c));
562 exec_command_dump_list(s->exec_command[c], f, prefix2);
568 static int instance_from_socket(int fd, unsigned nr, char **instance) {
573 struct sockaddr_un un;
574 struct sockaddr_in in;
575 struct sockaddr_in6 in6;
576 struct sockaddr_storage storage;
583 if (getsockname(fd, &local.sa, &l) < 0)
587 if (getpeername(fd, &remote.sa, &l) < 0)
590 switch (local.sa.sa_family) {
594 a = ntohl(local.in.sin_addr.s_addr),
595 b = ntohl(remote.in.sin_addr.s_addr);
598 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
600 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
601 ntohs(local.in.sin_port),
602 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
603 ntohs(remote.in.sin_port)) < 0)
610 static const unsigned char ipv4_prefix[] = {
611 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
614 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
615 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
617 *a = local.in6.sin6_addr.s6_addr+12,
618 *b = remote.in6.sin6_addr.s6_addr+12;
621 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
623 a[0], a[1], a[2], a[3],
624 ntohs(local.in6.sin6_port),
625 b[0], b[1], b[2], b[3],
626 ntohs(remote.in6.sin6_port)) < 0)
629 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
634 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
635 ntohs(local.in6.sin6_port),
636 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
637 ntohs(remote.in6.sin6_port)) < 0)
648 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
654 (unsigned long) ucred.pid,
655 (unsigned long) ucred.uid) < 0)
662 assert_not_reached("Unhandled socket type.");
669 static void socket_close_fds(Socket *s) {
674 LIST_FOREACH(port, p, s->ports) {
678 unit_unwatch_fd(UNIT(s), &p->fd_watch);
679 close_nointr_nofail(p->fd);
681 /* One little note: we should never delete any sockets
682 * in the file system here! After all some other
683 * process we spawned might still have a reference of
684 * this fd and wants to continue to use it. Therefore
685 * we delete sockets in the file system before we
686 * create a new one, not after we stopped using
693 static void socket_apply_socket_options(Socket *s, int fd) {
698 int b = s->keep_alive;
699 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
700 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
705 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
706 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
711 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
712 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
717 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
718 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
721 if (s->priority >= 0)
722 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
723 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
725 if (s->receive_buffer > 0) {
726 int value = (int) s->receive_buffer;
728 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
730 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
731 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
732 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
735 if (s->send_buffer > 0) {
736 int value = (int) s->send_buffer;
737 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
738 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
739 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
743 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
744 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
747 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
748 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
750 if (s->ip_ttl >= 0) {
753 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
755 if (socket_ipv6_is_supported())
756 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
759 errno = EAFNOSUPPORT;
763 log_warning_unit(UNIT(s)->id,
764 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
767 if (s->tcp_congestion)
768 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
769 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
772 int b = s->reuseport;
773 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)))
774 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
779 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
780 log_error_unit(UNIT(s)->id,
781 "fsetxattr(\"security.SMACK64IPIN\"): %m");
784 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
785 log_error_unit(UNIT(s)->id,
786 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
790 static void socket_apply_fifo_options(Socket *s, int fd) {
794 if (s->pipe_size > 0)
795 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
796 log_warning_unit(UNIT(s)->id,
801 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
802 log_error_unit(UNIT(s)->id,
803 "fsetxattr(\"security.SMACK64\"): %m");
807 static int fifo_address_create(
809 mode_t directory_mode,
820 mkdir_parents_label(path, directory_mode);
822 r = label_context_set(path, S_IFIFO);
826 /* Enforce the right access mode for the fifo */
827 old_mask = umask(~ socket_mode);
829 /* Include the original umask in our mask */
830 umask(~socket_mode | old_mask);
832 r = mkfifo(path, socket_mode);
835 if (r < 0 && errno != EEXIST) {
840 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
845 label_context_clear();
847 if (fstat(fd, &st) < 0) {
852 if (!S_ISFIFO(st.st_mode) ||
853 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
854 st.st_uid != getuid() ||
855 st.st_gid != getgid()) {
865 label_context_clear();
868 close_nointr_nofail(fd);
873 static int special_address_create(
883 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
888 if (fstat(fd, &st) < 0) {
893 /* Check whether this is a /proc, /sys or /dev file or char device */
894 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
904 close_nointr_nofail(fd);
909 static int mq_address_create(
919 struct mq_attr _attr, *attr = NULL;
924 if (maxmsg > 0 && msgsize > 0) {
926 _attr.mq_flags = O_NONBLOCK;
927 _attr.mq_maxmsg = maxmsg;
928 _attr.mq_msgsize = msgsize;
932 /* Enforce the right access mode for the mq */
933 old_mask = umask(~ mq_mode);
935 /* Include the original umask in our mask */
936 umask(~mq_mode | old_mask);
938 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
946 if (fstat(fd, &st) < 0) {
951 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
952 st.st_uid != getuid() ||
953 st.st_gid != getgid()) {
964 close_nointr_nofail(fd);
969 static int socket_open_fds(Socket *s) {
973 bool know_label = false;
977 LIST_FOREACH(port, p, s->ports) {
982 if (p->type == SOCKET_SOCKET) {
986 if ((r = socket_instantiate_service(s)) < 0)
989 if (UNIT_ISSET(s->service) &&
990 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
991 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1002 if ((r = socket_address_listen(
1015 socket_apply_socket_options(s, p->fd);
1017 } else if (p->type == SOCKET_SPECIAL) {
1019 if ((r = special_address_create(
1024 } else if (p->type == SOCKET_FIFO) {
1026 if ((r = fifo_address_create(
1033 socket_apply_fifo_options(s, p->fd);
1034 } else if (p->type == SOCKET_MQUEUE) {
1036 if ((r = mq_address_create(
1044 assert_not_reached("Unknown port type");
1051 socket_close_fds(s);
1056 static void socket_unwatch_fds(Socket *s) {
1061 LIST_FOREACH(port, p, s->ports) {
1065 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1069 static int socket_watch_fds(Socket *s) {
1075 LIST_FOREACH(port, p, s->ports) {
1079 p->fd_watch.socket_accept =
1081 p->type == SOCKET_SOCKET &&
1082 socket_address_can_accept(&p->address);
1084 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1091 socket_unwatch_fds(s);
1095 static void socket_set_state(Socket *s, SocketState state) {
1096 SocketState old_state;
1099 old_state = s->state;
1102 if (state != SOCKET_START_PRE &&
1103 state != SOCKET_START_POST &&
1104 state != SOCKET_STOP_PRE &&
1105 state != SOCKET_STOP_PRE_SIGTERM &&
1106 state != SOCKET_STOP_PRE_SIGKILL &&
1107 state != SOCKET_STOP_POST &&
1108 state != SOCKET_FINAL_SIGTERM &&
1109 state != SOCKET_FINAL_SIGKILL) {
1110 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1111 socket_unwatch_control_pid(s);
1112 s->control_command = NULL;
1113 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1116 if (state != SOCKET_LISTENING)
1117 socket_unwatch_fds(s);
1119 if (state != SOCKET_START_POST &&
1120 state != SOCKET_LISTENING &&
1121 state != SOCKET_RUNNING &&
1122 state != SOCKET_STOP_PRE &&
1123 state != SOCKET_STOP_PRE_SIGTERM &&
1124 state != SOCKET_STOP_PRE_SIGKILL)
1125 socket_close_fds(s);
1127 if (state != old_state)
1128 log_debug_unit(UNIT(s)->id,
1129 "%s changed %s -> %s", UNIT(s)->id,
1130 socket_state_to_string(old_state),
1131 socket_state_to_string(state));
1133 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1136 static int socket_coldplug(Unit *u) {
1137 Socket *s = SOCKET(u);
1141 assert(s->state == SOCKET_DEAD);
1143 if (s->deserialized_state != s->state) {
1145 if (s->deserialized_state == SOCKET_START_PRE ||
1146 s->deserialized_state == SOCKET_START_POST ||
1147 s->deserialized_state == SOCKET_STOP_PRE ||
1148 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1149 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1150 s->deserialized_state == SOCKET_STOP_POST ||
1151 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1152 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1154 if (s->control_pid <= 0)
1157 r = unit_watch_pid(UNIT(s), s->control_pid);
1161 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1166 if (s->deserialized_state == SOCKET_START_POST ||
1167 s->deserialized_state == SOCKET_LISTENING ||
1168 s->deserialized_state == SOCKET_RUNNING ||
1169 s->deserialized_state == SOCKET_STOP_PRE ||
1170 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1171 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1172 if ((r = socket_open_fds(s)) < 0)
1175 if (s->deserialized_state == SOCKET_LISTENING)
1176 if ((r = socket_watch_fds(s)) < 0)
1179 socket_set_state(s, s->deserialized_state);
1185 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1194 unit_realize_cgroup(UNIT(s));
1196 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1200 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1208 UNIT(s)->manager->environment,
1212 UNIT(s)->manager->confirm_spawn,
1213 UNIT(s)->manager->cgroup_supported,
1214 UNIT(s)->cgroup_path,
1223 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1224 /* FIXME: we need to do something here */
1232 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1237 static void socket_enter_dead(Socket *s, SocketResult f) {
1240 if (f != SOCKET_SUCCESS)
1243 exec_context_tmp_dirs_done(&s->exec_context);
1244 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1247 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1249 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1253 if (f != SOCKET_SUCCESS)
1256 socket_unwatch_control_pid(s);
1258 s->control_command_id = SOCKET_EXEC_STOP_POST;
1260 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1261 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1264 socket_set_state(s, SOCKET_STOP_POST);
1266 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1271 log_warning_unit(UNIT(s)->id,
1272 "%s failed to run 'stop-post' task: %s",
1273 UNIT(s)->id, strerror(-r));
1274 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1277 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1282 if (f != SOCKET_SUCCESS)
1285 r = unit_kill_context(
1288 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1296 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1300 socket_set_state(s, state);
1301 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1302 socket_enter_stop_post(s, SOCKET_SUCCESS);
1304 socket_enter_dead(s, SOCKET_SUCCESS);
1309 log_warning_unit(UNIT(s)->id,
1310 "%s failed to kill processes: %s",
1311 UNIT(s)->id, strerror(-r));
1313 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1314 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1316 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1319 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1323 if (f != SOCKET_SUCCESS)
1326 socket_unwatch_control_pid(s);
1328 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1330 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1331 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1334 socket_set_state(s, SOCKET_STOP_PRE);
1336 socket_enter_stop_post(s, SOCKET_SUCCESS);
1341 log_warning_unit(UNIT(s)->id,
1342 "%s failed to run 'stop-pre' task: %s",
1343 UNIT(s)->id, strerror(-r));
1344 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1347 static void socket_enter_listening(Socket *s) {
1351 r = socket_watch_fds(s);
1353 log_warning_unit(UNIT(s)->id,
1354 "%s failed to watch sockets: %s",
1355 UNIT(s)->id, strerror(-r));
1359 socket_set_state(s, SOCKET_LISTENING);
1363 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1366 static void socket_enter_start_post(Socket *s) {
1370 r = socket_open_fds(s);
1372 log_warning_unit(UNIT(s)->id,
1373 "%s failed to listen on sockets: %s",
1374 UNIT(s)->id, strerror(-r));
1378 socket_unwatch_control_pid(s);
1380 s->control_command_id = SOCKET_EXEC_START_POST;
1382 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1383 r = socket_spawn(s, s->control_command, &s->control_pid);
1385 log_warning_unit(UNIT(s)->id,
1386 "%s failed to run 'start-post' task: %s",
1387 UNIT(s)->id, strerror(-r));
1391 socket_set_state(s, SOCKET_START_POST);
1393 socket_enter_listening(s);
1398 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1401 static void socket_enter_start_pre(Socket *s) {
1405 socket_unwatch_control_pid(s);
1407 s->control_command_id = SOCKET_EXEC_START_PRE;
1409 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1410 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1413 socket_set_state(s, SOCKET_START_PRE);
1415 socket_enter_start_post(s);
1420 log_warning_unit(UNIT(s)->id,
1421 "%s failed to run 'start-pre' task: %s",
1422 UNIT(s)->id, strerror(-r));
1423 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1426 static void socket_enter_running(Socket *s, int cfd) {
1431 dbus_error_init(&error);
1433 /* We don't take connections anymore if we are supposed to
1434 * shut down anyway */
1435 if (unit_stop_pending(UNIT(s))) {
1436 log_debug_unit(UNIT(s)->id,
1437 "Suppressing connection request on %s since unit stop is scheduled.",
1441 close_nointr_nofail(cfd);
1443 /* Flush all sockets by closing and reopening them */
1444 socket_close_fds(s);
1446 r = socket_watch_fds(s);
1448 log_warning_unit(UNIT(s)->id,
1449 "%s failed to watch sockets: %s",
1450 UNIT(s)->id, strerror(-r));
1451 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1461 bool pending = false;
1463 /* If there's already a start pending don't bother to
1465 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1466 if (unit_active_or_pending(u)) {
1472 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1477 socket_set_state(s, SOCKET_RUNNING);
1479 char *prefix, *instance = NULL, *name;
1482 if (s->n_connections >= s->max_connections) {
1483 log_warning_unit(UNIT(s)->id,
1484 "%s: Too many incoming connections (%u)",
1485 UNIT(s)->id, s->n_connections);
1486 close_nointr_nofail(cfd);
1490 r = socket_instantiate_service(s);
1494 r = instance_from_socket(cfd, s->n_accepted, &instance);
1499 /* ENOTCONN is legitimate if TCP RST was received.
1500 * This connection is over, but the socket unit lives on. */
1501 close_nointr_nofail(cfd);
1505 prefix = unit_name_to_prefix(UNIT(s)->id);
1512 name = unit_name_build(prefix, instance, ".service");
1521 r = unit_add_name(UNIT_DEREF(s->service), name);
1527 service = SERVICE(UNIT_DEREF(s->service));
1528 unit_ref_unset(&s->service);
1531 UNIT(service)->no_gc = false;
1533 unit_choose_id(UNIT(service), name);
1536 r = service_set_socket_fd(service, cfd, s);
1541 s->n_connections ++;
1543 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1547 /* Notify clients about changed counters */
1548 unit_add_to_dbus_queue(UNIT(s));
1554 log_warning_unit(UNIT(s)->id,
1555 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1557 cfd >= 0 ? "template" : "non-template",
1558 bus_error(&error, r));
1559 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1562 close_nointr_nofail(cfd);
1564 dbus_error_free(&error);
1567 static void socket_run_next(Socket *s) {
1571 assert(s->control_command);
1572 assert(s->control_command->command_next);
1574 socket_unwatch_control_pid(s);
1576 s->control_command = s->control_command->command_next;
1578 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1584 log_warning_unit(UNIT(s)->id,
1585 "%s failed to run next task: %s",
1586 UNIT(s)->id, strerror(-r));
1588 if (s->state == SOCKET_START_POST)
1589 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1590 else if (s->state == SOCKET_STOP_POST)
1591 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1593 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1596 static int socket_start(Unit *u) {
1597 Socket *s = SOCKET(u);
1601 /* We cannot fulfill this request right now, try again later
1603 if (s->state == SOCKET_STOP_PRE ||
1604 s->state == SOCKET_STOP_PRE_SIGKILL ||
1605 s->state == SOCKET_STOP_PRE_SIGTERM ||
1606 s->state == SOCKET_STOP_POST ||
1607 s->state == SOCKET_FINAL_SIGTERM ||
1608 s->state == SOCKET_FINAL_SIGKILL)
1611 if (s->state == SOCKET_START_PRE ||
1612 s->state == SOCKET_START_POST)
1615 /* Cannot run this without the service being around */
1616 if (UNIT_ISSET(s->service)) {
1619 service = SERVICE(UNIT_DEREF(s->service));
1621 if (UNIT(service)->load_state != UNIT_LOADED) {
1622 log_error_unit(u->id,
1623 "Socket service %s not loaded, refusing.",
1628 /* If the service is already active we cannot start the
1630 if (service->state != SERVICE_DEAD &&
1631 service->state != SERVICE_FAILED &&
1632 service->state != SERVICE_AUTO_RESTART) {
1633 log_error_unit(u->id,
1634 "Socket service %s already active, refusing.",
1639 #ifdef HAVE_SYSV_COMPAT
1640 if (service->is_sysv) {
1641 log_error_unit(u->id,
1642 "Using SysV services for socket activation is not supported. Refusing.");
1648 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1650 s->result = SOCKET_SUCCESS;
1651 socket_enter_start_pre(s);
1655 static int socket_stop(Unit *u) {
1656 Socket *s = SOCKET(u);
1661 if (s->state == SOCKET_STOP_PRE ||
1662 s->state == SOCKET_STOP_PRE_SIGTERM ||
1663 s->state == SOCKET_STOP_PRE_SIGKILL ||
1664 s->state == SOCKET_STOP_POST ||
1665 s->state == SOCKET_FINAL_SIGTERM ||
1666 s->state == SOCKET_FINAL_SIGKILL)
1669 /* If there's already something running we go directly into
1671 if (s->state == SOCKET_START_PRE ||
1672 s->state == SOCKET_START_POST) {
1673 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1677 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1679 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1683 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1684 Socket *s = SOCKET(u);
1692 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1693 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1694 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1696 if (s->control_pid > 0)
1697 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1699 if (s->control_command_id >= 0)
1700 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1702 LIST_FOREACH(port, p, s->ports) {
1708 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1711 if (p->type == SOCKET_SOCKET) {
1714 r = socket_address_print(&p->address, &t);
1718 if (socket_address_family(&p->address) == AF_NETLINK)
1719 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1721 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1723 } else if (p->type == SOCKET_SPECIAL)
1724 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1725 else if (p->type == SOCKET_MQUEUE)
1726 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1728 assert(p->type == SOCKET_FIFO);
1729 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1733 exec_context_serialize(&s->exec_context, UNIT(s), f);
1738 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1739 Socket *s = SOCKET(u);
1746 if (streq(key, "state")) {
1749 state = socket_state_from_string(value);
1751 log_debug_unit(u->id,
1752 "Failed to parse state value %s", value);
1754 s->deserialized_state = state;
1755 } else if (streq(key, "result")) {
1758 f = socket_result_from_string(value);
1760 log_debug_unit(u->id,
1761 "Failed to parse result value %s", value);
1762 else if (f != SOCKET_SUCCESS)
1765 } else if (streq(key, "n-accepted")) {
1768 if (safe_atou(value, &k) < 0)
1769 log_debug_unit(u->id,
1770 "Failed to parse n-accepted value %s", value);
1773 } else if (streq(key, "control-pid")) {
1776 if (parse_pid(value, &pid) < 0)
1777 log_debug_unit(u->id,
1778 "Failed to parse control-pid value %s", value);
1780 s->control_pid = pid;
1781 } else if (streq(key, "control-command")) {
1782 SocketExecCommand id;
1784 id = socket_exec_command_from_string(value);
1786 log_debug_unit(u->id,
1787 "Failed to parse exec-command value %s", value);
1789 s->control_command_id = id;
1790 s->control_command = s->exec_command[id];
1792 } else if (streq(key, "fifo")) {
1796 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1797 log_debug_unit(u->id,
1798 "Failed to parse fifo value %s", value);
1801 LIST_FOREACH(port, p, s->ports)
1802 if (p->type == SOCKET_FIFO &&
1803 streq_ptr(p->path, value+skip))
1808 close_nointr_nofail(p->fd);
1809 p->fd = fdset_remove(fds, fd);
1813 } else if (streq(key, "special")) {
1817 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1818 log_debug_unit(u->id,
1819 "Failed to parse special value %s", value);
1822 LIST_FOREACH(port, p, s->ports)
1823 if (p->type == SOCKET_SPECIAL &&
1824 streq_ptr(p->path, value+skip))
1829 close_nointr_nofail(p->fd);
1830 p->fd = fdset_remove(fds, fd);
1834 } else if (streq(key, "mqueue")) {
1838 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1839 log_debug_unit(u->id,
1840 "Failed to parse mqueue value %s", value);
1843 LIST_FOREACH(port, p, s->ports)
1844 if (p->type == SOCKET_MQUEUE &&
1845 streq_ptr(p->path, value+skip))
1850 close_nointr_nofail(p->fd);
1851 p->fd = fdset_remove(fds, fd);
1855 } else if (streq(key, "socket")) {
1856 int fd, type, skip = 0;
1859 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1860 log_debug_unit(u->id,
1861 "Failed to parse socket value %s", value);
1864 LIST_FOREACH(port, p, s->ports)
1865 if (socket_address_is(&p->address, value+skip, type))
1870 close_nointr_nofail(p->fd);
1871 p->fd = fdset_remove(fds, fd);
1875 } else if (streq(key, "netlink")) {
1879 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1880 log_debug_unit(u->id,
1881 "Failed to parse socket value %s", value);
1884 LIST_FOREACH(port, p, s->ports)
1885 if (socket_address_is_netlink(&p->address, value+skip))
1890 close_nointr_nofail(p->fd);
1891 p->fd = fdset_remove(fds, fd);
1894 } else if (streq(key, "tmp-dir")) {
1901 s->exec_context.tmp_dir = t;
1902 } else if (streq(key, "var-tmp-dir")) {
1909 s->exec_context.var_tmp_dir = t;
1911 log_debug_unit(UNIT(s)->id,
1912 "Unknown serialization key '%s'", key);
1917 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1918 Socket *s = SOCKET(u);
1923 LIST_FOREACH(port, p, s->ports) {
1927 if (p->type != SOCKET_SOCKET)
1933 FDSET_FOREACH(fd, fds, i) {
1934 if (socket_address_matches_fd(&p->address, fd)) {
1935 p->fd = fdset_remove(fds, fd);
1936 s->deserialized_state = SOCKET_LISTENING;
1945 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1948 return state_translation_table[SOCKET(u)->state];
1951 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1954 return socket_state_to_string(SOCKET(u)->state);
1957 const char* socket_port_type_to_string(SocketPort *p) {
1963 switch (p->address.type) {
1964 case SOCK_STREAM: return "Stream";
1965 case SOCK_DGRAM: return "Datagram";
1966 case SOCK_SEQPACKET: return "SequentialPacket";
1968 if (socket_address_family(&p->address) == AF_NETLINK)
1970 default: return "Invalid";
1972 case SOCKET_SPECIAL: return "Special";
1973 case SOCKET_MQUEUE: return "MessageQueue";
1974 case SOCKET_FIFO: return "FIFO";
1975 default: return NULL;
1979 _pure_ static bool socket_check_gc(Unit *u) {
1980 Socket *s = SOCKET(u);
1984 return s->n_connections > 0;
1987 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1988 Socket *s = SOCKET(u);
1994 if (s->state != SOCKET_LISTENING)
1997 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1999 if (events != EPOLLIN) {
2001 if (events & EPOLLHUP)
2002 log_error_unit(u->id,
2003 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2006 log_error_unit(u->id,
2007 "%s: Got unexpected poll event (0x%x) on socket.",
2013 if (w->socket_accept) {
2016 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2022 log_error_unit(u->id,
2023 "Failed to accept socket: %m");
2030 socket_apply_socket_options(s, cfd);
2033 socket_enter_running(s, cfd);
2037 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2040 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2041 Socket *s = SOCKET(u);
2047 if (pid != s->control_pid)
2052 if (is_clean_exit(code, status, NULL))
2054 else if (code == CLD_EXITED)
2055 f = SOCKET_FAILURE_EXIT_CODE;
2056 else if (code == CLD_KILLED)
2057 f = SOCKET_FAILURE_SIGNAL;
2058 else if (code == CLD_DUMPED)
2059 f = SOCKET_FAILURE_CORE_DUMP;
2061 assert_not_reached("Unknown code");
2063 if (s->control_command) {
2064 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2066 if (s->control_command->ignore)
2070 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2072 "%s control process exited, code=%s status=%i",
2073 u->id, sigchld_code_to_string(code), status);
2075 if (f != SOCKET_SUCCESS)
2078 if (s->control_command &&
2079 s->control_command->command_next &&
2080 f == SOCKET_SUCCESS) {
2082 log_debug_unit(u->id,
2083 "%s running next command for state %s",
2084 u->id, socket_state_to_string(s->state));
2087 s->control_command = NULL;
2088 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2090 /* No further commands for this step, so let's figure
2091 * out what to do next */
2093 log_debug_unit(u->id,
2094 "%s got final SIGCHLD for state %s",
2095 u->id, socket_state_to_string(s->state));
2099 case SOCKET_START_PRE:
2100 if (f == SOCKET_SUCCESS)
2101 socket_enter_start_post(s);
2103 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2106 case SOCKET_START_POST:
2107 if (f == SOCKET_SUCCESS)
2108 socket_enter_listening(s);
2110 socket_enter_stop_pre(s, f);
2113 case SOCKET_STOP_PRE:
2114 case SOCKET_STOP_PRE_SIGTERM:
2115 case SOCKET_STOP_PRE_SIGKILL:
2116 socket_enter_stop_post(s, f);
2119 case SOCKET_STOP_POST:
2120 case SOCKET_FINAL_SIGTERM:
2121 case SOCKET_FINAL_SIGKILL:
2122 socket_enter_dead(s, f);
2126 assert_not_reached("Uh, control process died at wrong time.");
2130 /* Notify clients about changed exit status */
2131 unit_add_to_dbus_queue(u);
2134 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2135 Socket *s = SOCKET(u);
2138 assert(elapsed == 1);
2139 assert(w == &s->timer_watch);
2143 case SOCKET_START_PRE:
2144 log_warning_unit(u->id,
2145 "%s starting timed out. Terminating.", u->id);
2146 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2149 case SOCKET_START_POST:
2150 log_warning_unit(u->id,
2151 "%s starting timed out. Stopping.", u->id);
2152 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2155 case SOCKET_STOP_PRE:
2156 log_warning_unit(u->id,
2157 "%s stopping timed out. Terminating.", u->id);
2158 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2161 case SOCKET_STOP_PRE_SIGTERM:
2162 if (s->kill_context.send_sigkill) {
2163 log_warning_unit(u->id,
2164 "%s stopping timed out. Killing.", u->id);
2165 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2167 log_warning_unit(u->id,
2168 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2170 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2174 case SOCKET_STOP_PRE_SIGKILL:
2175 log_warning_unit(u->id,
2176 "%s still around after SIGKILL. Ignoring.", u->id);
2177 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2180 case SOCKET_STOP_POST:
2181 log_warning_unit(u->id,
2182 "%s stopping timed out (2). Terminating.", u->id);
2183 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2186 case SOCKET_FINAL_SIGTERM:
2187 if (s->kill_context.send_sigkill) {
2188 log_warning_unit(u->id,
2189 "%s stopping timed out (2). Killing.", u->id);
2190 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2192 log_warning_unit(u->id,
2193 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2195 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2199 case SOCKET_FINAL_SIGKILL:
2200 log_warning_unit(u->id,
2201 "%s still around after SIGKILL (2). Entering failed mode.",
2203 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2207 assert_not_reached("Timeout at wrong time.");
2211 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2220 /* Called from the service code for requesting our fds */
2223 LIST_FOREACH(port, p, s->ports)
2233 if (!(rfds = new(int, rn_fds)))
2237 LIST_FOREACH(port, p, s->ports)
2241 assert(k == rn_fds);
2249 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2252 /* The service is dead. Dang!
2254 * This is strictly for one-instance-for-all-connections
2257 if (s->state == SOCKET_RUNNING) {
2258 log_debug_unit(UNIT(s)->id,
2259 "%s got notified about service death (failed permanently: %s)",
2260 UNIT(s)->id, yes_no(failed_permanent));
2261 if (failed_permanent)
2262 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2264 socket_enter_listening(s);
2268 void socket_connection_unref(Socket *s) {
2271 /* The service is dead. Yay!
2273 * This is strictly for one-instance-per-connection
2276 assert(s->n_connections > 0);
2279 log_debug_unit(UNIT(s)->id,
2280 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2283 static void socket_reset_failed(Unit *u) {
2284 Socket *s = SOCKET(u);
2288 if (s->state == SOCKET_FAILED)
2289 socket_set_state(s, SOCKET_DEAD);
2291 s->result = SOCKET_SUCCESS;
2294 static void socket_trigger_notify(Unit *u, Unit *other) {
2295 Socket *s = SOCKET(u);
2296 Service *se = SERVICE(other);
2301 /* Don't propagate state changes from the service if we are
2302 already down or accepting connections */
2303 if ((s->state != SOCKET_RUNNING &&
2304 s->state != SOCKET_LISTENING) ||
2308 if (other->load_state != UNIT_LOADED ||
2309 other->type != UNIT_SERVICE)
2312 if (se->state == SERVICE_FAILED)
2313 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2315 if (se->state == SERVICE_DEAD ||
2316 se->state == SERVICE_STOP ||
2317 se->state == SERVICE_STOP_SIGTERM ||
2318 se->state == SERVICE_STOP_SIGKILL ||
2319 se->state == SERVICE_STOP_POST ||
2320 se->state == SERVICE_FINAL_SIGTERM ||
2321 se->state == SERVICE_FINAL_SIGKILL ||
2322 se->state == SERVICE_AUTO_RESTART)
2323 socket_notify_service_dead(s, false);
2325 if (se->state == SERVICE_RUNNING)
2326 socket_set_state(s, SOCKET_RUNNING);
2329 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2330 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2333 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2334 [SOCKET_DEAD] = "dead",
2335 [SOCKET_START_PRE] = "start-pre",
2336 [SOCKET_START_POST] = "start-post",
2337 [SOCKET_LISTENING] = "listening",
2338 [SOCKET_RUNNING] = "running",
2339 [SOCKET_STOP_PRE] = "stop-pre",
2340 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2341 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2342 [SOCKET_STOP_POST] = "stop-post",
2343 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2344 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2345 [SOCKET_FAILED] = "failed"
2348 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2350 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2351 [SOCKET_EXEC_START_PRE] = "StartPre",
2352 [SOCKET_EXEC_START_POST] = "StartPost",
2353 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2354 [SOCKET_EXEC_STOP_POST] = "StopPost"
2357 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2359 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2360 [SOCKET_SUCCESS] = "success",
2361 [SOCKET_FAILURE_RESOURCES] = "resources",
2362 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2363 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2364 [SOCKET_FAILURE_SIGNAL] = "signal",
2365 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2366 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2369 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2371 const UnitVTable socket_vtable = {
2372 .object_size = sizeof(Socket),
2379 .private_section = "Socket",
2380 .exec_context_offset = offsetof(Socket, exec_context),
2381 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2383 .init = socket_init,
2384 .done = socket_done,
2385 .load = socket_load,
2387 .kill = socket_kill,
2389 .coldplug = socket_coldplug,
2391 .dump = socket_dump,
2393 .start = socket_start,
2394 .stop = socket_stop,
2396 .serialize = socket_serialize,
2397 .deserialize_item = socket_deserialize_item,
2398 .distribute_fds = socket_distribute_fds,
2400 .active_state = socket_active_state,
2401 .sub_state_to_string = socket_sub_state_to_string,
2403 .check_gc = socket_check_gc,
2405 .fd_event = socket_fd_event,
2406 .sigchld_event = socket_sigchld_event,
2407 .timer_event = socket_timer_event,
2409 .trigger_notify = socket_trigger_notify,
2411 .reset_failed = socket_reset_failed,
2413 .bus_interface = "org.freedesktop.systemd1.Socket",
2414 .bus_message_handler = bus_socket_message_handler,
2415 .bus_invalidating_properties = bus_socket_invalidating_properties,
2416 .bus_set_property = bus_socket_set_property,
2417 .bus_commit_properties = bus_socket_commit_properties,
2419 .status_message_formats = {
2420 /*.starting_stopping = {
2421 [0] = "Starting socket %s...",
2422 [1] = "Stopping socket %s...",
2424 .finished_start_job = {
2425 [JOB_DONE] = "Listening on %s.",
2426 [JOB_FAILED] = "Failed to listen on %s.",
2427 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2428 [JOB_TIMEOUT] = "Timed out starting %s.",
2430 .finished_stop_job = {
2431 [JOB_DONE] = "Closed %s.",
2432 [JOB_FAILED] = "Failed stopping %s.",
2433 [JOB_TIMEOUT] = "Timed out stopping %s.",