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);
541 "%sSmackLabel: %s\n",
546 "%sSmackLabelIPIn: %s\n",
547 prefix, s->smack_ip_in);
551 "%sSmackLabelIPOut: %s\n",
552 prefix, s->smack_ip_out);
554 LIST_FOREACH(port, p, s->ports) {
556 if (p->type == SOCKET_SOCKET) {
561 if ((r = socket_address_print(&p->address, &k)) < 0)
566 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
568 } else if (p->type == SOCKET_SPECIAL)
569 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
570 else if (p->type == SOCKET_MQUEUE)
571 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
573 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
576 exec_context_dump(&s->exec_context, f, prefix);
577 kill_context_dump(&s->kill_context, f, prefix);
579 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
580 if (!s->exec_command[c])
583 fprintf(f, "%s-> %s:\n",
584 prefix, socket_exec_command_to_string(c));
586 exec_command_dump_list(s->exec_command[c], f, prefix2);
592 static int instance_from_socket(int fd, unsigned nr, char **instance) {
597 struct sockaddr_un un;
598 struct sockaddr_in in;
599 struct sockaddr_in6 in6;
600 struct sockaddr_storage storage;
607 if (getsockname(fd, &local.sa, &l) < 0)
611 if (getpeername(fd, &remote.sa, &l) < 0)
614 switch (local.sa.sa_family) {
618 a = ntohl(local.in.sin_addr.s_addr),
619 b = ntohl(remote.in.sin_addr.s_addr);
622 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
624 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
625 ntohs(local.in.sin_port),
626 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
627 ntohs(remote.in.sin_port)) < 0)
634 static const unsigned char ipv4_prefix[] = {
635 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
638 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
639 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
641 *a = local.in6.sin6_addr.s6_addr+12,
642 *b = remote.in6.sin6_addr.s6_addr+12;
645 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
647 a[0], a[1], a[2], a[3],
648 ntohs(local.in6.sin6_port),
649 b[0], b[1], b[2], b[3],
650 ntohs(remote.in6.sin6_port)) < 0)
653 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
658 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
659 ntohs(local.in6.sin6_port),
660 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
661 ntohs(remote.in6.sin6_port)) < 0)
672 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
678 (unsigned long) ucred.pid,
679 (unsigned long) ucred.uid) < 0)
686 assert_not_reached("Unhandled socket type.");
693 static void socket_close_fds(Socket *s) {
698 LIST_FOREACH(port, p, s->ports) {
702 unit_unwatch_fd(UNIT(s), &p->fd_watch);
703 close_nointr_nofail(p->fd);
705 /* One little note: we should never delete any sockets
706 * in the file system here! After all some other
707 * process we spawned might still have a reference of
708 * this fd and wants to continue to use it. Therefore
709 * we delete sockets in the file system before we
710 * create a new one, not after we stopped using
717 static void socket_apply_socket_options(Socket *s, int fd) {
722 int b = s->keep_alive;
723 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
729 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
741 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
742 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
745 if (s->priority >= 0)
746 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
747 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
749 if (s->receive_buffer > 0) {
750 int value = (int) s->receive_buffer;
752 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
754 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
755 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
756 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
759 if (s->send_buffer > 0) {
760 int value = (int) s->send_buffer;
761 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
762 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
763 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
767 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
768 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
771 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
772 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
774 if (s->ip_ttl >= 0) {
777 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
779 if (socket_ipv6_is_supported())
780 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
783 errno = EAFNOSUPPORT;
787 log_warning_unit(UNIT(s)->id,
788 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
791 if (s->tcp_congestion)
792 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
793 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
797 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
798 log_error_unit(UNIT(s)->id,
799 "fsetxattr(\"security.SMACK64IPIN\"): %m");
802 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
803 log_error_unit(UNIT(s)->id,
804 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
808 static void socket_apply_fifo_options(Socket *s, int fd) {
812 if (s->pipe_size > 0)
813 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
814 log_warning_unit(UNIT(s)->id,
819 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
820 log_error_unit(UNIT(s)->id,
821 "fsetxattr(\"security.SMACK64\"): %m");
825 static int fifo_address_create(
827 mode_t directory_mode,
838 mkdir_parents_label(path, directory_mode);
840 r = label_context_set(path, S_IFIFO);
844 /* Enforce the right access mode for the fifo */
845 old_mask = umask(~ socket_mode);
847 /* Include the original umask in our mask */
848 umask(~socket_mode | old_mask);
850 r = mkfifo(path, socket_mode);
853 if (r < 0 && errno != EEXIST) {
858 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
863 label_context_clear();
865 if (fstat(fd, &st) < 0) {
870 if (!S_ISFIFO(st.st_mode) ||
871 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
872 st.st_uid != getuid() ||
873 st.st_gid != getgid()) {
883 label_context_clear();
886 close_nointr_nofail(fd);
891 static int special_address_create(
901 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
906 if (fstat(fd, &st) < 0) {
911 /* Check whether this is a /proc, /sys or /dev file or char device */
912 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
922 close_nointr_nofail(fd);
927 static int mq_address_create(
937 struct mq_attr _attr, *attr = NULL;
942 if (maxmsg > 0 && msgsize > 0) {
944 _attr.mq_flags = O_NONBLOCK;
945 _attr.mq_maxmsg = maxmsg;
946 _attr.mq_msgsize = msgsize;
950 /* Enforce the right access mode for the mq */
951 old_mask = umask(~ mq_mode);
953 /* Include the original umask in our mask */
954 umask(~mq_mode | old_mask);
956 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
964 if (fstat(fd, &st) < 0) {
969 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
970 st.st_uid != getuid() ||
971 st.st_gid != getgid()) {
982 close_nointr_nofail(fd);
987 static int socket_open_fds(Socket *s) {
991 bool know_label = false;
995 LIST_FOREACH(port, p, s->ports) {
1000 if (p->type == SOCKET_SOCKET) {
1004 if ((r = socket_instantiate_service(s)) < 0)
1007 if (UNIT_ISSET(s->service) &&
1008 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1009 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1020 if ((r = socket_address_listen(
1033 socket_apply_socket_options(s, p->fd);
1035 } else if (p->type == SOCKET_SPECIAL) {
1037 if ((r = special_address_create(
1042 } else if (p->type == SOCKET_FIFO) {
1044 if ((r = fifo_address_create(
1051 socket_apply_fifo_options(s, p->fd);
1052 } else if (p->type == SOCKET_MQUEUE) {
1054 if ((r = mq_address_create(
1062 assert_not_reached("Unknown port type");
1069 socket_close_fds(s);
1074 static void socket_unwatch_fds(Socket *s) {
1079 LIST_FOREACH(port, p, s->ports) {
1083 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1087 static int socket_watch_fds(Socket *s) {
1093 LIST_FOREACH(port, p, s->ports) {
1097 p->fd_watch.socket_accept =
1099 p->type == SOCKET_SOCKET &&
1100 socket_address_can_accept(&p->address);
1102 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1109 socket_unwatch_fds(s);
1113 static void socket_set_state(Socket *s, SocketState state) {
1114 SocketState old_state;
1117 old_state = s->state;
1120 if (state != SOCKET_START_PRE &&
1121 state != SOCKET_START_POST &&
1122 state != SOCKET_STOP_PRE &&
1123 state != SOCKET_STOP_PRE_SIGTERM &&
1124 state != SOCKET_STOP_PRE_SIGKILL &&
1125 state != SOCKET_STOP_POST &&
1126 state != SOCKET_FINAL_SIGTERM &&
1127 state != SOCKET_FINAL_SIGKILL) {
1128 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1129 socket_unwatch_control_pid(s);
1130 s->control_command = NULL;
1131 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1134 if (state != SOCKET_LISTENING)
1135 socket_unwatch_fds(s);
1137 if (state != SOCKET_START_POST &&
1138 state != SOCKET_LISTENING &&
1139 state != SOCKET_RUNNING &&
1140 state != SOCKET_STOP_PRE &&
1141 state != SOCKET_STOP_PRE_SIGTERM &&
1142 state != SOCKET_STOP_PRE_SIGKILL)
1143 socket_close_fds(s);
1145 if (state != old_state)
1146 log_debug_unit(UNIT(s)->id,
1147 "%s changed %s -> %s", UNIT(s)->id,
1148 socket_state_to_string(old_state),
1149 socket_state_to_string(state));
1151 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1154 static int socket_coldplug(Unit *u) {
1155 Socket *s = SOCKET(u);
1159 assert(s->state == SOCKET_DEAD);
1161 if (s->deserialized_state != s->state) {
1163 if (s->deserialized_state == SOCKET_START_PRE ||
1164 s->deserialized_state == SOCKET_START_POST ||
1165 s->deserialized_state == SOCKET_STOP_PRE ||
1166 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1167 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1168 s->deserialized_state == SOCKET_STOP_POST ||
1169 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1170 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1172 if (s->control_pid <= 0)
1175 r = unit_watch_pid(UNIT(s), s->control_pid);
1179 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1184 if (s->deserialized_state == SOCKET_START_POST ||
1185 s->deserialized_state == SOCKET_LISTENING ||
1186 s->deserialized_state == SOCKET_RUNNING ||
1187 s->deserialized_state == SOCKET_STOP_PRE ||
1188 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1189 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1190 if ((r = socket_open_fds(s)) < 0)
1193 if (s->deserialized_state == SOCKET_LISTENING)
1194 if ((r = socket_watch_fds(s)) < 0)
1197 socket_set_state(s, s->deserialized_state);
1203 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1212 unit_realize_cgroup(UNIT(s));
1214 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1218 argv = unit_full_printf_strv(UNIT(s), c->argv);
1228 UNIT(s)->manager->environment,
1232 UNIT(s)->manager->confirm_spawn,
1233 UNIT(s)->cgroup_mask,
1234 UNIT(s)->cgroup_path,
1243 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1244 /* FIXME: we need to do something here */
1252 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1257 static void socket_enter_dead(Socket *s, SocketResult f) {
1260 if (f != SOCKET_SUCCESS)
1263 exec_context_tmp_dirs_done(&s->exec_context);
1264 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1267 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1269 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1273 if (f != SOCKET_SUCCESS)
1276 socket_unwatch_control_pid(s);
1278 s->control_command_id = SOCKET_EXEC_STOP_POST;
1280 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1281 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1284 socket_set_state(s, SOCKET_STOP_POST);
1286 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1291 log_warning_unit(UNIT(s)->id,
1292 "%s failed to run 'stop-post' task: %s",
1293 UNIT(s)->id, strerror(-r));
1294 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1297 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1302 if (f != SOCKET_SUCCESS)
1305 r = unit_kill_context(
1308 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1316 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1320 socket_set_state(s, state);
1321 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1322 socket_enter_stop_post(s, SOCKET_SUCCESS);
1324 socket_enter_dead(s, SOCKET_SUCCESS);
1329 log_warning_unit(UNIT(s)->id,
1330 "%s failed to kill processes: %s",
1331 UNIT(s)->id, strerror(-r));
1333 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1334 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1336 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1339 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1343 if (f != SOCKET_SUCCESS)
1346 socket_unwatch_control_pid(s);
1348 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1350 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1351 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1354 socket_set_state(s, SOCKET_STOP_PRE);
1356 socket_enter_stop_post(s, SOCKET_SUCCESS);
1361 log_warning_unit(UNIT(s)->id,
1362 "%s failed to run 'stop-pre' task: %s",
1363 UNIT(s)->id, strerror(-r));
1364 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1367 static void socket_enter_listening(Socket *s) {
1371 r = socket_watch_fds(s);
1373 log_warning_unit(UNIT(s)->id,
1374 "%s failed to watch sockets: %s",
1375 UNIT(s)->id, strerror(-r));
1379 socket_set_state(s, SOCKET_LISTENING);
1383 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1386 static void socket_enter_start_post(Socket *s) {
1390 r = socket_open_fds(s);
1392 log_warning_unit(UNIT(s)->id,
1393 "%s failed to listen on sockets: %s",
1394 UNIT(s)->id, strerror(-r));
1398 socket_unwatch_control_pid(s);
1400 s->control_command_id = SOCKET_EXEC_START_POST;
1402 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1403 r = socket_spawn(s, s->control_command, &s->control_pid);
1405 log_warning_unit(UNIT(s)->id,
1406 "%s failed to run 'start-post' task: %s",
1407 UNIT(s)->id, strerror(-r));
1411 socket_set_state(s, SOCKET_START_POST);
1413 socket_enter_listening(s);
1418 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1421 static void socket_enter_start_pre(Socket *s) {
1425 socket_unwatch_control_pid(s);
1427 s->control_command_id = SOCKET_EXEC_START_PRE;
1429 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1430 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1433 socket_set_state(s, SOCKET_START_PRE);
1435 socket_enter_start_post(s);
1440 log_warning_unit(UNIT(s)->id,
1441 "%s failed to run 'start-pre' task: %s",
1442 UNIT(s)->id, strerror(-r));
1443 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1446 static void socket_enter_running(Socket *s, int cfd) {
1451 dbus_error_init(&error);
1453 /* We don't take connections anymore if we are supposed to
1454 * shut down anyway */
1455 if (unit_stop_pending(UNIT(s))) {
1456 log_debug_unit(UNIT(s)->id,
1457 "Suppressing connection request on %s since unit stop is scheduled.",
1461 close_nointr_nofail(cfd);
1463 /* Flush all sockets by closing and reopening them */
1464 socket_close_fds(s);
1466 r = socket_watch_fds(s);
1468 log_warning_unit(UNIT(s)->id,
1469 "%s failed to watch sockets: %s",
1470 UNIT(s)->id, strerror(-r));
1471 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1481 bool pending = false;
1483 /* If there's already a start pending don't bother to
1485 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1486 if (unit_active_or_pending(u)) {
1492 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1497 socket_set_state(s, SOCKET_RUNNING);
1499 char *prefix, *instance = NULL, *name;
1502 if (s->n_connections >= s->max_connections) {
1503 log_warning_unit(UNIT(s)->id,
1504 "%s: Too many incoming connections (%u)",
1505 UNIT(s)->id, s->n_connections);
1506 close_nointr_nofail(cfd);
1510 r = socket_instantiate_service(s);
1514 r = instance_from_socket(cfd, s->n_accepted, &instance);
1519 /* ENOTCONN is legitimate if TCP RST was received.
1520 * This connection is over, but the socket unit lives on. */
1521 close_nointr_nofail(cfd);
1525 prefix = unit_name_to_prefix(UNIT(s)->id);
1532 name = unit_name_build(prefix, instance, ".service");
1541 r = unit_add_name(UNIT_DEREF(s->service), name);
1547 service = SERVICE(UNIT_DEREF(s->service));
1548 unit_ref_unset(&s->service);
1551 UNIT(service)->no_gc = false;
1553 unit_choose_id(UNIT(service), name);
1556 r = service_set_socket_fd(service, cfd, s);
1561 s->n_connections ++;
1563 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1567 /* Notify clients about changed counters */
1568 unit_add_to_dbus_queue(UNIT(s));
1574 log_warning_unit(UNIT(s)->id,
1575 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1577 cfd >= 0 ? "template" : "non-template",
1578 bus_error(&error, r));
1579 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1582 close_nointr_nofail(cfd);
1584 dbus_error_free(&error);
1587 static void socket_run_next(Socket *s) {
1591 assert(s->control_command);
1592 assert(s->control_command->command_next);
1594 socket_unwatch_control_pid(s);
1596 s->control_command = s->control_command->command_next;
1598 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1604 log_warning_unit(UNIT(s)->id,
1605 "%s failed to run next task: %s",
1606 UNIT(s)->id, strerror(-r));
1608 if (s->state == SOCKET_START_POST)
1609 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1610 else if (s->state == SOCKET_STOP_POST)
1611 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1613 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1616 static int socket_start(Unit *u) {
1617 Socket *s = SOCKET(u);
1621 /* We cannot fulfill this request right now, try again later
1623 if (s->state == SOCKET_STOP_PRE ||
1624 s->state == SOCKET_STOP_PRE_SIGKILL ||
1625 s->state == SOCKET_STOP_PRE_SIGTERM ||
1626 s->state == SOCKET_STOP_POST ||
1627 s->state == SOCKET_FINAL_SIGTERM ||
1628 s->state == SOCKET_FINAL_SIGKILL)
1631 if (s->state == SOCKET_START_PRE ||
1632 s->state == SOCKET_START_POST)
1635 /* Cannot run this without the service being around */
1636 if (UNIT_ISSET(s->service)) {
1639 service = SERVICE(UNIT_DEREF(s->service));
1641 if (UNIT(service)->load_state != UNIT_LOADED) {
1642 log_error_unit(u->id,
1643 "Socket service %s not loaded, refusing.",
1648 /* If the service is already active we cannot start the
1650 if (service->state != SERVICE_DEAD &&
1651 service->state != SERVICE_FAILED &&
1652 service->state != SERVICE_AUTO_RESTART) {
1653 log_error_unit(u->id,
1654 "Socket service %s already active, refusing.",
1659 #ifdef HAVE_SYSV_COMPAT
1660 if (service->is_sysv) {
1661 log_error_unit(u->id,
1662 "Using SysV services for socket activation is not supported. Refusing.");
1668 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1670 s->result = SOCKET_SUCCESS;
1671 socket_enter_start_pre(s);
1675 static int socket_stop(Unit *u) {
1676 Socket *s = SOCKET(u);
1681 if (s->state == SOCKET_STOP_PRE ||
1682 s->state == SOCKET_STOP_PRE_SIGTERM ||
1683 s->state == SOCKET_STOP_PRE_SIGKILL ||
1684 s->state == SOCKET_STOP_POST ||
1685 s->state == SOCKET_FINAL_SIGTERM ||
1686 s->state == SOCKET_FINAL_SIGKILL)
1689 /* If there's already something running we go directly into
1691 if (s->state == SOCKET_START_PRE ||
1692 s->state == SOCKET_START_POST) {
1693 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1697 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1699 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1703 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1704 Socket *s = SOCKET(u);
1712 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1713 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1714 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1716 if (s->control_pid > 0)
1717 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1719 if (s->control_command_id >= 0)
1720 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1722 LIST_FOREACH(port, p, s->ports) {
1728 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1731 if (p->type == SOCKET_SOCKET) {
1734 r = socket_address_print(&p->address, &t);
1738 if (socket_address_family(&p->address) == AF_NETLINK)
1739 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1741 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1743 } else if (p->type == SOCKET_SPECIAL)
1744 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1745 else if (p->type == SOCKET_MQUEUE)
1746 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1748 assert(p->type == SOCKET_FIFO);
1749 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1753 exec_context_serialize(&s->exec_context, UNIT(s), f);
1758 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1759 Socket *s = SOCKET(u);
1766 if (streq(key, "state")) {
1769 state = socket_state_from_string(value);
1771 log_debug_unit(u->id,
1772 "Failed to parse state value %s", value);
1774 s->deserialized_state = state;
1775 } else if (streq(key, "result")) {
1778 f = socket_result_from_string(value);
1780 log_debug_unit(u->id,
1781 "Failed to parse result value %s", value);
1782 else if (f != SOCKET_SUCCESS)
1785 } else if (streq(key, "n-accepted")) {
1788 if (safe_atou(value, &k) < 0)
1789 log_debug_unit(u->id,
1790 "Failed to parse n-accepted value %s", value);
1793 } else if (streq(key, "control-pid")) {
1796 if (parse_pid(value, &pid) < 0)
1797 log_debug_unit(u->id,
1798 "Failed to parse control-pid value %s", value);
1800 s->control_pid = pid;
1801 } else if (streq(key, "control-command")) {
1802 SocketExecCommand id;
1804 id = socket_exec_command_from_string(value);
1806 log_debug_unit(u->id,
1807 "Failed to parse exec-command value %s", value);
1809 s->control_command_id = id;
1810 s->control_command = s->exec_command[id];
1812 } else if (streq(key, "fifo")) {
1816 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1817 log_debug_unit(u->id,
1818 "Failed to parse fifo value %s", value);
1821 LIST_FOREACH(port, p, s->ports)
1822 if (p->type == SOCKET_FIFO &&
1823 streq_ptr(p->path, value+skip))
1828 close_nointr_nofail(p->fd);
1829 p->fd = fdset_remove(fds, fd);
1833 } else if (streq(key, "special")) {
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1838 log_debug_unit(u->id,
1839 "Failed to parse special value %s", value);
1842 LIST_FOREACH(port, p, s->ports)
1843 if (p->type == SOCKET_SPECIAL &&
1844 streq_ptr(p->path, value+skip))
1849 close_nointr_nofail(p->fd);
1850 p->fd = fdset_remove(fds, fd);
1854 } else if (streq(key, "mqueue")) {
1858 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1859 log_debug_unit(u->id,
1860 "Failed to parse mqueue value %s", value);
1863 LIST_FOREACH(port, p, s->ports)
1864 if (p->type == SOCKET_MQUEUE &&
1865 streq_ptr(p->path, value+skip))
1870 close_nointr_nofail(p->fd);
1871 p->fd = fdset_remove(fds, fd);
1875 } else if (streq(key, "socket")) {
1876 int fd, type, skip = 0;
1879 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 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(&p->address, value+skip, type))
1890 close_nointr_nofail(p->fd);
1891 p->fd = fdset_remove(fds, fd);
1895 } else if (streq(key, "netlink")) {
1899 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1900 log_debug_unit(u->id,
1901 "Failed to parse socket value %s", value);
1904 LIST_FOREACH(port, p, s->ports)
1905 if (socket_address_is_netlink(&p->address, value+skip))
1910 close_nointr_nofail(p->fd);
1911 p->fd = fdset_remove(fds, fd);
1914 } else if (streq(key, "tmp-dir")) {
1921 s->exec_context.tmp_dir = t;
1922 } else if (streq(key, "var-tmp-dir")) {
1929 s->exec_context.var_tmp_dir = t;
1931 log_debug_unit(UNIT(s)->id,
1932 "Unknown serialization key '%s'", key);
1937 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1938 Socket *s = SOCKET(u);
1943 LIST_FOREACH(port, p, s->ports) {
1947 if (p->type != SOCKET_SOCKET)
1953 FDSET_FOREACH(fd, fds, i) {
1954 if (socket_address_matches_fd(&p->address, fd)) {
1955 p->fd = fdset_remove(fds, fd);
1956 s->deserialized_state = SOCKET_LISTENING;
1965 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1968 return state_translation_table[SOCKET(u)->state];
1971 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1974 return socket_state_to_string(SOCKET(u)->state);
1977 const char* socket_port_type_to_string(SocketPort *p) {
1983 switch (p->address.type) {
1984 case SOCK_STREAM: return "Stream";
1985 case SOCK_DGRAM: return "Datagram";
1986 case SOCK_SEQPACKET: return "SequentialPacket";
1988 if (socket_address_family(&p->address) == AF_NETLINK)
1990 default: return "Invalid";
1992 case SOCKET_SPECIAL: return "Special";
1993 case SOCKET_MQUEUE: return "MessageQueue";
1994 case SOCKET_FIFO: return "FIFO";
1995 default: return NULL;
1999 _pure_ static bool socket_check_gc(Unit *u) {
2000 Socket *s = SOCKET(u);
2004 return s->n_connections > 0;
2007 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2008 Socket *s = SOCKET(u);
2014 if (s->state != SOCKET_LISTENING)
2017 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2019 if (events != EPOLLIN) {
2021 if (events & EPOLLHUP)
2022 log_error_unit(u->id,
2023 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2026 log_error_unit(u->id,
2027 "%s: Got unexpected poll event (0x%x) on socket.",
2033 if (w->socket_accept) {
2036 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2042 log_error_unit(u->id,
2043 "Failed to accept socket: %m");
2050 socket_apply_socket_options(s, cfd);
2053 socket_enter_running(s, cfd);
2057 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2060 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2061 Socket *s = SOCKET(u);
2067 if (pid != s->control_pid)
2072 if (is_clean_exit(code, status, NULL))
2074 else if (code == CLD_EXITED)
2075 f = SOCKET_FAILURE_EXIT_CODE;
2076 else if (code == CLD_KILLED)
2077 f = SOCKET_FAILURE_SIGNAL;
2078 else if (code == CLD_DUMPED)
2079 f = SOCKET_FAILURE_CORE_DUMP;
2081 assert_not_reached("Unknown code");
2083 if (s->control_command) {
2084 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2086 if (s->control_command->ignore)
2090 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2092 "%s control process exited, code=%s status=%i",
2093 u->id, sigchld_code_to_string(code), status);
2095 if (f != SOCKET_SUCCESS)
2098 if (s->control_command &&
2099 s->control_command->command_next &&
2100 f == SOCKET_SUCCESS) {
2102 log_debug_unit(u->id,
2103 "%s running next command for state %s",
2104 u->id, socket_state_to_string(s->state));
2107 s->control_command = NULL;
2108 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2110 /* No further commands for this step, so let's figure
2111 * out what to do next */
2113 log_debug_unit(u->id,
2114 "%s got final SIGCHLD for state %s",
2115 u->id, socket_state_to_string(s->state));
2119 case SOCKET_START_PRE:
2120 if (f == SOCKET_SUCCESS)
2121 socket_enter_start_post(s);
2123 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2126 case SOCKET_START_POST:
2127 if (f == SOCKET_SUCCESS)
2128 socket_enter_listening(s);
2130 socket_enter_stop_pre(s, f);
2133 case SOCKET_STOP_PRE:
2134 case SOCKET_STOP_PRE_SIGTERM:
2135 case SOCKET_STOP_PRE_SIGKILL:
2136 socket_enter_stop_post(s, f);
2139 case SOCKET_STOP_POST:
2140 case SOCKET_FINAL_SIGTERM:
2141 case SOCKET_FINAL_SIGKILL:
2142 socket_enter_dead(s, f);
2146 assert_not_reached("Uh, control process died at wrong time.");
2150 /* Notify clients about changed exit status */
2151 unit_add_to_dbus_queue(u);
2154 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2155 Socket *s = SOCKET(u);
2158 assert(elapsed == 1);
2159 assert(w == &s->timer_watch);
2163 case SOCKET_START_PRE:
2164 log_warning_unit(u->id,
2165 "%s starting timed out. Terminating.", u->id);
2166 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2169 case SOCKET_START_POST:
2170 log_warning_unit(u->id,
2171 "%s starting timed out. Stopping.", u->id);
2172 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2175 case SOCKET_STOP_PRE:
2176 log_warning_unit(u->id,
2177 "%s stopping timed out. Terminating.", u->id);
2178 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2181 case SOCKET_STOP_PRE_SIGTERM:
2182 if (s->kill_context.send_sigkill) {
2183 log_warning_unit(u->id,
2184 "%s stopping timed out. Killing.", u->id);
2185 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2187 log_warning_unit(u->id,
2188 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2190 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2194 case SOCKET_STOP_PRE_SIGKILL:
2195 log_warning_unit(u->id,
2196 "%s still around after SIGKILL. Ignoring.", u->id);
2197 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2200 case SOCKET_STOP_POST:
2201 log_warning_unit(u->id,
2202 "%s stopping timed out (2). Terminating.", u->id);
2203 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2206 case SOCKET_FINAL_SIGTERM:
2207 if (s->kill_context.send_sigkill) {
2208 log_warning_unit(u->id,
2209 "%s stopping timed out (2). Killing.", u->id);
2210 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2212 log_warning_unit(u->id,
2213 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2215 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2219 case SOCKET_FINAL_SIGKILL:
2220 log_warning_unit(u->id,
2221 "%s still around after SIGKILL (2). Entering failed mode.",
2223 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2227 assert_not_reached("Timeout at wrong time.");
2231 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2240 /* Called from the service code for requesting our fds */
2243 LIST_FOREACH(port, p, s->ports)
2253 if (!(rfds = new(int, rn_fds)))
2257 LIST_FOREACH(port, p, s->ports)
2261 assert(k == rn_fds);
2269 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2272 /* The service is dead. Dang!
2274 * This is strictly for one-instance-for-all-connections
2277 if (s->state == SOCKET_RUNNING) {
2278 log_debug_unit(UNIT(s)->id,
2279 "%s got notified about service death (failed permanently: %s)",
2280 UNIT(s)->id, yes_no(failed_permanent));
2281 if (failed_permanent)
2282 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2284 socket_enter_listening(s);
2288 void socket_connection_unref(Socket *s) {
2291 /* The service is dead. Yay!
2293 * This is strictly for one-instance-per-connection
2296 assert(s->n_connections > 0);
2299 log_debug_unit(UNIT(s)->id,
2300 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2303 static void socket_reset_failed(Unit *u) {
2304 Socket *s = SOCKET(u);
2308 if (s->state == SOCKET_FAILED)
2309 socket_set_state(s, SOCKET_DEAD);
2311 s->result = SOCKET_SUCCESS;
2314 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2315 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2318 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2319 [SOCKET_DEAD] = "dead",
2320 [SOCKET_START_PRE] = "start-pre",
2321 [SOCKET_START_POST] = "start-post",
2322 [SOCKET_LISTENING] = "listening",
2323 [SOCKET_RUNNING] = "running",
2324 [SOCKET_STOP_PRE] = "stop-pre",
2325 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2326 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2327 [SOCKET_STOP_POST] = "stop-post",
2328 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2329 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2330 [SOCKET_FAILED] = "failed"
2333 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2335 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2336 [SOCKET_EXEC_START_PRE] = "StartPre",
2337 [SOCKET_EXEC_START_POST] = "StartPost",
2338 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2339 [SOCKET_EXEC_STOP_POST] = "StopPost"
2342 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2344 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2345 [SOCKET_SUCCESS] = "success",
2346 [SOCKET_FAILURE_RESOURCES] = "resources",
2347 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2348 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2349 [SOCKET_FAILURE_SIGNAL] = "signal",
2350 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2351 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2354 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2356 const UnitVTable socket_vtable = {
2357 .object_size = sizeof(Socket),
2364 .private_section = "Socket",
2365 .exec_context_offset = offsetof(Socket, exec_context),
2366 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2368 .init = socket_init,
2369 .done = socket_done,
2370 .load = socket_load,
2372 .kill = socket_kill,
2374 .coldplug = socket_coldplug,
2376 .dump = socket_dump,
2378 .start = socket_start,
2379 .stop = socket_stop,
2381 .serialize = socket_serialize,
2382 .deserialize_item = socket_deserialize_item,
2383 .distribute_fds = socket_distribute_fds,
2385 .active_state = socket_active_state,
2386 .sub_state_to_string = socket_sub_state_to_string,
2388 .check_gc = socket_check_gc,
2390 .fd_event = socket_fd_event,
2391 .sigchld_event = socket_sigchld_event,
2392 .timer_event = socket_timer_event,
2394 .reset_failed = socket_reset_failed,
2396 .bus_interface = "org.freedesktop.systemd1.Socket",
2397 .bus_message_handler = bus_socket_message_handler,
2398 .bus_invalidating_properties = bus_socket_invalidating_properties,
2399 .bus_set_property = bus_socket_set_property,
2400 .bus_commit_properties = bus_socket_commit_properties,
2402 .status_message_formats = {
2403 /*.starting_stopping = {
2404 [0] = "Starting socket %s...",
2405 [1] = "Stopping socket %s...",
2407 .finished_start_job = {
2408 [JOB_DONE] = "Listening on %s.",
2409 [JOB_FAILED] = "Failed to listen on %s.",
2410 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2411 [JOB_TIMEOUT] = "Timed out starting %s.",
2413 .finished_stop_job = {
2414 [JOB_DONE] = "Closed %s.",
2415 [JOB_FAILED] = "Failed stopping %s.",
2416 [JOB_TIMEOUT] = "Timed out stopping %s.",