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 bool socket_needs_mount(Socket *s, const char *prefix) {
266 LIST_FOREACH(port, p, s->ports) {
268 if (p->type == SOCKET_SOCKET) {
269 if (socket_address_needs_mount(&p->address, prefix))
271 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
272 if (path_startswith(p->path, prefix))
280 int socket_add_one_mount_link(Socket *s, Mount *m) {
286 if (UNIT(s)->load_state != UNIT_LOADED ||
287 UNIT(m)->load_state != UNIT_LOADED)
290 if (!socket_needs_mount(s, m->where))
293 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
300 static int socket_add_mount_links(Socket *s) {
306 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
307 r = socket_add_one_mount_link(s, MOUNT(other));
315 static int socket_add_device_link(Socket *s) {
321 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
324 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
327 r = unit_add_node_link(UNIT(s), t, false);
333 static int socket_add_default_dependencies(Socket *s) {
337 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
341 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
342 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
347 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
350 _pure_ static bool socket_has_exec(Socket *s) {
354 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
355 if (s->exec_command[i])
361 static int socket_load(Unit *u) {
362 Socket *s = SOCKET(u);
366 assert(u->load_state == UNIT_STUB);
368 if ((r = unit_load_fragment_and_dropin(u)) < 0)
371 /* This is a new unit? Then let's add in some extras */
372 if (u->load_state == UNIT_LOADED) {
374 if (have_non_accept_socket(s)) {
376 if (!UNIT_DEREF(s->service)) {
379 r = unit_load_related_unit(u, ".service", &x);
383 unit_ref_set(&s->service, x);
386 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
391 if ((r = socket_add_mount_links(s)) < 0)
394 if ((r = socket_add_device_link(s)) < 0)
397 if (socket_has_exec(s))
398 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
401 r = unit_add_default_slice(u);
405 if (UNIT(s)->default_dependencies)
406 if ((r = socket_add_default_dependencies(s)) < 0)
409 r = unit_exec_context_defaults(u, &s->exec_context);
414 return socket_verify(s);
417 _const_ static const char* listen_lookup(int family, int type) {
419 if (family == AF_NETLINK)
420 return "ListenNetlink";
422 if (type == SOCK_STREAM)
423 return "ListenStream";
424 else if (type == SOCK_DGRAM)
425 return "ListenDatagram";
426 else if (type == SOCK_SEQPACKET)
427 return "ListenSequentialPacket";
429 assert_not_reached("Unknown socket type");
433 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
436 Socket *s = SOCKET(u);
444 p2 = strappend(prefix, "\t");
445 prefix2 = p2 ? p2 : prefix;
448 "%sSocket State: %s\n"
450 "%sBindIPv6Only: %s\n"
452 "%sSocketMode: %04o\n"
453 "%sDirectoryMode: %04o\n"
456 "%sTransparent: %s\n"
458 "%sPassCredentials: %s\n"
459 "%sPassSecurity: %s\n"
460 "%sTCPCongestion: %s\n",
461 prefix, socket_state_to_string(s->state),
462 prefix, socket_result_to_string(s->result),
463 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
465 prefix, s->socket_mode,
466 prefix, s->directory_mode,
467 prefix, yes_no(s->keep_alive),
468 prefix, yes_no(s->free_bind),
469 prefix, yes_no(s->transparent),
470 prefix, yes_no(s->broadcast),
471 prefix, yes_no(s->pass_cred),
472 prefix, yes_no(s->pass_sec),
473 prefix, strna(s->tcp_congestion));
475 if (s->control_pid > 0)
477 "%sControl PID: %lu\n",
478 prefix, (unsigned long) s->control_pid);
480 if (s->bind_to_device)
482 "%sBindToDevice: %s\n",
483 prefix, s->bind_to_device);
488 "%sNConnections: %u\n"
489 "%sMaxConnections: %u\n",
490 prefix, s->n_accepted,
491 prefix, s->n_connections,
492 prefix, s->max_connections);
494 if (s->priority >= 0)
497 prefix, s->priority);
499 if (s->receive_buffer > 0)
501 "%sReceiveBuffer: %zu\n",
502 prefix, s->receive_buffer);
504 if (s->send_buffer > 0)
506 "%sSendBuffer: %zu\n",
507 prefix, s->send_buffer);
519 if (s->pipe_size > 0)
522 prefix, s->pipe_size);
529 if (s->mq_maxmsg > 0)
531 "%sMessageQueueMaxMessages: %li\n",
532 prefix, s->mq_maxmsg);
534 if (s->mq_msgsize > 0)
536 "%sMessageQueueMessageSize: %li\n",
537 prefix, s->mq_msgsize);
542 prefix, yes_no(s->reuseport));
546 "%sSmackLabel: %s\n",
551 "%sSmackLabelIPIn: %s\n",
552 prefix, s->smack_ip_in);
556 "%sSmackLabelIPOut: %s\n",
557 prefix, s->smack_ip_out);
559 LIST_FOREACH(port, p, s->ports) {
561 if (p->type == SOCKET_SOCKET) {
566 if ((r = socket_address_print(&p->address, &k)) < 0)
571 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
573 } else if (p->type == SOCKET_SPECIAL)
574 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
575 else if (p->type == SOCKET_MQUEUE)
576 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
578 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
581 exec_context_dump(&s->exec_context, f, prefix);
582 kill_context_dump(&s->kill_context, f, prefix);
584 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
585 if (!s->exec_command[c])
588 fprintf(f, "%s-> %s:\n",
589 prefix, socket_exec_command_to_string(c));
591 exec_command_dump_list(s->exec_command[c], f, prefix2);
597 static int instance_from_socket(int fd, unsigned nr, char **instance) {
602 struct sockaddr_un un;
603 struct sockaddr_in in;
604 struct sockaddr_in6 in6;
605 struct sockaddr_storage storage;
612 if (getsockname(fd, &local.sa, &l) < 0)
616 if (getpeername(fd, &remote.sa, &l) < 0)
619 switch (local.sa.sa_family) {
623 a = ntohl(local.in.sin_addr.s_addr),
624 b = ntohl(remote.in.sin_addr.s_addr);
627 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
629 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
630 ntohs(local.in.sin_port),
631 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
632 ntohs(remote.in.sin_port)) < 0)
639 static const unsigned char ipv4_prefix[] = {
640 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
643 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
644 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
646 *a = local.in6.sin6_addr.s6_addr+12,
647 *b = remote.in6.sin6_addr.s6_addr+12;
650 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
652 a[0], a[1], a[2], a[3],
653 ntohs(local.in6.sin6_port),
654 b[0], b[1], b[2], b[3],
655 ntohs(remote.in6.sin6_port)) < 0)
658 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
663 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
664 ntohs(local.in6.sin6_port),
665 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
666 ntohs(remote.in6.sin6_port)) < 0)
677 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
683 (unsigned long) ucred.pid,
684 (unsigned long) ucred.uid) < 0)
691 assert_not_reached("Unhandled socket type.");
698 static void socket_close_fds(Socket *s) {
703 LIST_FOREACH(port, p, s->ports) {
707 unit_unwatch_fd(UNIT(s), &p->fd_watch);
708 close_nointr_nofail(p->fd);
710 /* One little note: we should never delete any sockets
711 * in the file system here! After all some other
712 * process we spawned might still have a reference of
713 * this fd and wants to continue to use it. Therefore
714 * we delete sockets in the file system before we
715 * create a new one, not after we stopped using
722 static void socket_apply_socket_options(Socket *s, int fd) {
727 int b = s->keep_alive;
728 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
729 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
734 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
735 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
740 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
741 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
746 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
747 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
750 if (s->priority >= 0)
751 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
752 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
754 if (s->receive_buffer > 0) {
755 int value = (int) s->receive_buffer;
757 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
759 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
760 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
761 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
764 if (s->send_buffer > 0) {
765 int value = (int) s->send_buffer;
766 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
767 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
768 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
772 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
773 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
776 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
777 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
779 if (s->ip_ttl >= 0) {
782 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
784 if (socket_ipv6_is_supported())
785 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
788 errno = EAFNOSUPPORT;
792 log_warning_unit(UNIT(s)->id,
793 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
796 if (s->tcp_congestion)
797 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
798 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
801 int b = s->reuseport;
802 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)))
803 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
808 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
809 log_error_unit(UNIT(s)->id,
810 "fsetxattr(\"security.SMACK64IPIN\"): %m");
813 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
814 log_error_unit(UNIT(s)->id,
815 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
819 static void socket_apply_fifo_options(Socket *s, int fd) {
823 if (s->pipe_size > 0)
824 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
825 log_warning_unit(UNIT(s)->id,
830 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
831 log_error_unit(UNIT(s)->id,
832 "fsetxattr(\"security.SMACK64\"): %m");
836 static int fifo_address_create(
838 mode_t directory_mode,
849 mkdir_parents_label(path, directory_mode);
851 r = label_context_set(path, S_IFIFO);
855 /* Enforce the right access mode for the fifo */
856 old_mask = umask(~ socket_mode);
858 /* Include the original umask in our mask */
859 umask(~socket_mode | old_mask);
861 r = mkfifo(path, socket_mode);
864 if (r < 0 && errno != EEXIST) {
869 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
874 label_context_clear();
876 if (fstat(fd, &st) < 0) {
881 if (!S_ISFIFO(st.st_mode) ||
882 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
883 st.st_uid != getuid() ||
884 st.st_gid != getgid()) {
894 label_context_clear();
897 close_nointr_nofail(fd);
902 static int special_address_create(
912 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
917 if (fstat(fd, &st) < 0) {
922 /* Check whether this is a /proc, /sys or /dev file or char device */
923 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
933 close_nointr_nofail(fd);
938 static int mq_address_create(
948 struct mq_attr _attr, *attr = NULL;
953 if (maxmsg > 0 && msgsize > 0) {
955 _attr.mq_flags = O_NONBLOCK;
956 _attr.mq_maxmsg = maxmsg;
957 _attr.mq_msgsize = msgsize;
961 /* Enforce the right access mode for the mq */
962 old_mask = umask(~ mq_mode);
964 /* Include the original umask in our mask */
965 umask(~mq_mode | old_mask);
967 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
975 if (fstat(fd, &st) < 0) {
980 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
981 st.st_uid != getuid() ||
982 st.st_gid != getgid()) {
993 close_nointr_nofail(fd);
998 static int socket_open_fds(Socket *s) {
1002 bool know_label = false;
1006 LIST_FOREACH(port, p, s->ports) {
1011 if (p->type == SOCKET_SOCKET) {
1015 if ((r = socket_instantiate_service(s)) < 0)
1018 if (UNIT_ISSET(s->service) &&
1019 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1020 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1031 if ((r = socket_address_listen(
1044 socket_apply_socket_options(s, p->fd);
1046 } else if (p->type == SOCKET_SPECIAL) {
1048 if ((r = special_address_create(
1053 } else if (p->type == SOCKET_FIFO) {
1055 if ((r = fifo_address_create(
1062 socket_apply_fifo_options(s, p->fd);
1063 } else if (p->type == SOCKET_MQUEUE) {
1065 if ((r = mq_address_create(
1073 assert_not_reached("Unknown port type");
1080 socket_close_fds(s);
1085 static void socket_unwatch_fds(Socket *s) {
1090 LIST_FOREACH(port, p, s->ports) {
1094 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1098 static int socket_watch_fds(Socket *s) {
1104 LIST_FOREACH(port, p, s->ports) {
1108 p->fd_watch.socket_accept =
1110 p->type == SOCKET_SOCKET &&
1111 socket_address_can_accept(&p->address);
1113 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1120 socket_unwatch_fds(s);
1124 static void socket_set_state(Socket *s, SocketState state) {
1125 SocketState old_state;
1128 old_state = s->state;
1131 if (state != SOCKET_START_PRE &&
1132 state != SOCKET_START_POST &&
1133 state != SOCKET_STOP_PRE &&
1134 state != SOCKET_STOP_PRE_SIGTERM &&
1135 state != SOCKET_STOP_PRE_SIGKILL &&
1136 state != SOCKET_STOP_POST &&
1137 state != SOCKET_FINAL_SIGTERM &&
1138 state != SOCKET_FINAL_SIGKILL) {
1139 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1140 socket_unwatch_control_pid(s);
1141 s->control_command = NULL;
1142 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1145 if (state != SOCKET_LISTENING)
1146 socket_unwatch_fds(s);
1148 if (state != SOCKET_START_POST &&
1149 state != SOCKET_LISTENING &&
1150 state != SOCKET_RUNNING &&
1151 state != SOCKET_STOP_PRE &&
1152 state != SOCKET_STOP_PRE_SIGTERM &&
1153 state != SOCKET_STOP_PRE_SIGKILL)
1154 socket_close_fds(s);
1156 if (state != old_state)
1157 log_debug_unit(UNIT(s)->id,
1158 "%s changed %s -> %s", UNIT(s)->id,
1159 socket_state_to_string(old_state),
1160 socket_state_to_string(state));
1162 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1165 static int socket_coldplug(Unit *u) {
1166 Socket *s = SOCKET(u);
1170 assert(s->state == SOCKET_DEAD);
1172 if (s->deserialized_state != s->state) {
1174 if (s->deserialized_state == SOCKET_START_PRE ||
1175 s->deserialized_state == SOCKET_START_POST ||
1176 s->deserialized_state == SOCKET_STOP_PRE ||
1177 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1178 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1179 s->deserialized_state == SOCKET_STOP_POST ||
1180 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1181 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1183 if (s->control_pid <= 0)
1186 r = unit_watch_pid(UNIT(s), s->control_pid);
1190 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1195 if (s->deserialized_state == SOCKET_START_POST ||
1196 s->deserialized_state == SOCKET_LISTENING ||
1197 s->deserialized_state == SOCKET_RUNNING ||
1198 s->deserialized_state == SOCKET_STOP_PRE ||
1199 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1200 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1201 if ((r = socket_open_fds(s)) < 0)
1204 if (s->deserialized_state == SOCKET_LISTENING)
1205 if ((r = socket_watch_fds(s)) < 0)
1208 socket_set_state(s, s->deserialized_state);
1214 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1223 unit_realize_cgroup(UNIT(s));
1225 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1229 argv = unit_full_printf_strv(UNIT(s), c->argv);
1239 UNIT(s)->manager->environment,
1243 UNIT(s)->manager->confirm_spawn,
1244 UNIT(s)->cgroup_mask,
1245 UNIT(s)->cgroup_path,
1254 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1255 /* FIXME: we need to do something here */
1263 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1268 static void socket_enter_dead(Socket *s, SocketResult f) {
1271 if (f != SOCKET_SUCCESS)
1274 exec_context_tmp_dirs_done(&s->exec_context);
1275 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1278 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1280 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1284 if (f != SOCKET_SUCCESS)
1287 socket_unwatch_control_pid(s);
1289 s->control_command_id = SOCKET_EXEC_STOP_POST;
1291 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1292 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1295 socket_set_state(s, SOCKET_STOP_POST);
1297 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1302 log_warning_unit(UNIT(s)->id,
1303 "%s failed to run 'stop-post' task: %s",
1304 UNIT(s)->id, strerror(-r));
1305 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1308 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1313 if (f != SOCKET_SUCCESS)
1316 r = unit_kill_context(
1319 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1327 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1331 socket_set_state(s, state);
1332 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1333 socket_enter_stop_post(s, SOCKET_SUCCESS);
1335 socket_enter_dead(s, SOCKET_SUCCESS);
1340 log_warning_unit(UNIT(s)->id,
1341 "%s failed to kill processes: %s",
1342 UNIT(s)->id, strerror(-r));
1344 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1345 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1347 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1350 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1354 if (f != SOCKET_SUCCESS)
1357 socket_unwatch_control_pid(s);
1359 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1361 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1362 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1365 socket_set_state(s, SOCKET_STOP_PRE);
1367 socket_enter_stop_post(s, SOCKET_SUCCESS);
1372 log_warning_unit(UNIT(s)->id,
1373 "%s failed to run 'stop-pre' task: %s",
1374 UNIT(s)->id, strerror(-r));
1375 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1378 static void socket_enter_listening(Socket *s) {
1382 r = socket_watch_fds(s);
1384 log_warning_unit(UNIT(s)->id,
1385 "%s failed to watch sockets: %s",
1386 UNIT(s)->id, strerror(-r));
1390 socket_set_state(s, SOCKET_LISTENING);
1394 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1397 static void socket_enter_start_post(Socket *s) {
1401 r = socket_open_fds(s);
1403 log_warning_unit(UNIT(s)->id,
1404 "%s failed to listen on sockets: %s",
1405 UNIT(s)->id, strerror(-r));
1409 socket_unwatch_control_pid(s);
1411 s->control_command_id = SOCKET_EXEC_START_POST;
1413 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1414 r = socket_spawn(s, s->control_command, &s->control_pid);
1416 log_warning_unit(UNIT(s)->id,
1417 "%s failed to run 'start-post' task: %s",
1418 UNIT(s)->id, strerror(-r));
1422 socket_set_state(s, SOCKET_START_POST);
1424 socket_enter_listening(s);
1429 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1432 static void socket_enter_start_pre(Socket *s) {
1436 socket_unwatch_control_pid(s);
1438 s->control_command_id = SOCKET_EXEC_START_PRE;
1440 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1441 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1444 socket_set_state(s, SOCKET_START_PRE);
1446 socket_enter_start_post(s);
1451 log_warning_unit(UNIT(s)->id,
1452 "%s failed to run 'start-pre' task: %s",
1453 UNIT(s)->id, strerror(-r));
1454 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1457 static void socket_enter_running(Socket *s, int cfd) {
1462 dbus_error_init(&error);
1464 /* We don't take connections anymore if we are supposed to
1465 * shut down anyway */
1466 if (unit_stop_pending(UNIT(s))) {
1467 log_debug_unit(UNIT(s)->id,
1468 "Suppressing connection request on %s since unit stop is scheduled.",
1472 close_nointr_nofail(cfd);
1474 /* Flush all sockets by closing and reopening them */
1475 socket_close_fds(s);
1477 r = socket_watch_fds(s);
1479 log_warning_unit(UNIT(s)->id,
1480 "%s failed to watch sockets: %s",
1481 UNIT(s)->id, strerror(-r));
1482 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1492 bool pending = false;
1494 /* If there's already a start pending don't bother to
1496 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1497 if (unit_active_or_pending(u)) {
1503 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1508 socket_set_state(s, SOCKET_RUNNING);
1510 char *prefix, *instance = NULL, *name;
1513 if (s->n_connections >= s->max_connections) {
1514 log_warning_unit(UNIT(s)->id,
1515 "%s: Too many incoming connections (%u)",
1516 UNIT(s)->id, s->n_connections);
1517 close_nointr_nofail(cfd);
1521 r = socket_instantiate_service(s);
1525 r = instance_from_socket(cfd, s->n_accepted, &instance);
1530 /* ENOTCONN is legitimate if TCP RST was received.
1531 * This connection is over, but the socket unit lives on. */
1532 close_nointr_nofail(cfd);
1536 prefix = unit_name_to_prefix(UNIT(s)->id);
1543 name = unit_name_build(prefix, instance, ".service");
1552 r = unit_add_name(UNIT_DEREF(s->service), name);
1558 service = SERVICE(UNIT_DEREF(s->service));
1559 unit_ref_unset(&s->service);
1562 UNIT(service)->no_gc = false;
1564 unit_choose_id(UNIT(service), name);
1567 r = service_set_socket_fd(service, cfd, s);
1572 s->n_connections ++;
1574 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1578 /* Notify clients about changed counters */
1579 unit_add_to_dbus_queue(UNIT(s));
1585 log_warning_unit(UNIT(s)->id,
1586 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1588 cfd >= 0 ? "template" : "non-template",
1589 bus_error(&error, r));
1590 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1593 close_nointr_nofail(cfd);
1595 dbus_error_free(&error);
1598 static void socket_run_next(Socket *s) {
1602 assert(s->control_command);
1603 assert(s->control_command->command_next);
1605 socket_unwatch_control_pid(s);
1607 s->control_command = s->control_command->command_next;
1609 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1615 log_warning_unit(UNIT(s)->id,
1616 "%s failed to run next task: %s",
1617 UNIT(s)->id, strerror(-r));
1619 if (s->state == SOCKET_START_POST)
1620 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1621 else if (s->state == SOCKET_STOP_POST)
1622 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1624 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1627 static int socket_start(Unit *u) {
1628 Socket *s = SOCKET(u);
1632 /* We cannot fulfill this request right now, try again later
1634 if (s->state == SOCKET_STOP_PRE ||
1635 s->state == SOCKET_STOP_PRE_SIGKILL ||
1636 s->state == SOCKET_STOP_PRE_SIGTERM ||
1637 s->state == SOCKET_STOP_POST ||
1638 s->state == SOCKET_FINAL_SIGTERM ||
1639 s->state == SOCKET_FINAL_SIGKILL)
1642 if (s->state == SOCKET_START_PRE ||
1643 s->state == SOCKET_START_POST)
1646 /* Cannot run this without the service being around */
1647 if (UNIT_ISSET(s->service)) {
1650 service = SERVICE(UNIT_DEREF(s->service));
1652 if (UNIT(service)->load_state != UNIT_LOADED) {
1653 log_error_unit(u->id,
1654 "Socket service %s not loaded, refusing.",
1659 /* If the service is already active we cannot start the
1661 if (service->state != SERVICE_DEAD &&
1662 service->state != SERVICE_FAILED &&
1663 service->state != SERVICE_AUTO_RESTART) {
1664 log_error_unit(u->id,
1665 "Socket service %s already active, refusing.",
1670 #ifdef HAVE_SYSV_COMPAT
1671 if (service->is_sysv) {
1672 log_error_unit(u->id,
1673 "Using SysV services for socket activation is not supported. Refusing.");
1679 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1681 s->result = SOCKET_SUCCESS;
1682 socket_enter_start_pre(s);
1686 static int socket_stop(Unit *u) {
1687 Socket *s = SOCKET(u);
1692 if (s->state == SOCKET_STOP_PRE ||
1693 s->state == SOCKET_STOP_PRE_SIGTERM ||
1694 s->state == SOCKET_STOP_PRE_SIGKILL ||
1695 s->state == SOCKET_STOP_POST ||
1696 s->state == SOCKET_FINAL_SIGTERM ||
1697 s->state == SOCKET_FINAL_SIGKILL)
1700 /* If there's already something running we go directly into
1702 if (s->state == SOCKET_START_PRE ||
1703 s->state == SOCKET_START_POST) {
1704 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1708 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1710 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1714 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1715 Socket *s = SOCKET(u);
1723 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1724 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1725 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1727 if (s->control_pid > 0)
1728 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1730 if (s->control_command_id >= 0)
1731 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1733 LIST_FOREACH(port, p, s->ports) {
1739 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1742 if (p->type == SOCKET_SOCKET) {
1745 r = socket_address_print(&p->address, &t);
1749 if (socket_address_family(&p->address) == AF_NETLINK)
1750 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1752 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1754 } else if (p->type == SOCKET_SPECIAL)
1755 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1756 else if (p->type == SOCKET_MQUEUE)
1757 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1759 assert(p->type == SOCKET_FIFO);
1760 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1764 exec_context_serialize(&s->exec_context, UNIT(s), f);
1769 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1770 Socket *s = SOCKET(u);
1777 if (streq(key, "state")) {
1780 state = socket_state_from_string(value);
1782 log_debug_unit(u->id,
1783 "Failed to parse state value %s", value);
1785 s->deserialized_state = state;
1786 } else if (streq(key, "result")) {
1789 f = socket_result_from_string(value);
1791 log_debug_unit(u->id,
1792 "Failed to parse result value %s", value);
1793 else if (f != SOCKET_SUCCESS)
1796 } else if (streq(key, "n-accepted")) {
1799 if (safe_atou(value, &k) < 0)
1800 log_debug_unit(u->id,
1801 "Failed to parse n-accepted value %s", value);
1804 } else if (streq(key, "control-pid")) {
1807 if (parse_pid(value, &pid) < 0)
1808 log_debug_unit(u->id,
1809 "Failed to parse control-pid value %s", value);
1811 s->control_pid = pid;
1812 } else if (streq(key, "control-command")) {
1813 SocketExecCommand id;
1815 id = socket_exec_command_from_string(value);
1817 log_debug_unit(u->id,
1818 "Failed to parse exec-command value %s", value);
1820 s->control_command_id = id;
1821 s->control_command = s->exec_command[id];
1823 } else if (streq(key, "fifo")) {
1827 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1828 log_debug_unit(u->id,
1829 "Failed to parse fifo value %s", value);
1832 LIST_FOREACH(port, p, s->ports)
1833 if (p->type == SOCKET_FIFO &&
1834 streq_ptr(p->path, value+skip))
1839 close_nointr_nofail(p->fd);
1840 p->fd = fdset_remove(fds, fd);
1844 } else if (streq(key, "special")) {
1848 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1849 log_debug_unit(u->id,
1850 "Failed to parse special value %s", value);
1853 LIST_FOREACH(port, p, s->ports)
1854 if (p->type == SOCKET_SPECIAL &&
1855 streq_ptr(p->path, value+skip))
1860 close_nointr_nofail(p->fd);
1861 p->fd = fdset_remove(fds, fd);
1865 } else if (streq(key, "mqueue")) {
1869 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1870 log_debug_unit(u->id,
1871 "Failed to parse mqueue value %s", value);
1874 LIST_FOREACH(port, p, s->ports)
1875 if (p->type == SOCKET_MQUEUE &&
1876 streq_ptr(p->path, value+skip))
1881 close_nointr_nofail(p->fd);
1882 p->fd = fdset_remove(fds, fd);
1886 } else if (streq(key, "socket")) {
1887 int fd, type, skip = 0;
1890 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1891 log_debug_unit(u->id,
1892 "Failed to parse socket value %s", value);
1895 LIST_FOREACH(port, p, s->ports)
1896 if (socket_address_is(&p->address, value+skip, type))
1901 close_nointr_nofail(p->fd);
1902 p->fd = fdset_remove(fds, fd);
1906 } else if (streq(key, "netlink")) {
1910 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1911 log_debug_unit(u->id,
1912 "Failed to parse socket value %s", value);
1915 LIST_FOREACH(port, p, s->ports)
1916 if (socket_address_is_netlink(&p->address, value+skip))
1921 close_nointr_nofail(p->fd);
1922 p->fd = fdset_remove(fds, fd);
1925 } else if (streq(key, "tmp-dir")) {
1932 s->exec_context.tmp_dir = t;
1933 } else if (streq(key, "var-tmp-dir")) {
1940 s->exec_context.var_tmp_dir = t;
1942 log_debug_unit(UNIT(s)->id,
1943 "Unknown serialization key '%s'", key);
1948 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1949 Socket *s = SOCKET(u);
1954 LIST_FOREACH(port, p, s->ports) {
1958 if (p->type != SOCKET_SOCKET)
1964 FDSET_FOREACH(fd, fds, i) {
1965 if (socket_address_matches_fd(&p->address, fd)) {
1966 p->fd = fdset_remove(fds, fd);
1967 s->deserialized_state = SOCKET_LISTENING;
1976 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1979 return state_translation_table[SOCKET(u)->state];
1982 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1985 return socket_state_to_string(SOCKET(u)->state);
1988 const char* socket_port_type_to_string(SocketPort *p) {
1994 switch (p->address.type) {
1995 case SOCK_STREAM: return "Stream";
1996 case SOCK_DGRAM: return "Datagram";
1997 case SOCK_SEQPACKET: return "SequentialPacket";
1999 if (socket_address_family(&p->address) == AF_NETLINK)
2001 default: return "Invalid";
2003 case SOCKET_SPECIAL: return "Special";
2004 case SOCKET_MQUEUE: return "MessageQueue";
2005 case SOCKET_FIFO: return "FIFO";
2006 default: return NULL;
2010 _pure_ static bool socket_check_gc(Unit *u) {
2011 Socket *s = SOCKET(u);
2015 return s->n_connections > 0;
2018 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2019 Socket *s = SOCKET(u);
2025 if (s->state != SOCKET_LISTENING)
2028 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2030 if (events != EPOLLIN) {
2032 if (events & EPOLLHUP)
2033 log_error_unit(u->id,
2034 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2037 log_error_unit(u->id,
2038 "%s: Got unexpected poll event (0x%x) on socket.",
2044 if (w->socket_accept) {
2047 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2053 log_error_unit(u->id,
2054 "Failed to accept socket: %m");
2061 socket_apply_socket_options(s, cfd);
2064 socket_enter_running(s, cfd);
2068 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2071 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2072 Socket *s = SOCKET(u);
2078 if (pid != s->control_pid)
2083 if (is_clean_exit(code, status, NULL))
2085 else if (code == CLD_EXITED)
2086 f = SOCKET_FAILURE_EXIT_CODE;
2087 else if (code == CLD_KILLED)
2088 f = SOCKET_FAILURE_SIGNAL;
2089 else if (code == CLD_DUMPED)
2090 f = SOCKET_FAILURE_CORE_DUMP;
2092 assert_not_reached("Unknown code");
2094 if (s->control_command) {
2095 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2097 if (s->control_command->ignore)
2101 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2103 "%s control process exited, code=%s status=%i",
2104 u->id, sigchld_code_to_string(code), status);
2106 if (f != SOCKET_SUCCESS)
2109 if (s->control_command &&
2110 s->control_command->command_next &&
2111 f == SOCKET_SUCCESS) {
2113 log_debug_unit(u->id,
2114 "%s running next command for state %s",
2115 u->id, socket_state_to_string(s->state));
2118 s->control_command = NULL;
2119 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2121 /* No further commands for this step, so let's figure
2122 * out what to do next */
2124 log_debug_unit(u->id,
2125 "%s got final SIGCHLD for state %s",
2126 u->id, socket_state_to_string(s->state));
2130 case SOCKET_START_PRE:
2131 if (f == SOCKET_SUCCESS)
2132 socket_enter_start_post(s);
2134 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2137 case SOCKET_START_POST:
2138 if (f == SOCKET_SUCCESS)
2139 socket_enter_listening(s);
2141 socket_enter_stop_pre(s, f);
2144 case SOCKET_STOP_PRE:
2145 case SOCKET_STOP_PRE_SIGTERM:
2146 case SOCKET_STOP_PRE_SIGKILL:
2147 socket_enter_stop_post(s, f);
2150 case SOCKET_STOP_POST:
2151 case SOCKET_FINAL_SIGTERM:
2152 case SOCKET_FINAL_SIGKILL:
2153 socket_enter_dead(s, f);
2157 assert_not_reached("Uh, control process died at wrong time.");
2161 /* Notify clients about changed exit status */
2162 unit_add_to_dbus_queue(u);
2165 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2166 Socket *s = SOCKET(u);
2169 assert(elapsed == 1);
2170 assert(w == &s->timer_watch);
2174 case SOCKET_START_PRE:
2175 log_warning_unit(u->id,
2176 "%s starting timed out. Terminating.", u->id);
2177 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2180 case SOCKET_START_POST:
2181 log_warning_unit(u->id,
2182 "%s starting timed out. Stopping.", u->id);
2183 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2186 case SOCKET_STOP_PRE:
2187 log_warning_unit(u->id,
2188 "%s stopping timed out. Terminating.", u->id);
2189 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2192 case SOCKET_STOP_PRE_SIGTERM:
2193 if (s->kill_context.send_sigkill) {
2194 log_warning_unit(u->id,
2195 "%s stopping timed out. Killing.", u->id);
2196 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2198 log_warning_unit(u->id,
2199 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2201 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2205 case SOCKET_STOP_PRE_SIGKILL:
2206 log_warning_unit(u->id,
2207 "%s still around after SIGKILL. Ignoring.", u->id);
2208 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2211 case SOCKET_STOP_POST:
2212 log_warning_unit(u->id,
2213 "%s stopping timed out (2). Terminating.", u->id);
2214 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2217 case SOCKET_FINAL_SIGTERM:
2218 if (s->kill_context.send_sigkill) {
2219 log_warning_unit(u->id,
2220 "%s stopping timed out (2). Killing.", u->id);
2221 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2223 log_warning_unit(u->id,
2224 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2226 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2230 case SOCKET_FINAL_SIGKILL:
2231 log_warning_unit(u->id,
2232 "%s still around after SIGKILL (2). Entering failed mode.",
2234 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2238 assert_not_reached("Timeout at wrong time.");
2242 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2251 /* Called from the service code for requesting our fds */
2254 LIST_FOREACH(port, p, s->ports)
2264 if (!(rfds = new(int, rn_fds)))
2268 LIST_FOREACH(port, p, s->ports)
2272 assert(k == rn_fds);
2280 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2283 /* The service is dead. Dang!
2285 * This is strictly for one-instance-for-all-connections
2288 if (s->state == SOCKET_RUNNING) {
2289 log_debug_unit(UNIT(s)->id,
2290 "%s got notified about service death (failed permanently: %s)",
2291 UNIT(s)->id, yes_no(failed_permanent));
2292 if (failed_permanent)
2293 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2295 socket_enter_listening(s);
2299 void socket_connection_unref(Socket *s) {
2302 /* The service is dead. Yay!
2304 * This is strictly for one-instance-per-connection
2307 assert(s->n_connections > 0);
2310 log_debug_unit(UNIT(s)->id,
2311 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2314 static void socket_reset_failed(Unit *u) {
2315 Socket *s = SOCKET(u);
2319 if (s->state == SOCKET_FAILED)
2320 socket_set_state(s, SOCKET_DEAD);
2322 s->result = SOCKET_SUCCESS;
2325 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2326 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2329 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2330 [SOCKET_DEAD] = "dead",
2331 [SOCKET_START_PRE] = "start-pre",
2332 [SOCKET_START_POST] = "start-post",
2333 [SOCKET_LISTENING] = "listening",
2334 [SOCKET_RUNNING] = "running",
2335 [SOCKET_STOP_PRE] = "stop-pre",
2336 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2337 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2338 [SOCKET_STOP_POST] = "stop-post",
2339 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2340 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2341 [SOCKET_FAILED] = "failed"
2344 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2346 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2347 [SOCKET_EXEC_START_PRE] = "StartPre",
2348 [SOCKET_EXEC_START_POST] = "StartPost",
2349 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2350 [SOCKET_EXEC_STOP_POST] = "StopPost"
2353 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2355 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2356 [SOCKET_SUCCESS] = "success",
2357 [SOCKET_FAILURE_RESOURCES] = "resources",
2358 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2359 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2360 [SOCKET_FAILURE_SIGNAL] = "signal",
2361 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2362 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2365 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2367 const UnitVTable socket_vtable = {
2368 .object_size = sizeof(Socket),
2375 .private_section = "Socket",
2376 .exec_context_offset = offsetof(Socket, exec_context),
2377 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2379 .init = socket_init,
2380 .done = socket_done,
2381 .load = socket_load,
2383 .kill = socket_kill,
2385 .coldplug = socket_coldplug,
2387 .dump = socket_dump,
2389 .start = socket_start,
2390 .stop = socket_stop,
2392 .serialize = socket_serialize,
2393 .deserialize_item = socket_deserialize_item,
2394 .distribute_fds = socket_distribute_fds,
2396 .active_state = socket_active_state,
2397 .sub_state_to_string = socket_sub_state_to_string,
2399 .check_gc = socket_check_gc,
2401 .fd_event = socket_fd_event,
2402 .sigchld_event = socket_sigchld_event,
2403 .timer_event = socket_timer_event,
2405 .reset_failed = socket_reset_failed,
2407 .bus_interface = "org.freedesktop.systemd1.Socket",
2408 .bus_message_handler = bus_socket_message_handler,
2409 .bus_invalidating_properties = bus_socket_invalidating_properties,
2410 .bus_set_property = bus_socket_set_property,
2411 .bus_commit_properties = bus_socket_commit_properties,
2413 .status_message_formats = {
2414 /*.starting_stopping = {
2415 [0] = "Starting socket %s...",
2416 [1] = "Stopping socket %s...",
2418 .finished_start_job = {
2419 [JOB_DONE] = "Listening on %s.",
2420 [JOB_FAILED] = "Failed to listen on %s.",
2421 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2422 [JOB_TIMEOUT] = "Timed out starting %s.",
2424 .finished_stop_job = {
2425 [JOB_DONE] = "Closed %s.",
2426 [JOB_FAILED] = "Failed stopping %s.",
2427 [JOB_TIMEOUT] = "Timed out stopping %s.",