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>
31 #ifdef HAVE_ATTR_XATTR_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 "bus-errors.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);
92 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
95 static void socket_unwatch_control_pid(Socket *s) {
98 if (s->control_pid <= 0)
101 unit_unwatch_pid(UNIT(s), s->control_pid);
105 void socket_free_ports(Socket *s) {
110 while ((p = s->ports)) {
111 LIST_REMOVE(SocketPort, port, s->ports, p);
114 unit_unwatch_fd(UNIT(s), &p->fd_watch);
115 close_nointr_nofail(p->fd);
123 static void socket_done(Unit *u) {
124 Socket *s = SOCKET(u);
128 socket_free_ports(s);
130 exec_context_done(&s->exec_context);
131 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
132 s->control_command = NULL;
134 socket_unwatch_control_pid(s);
136 unit_ref_unset(&s->service);
138 free(s->tcp_congestion);
139 s->tcp_congestion = NULL;
141 free(s->bind_to_device);
142 s->bind_to_device = NULL;
145 free(s->smack_ip_in);
146 free(s->smack_ip_out);
148 unit_unwatch_timer(u, &s->timer_watch);
151 static int socket_instantiate_service(Socket *s) {
158 /* This fills in s->service if it isn't filled in yet. For
159 * Accept=yes sockets we create the next connection service
160 * here. For Accept=no this is mostly a NOP since the service
161 * is figured out at load time anyway. */
163 if (UNIT_DEREF(s->service))
168 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
171 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
177 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
183 #ifdef HAVE_SYSV_COMPAT
184 if (SERVICE(u)->is_sysv) {
185 log_error("Using SysV services for socket activation is not supported. Refusing.");
191 unit_ref_set(&s->service, u);
193 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
196 static bool have_non_accept_socket(Socket *s) {
204 LIST_FOREACH(port, p, s->ports) {
206 if (p->type != SOCKET_SOCKET)
209 if (!socket_address_can_accept(&p->address))
216 static int socket_verify(Socket *s) {
219 if (UNIT(s)->load_state != UNIT_LOADED)
223 log_error_unit(UNIT(s)->id,
224 "%s lacks Listen setting. Refusing.", UNIT(s)->id);
228 if (s->accept && have_non_accept_socket(s)) {
229 log_error_unit(UNIT(s)->id,
230 "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
235 if (s->accept && s->max_connections <= 0) {
236 log_error_unit(UNIT(s)->id,
237 "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
241 if (s->accept && UNIT_DEREF(s->service)) {
242 log_error_unit(UNIT(s)->id,
243 "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
248 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
249 log_error_unit(UNIT(s)->id,
250 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
258 static bool socket_needs_mount(Socket *s, const char *prefix) {
263 LIST_FOREACH(port, p, s->ports) {
265 if (p->type == SOCKET_SOCKET) {
266 if (socket_address_needs_mount(&p->address, prefix))
268 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
269 if (path_startswith(p->path, prefix))
277 int socket_add_one_mount_link(Socket *s, Mount *m) {
283 if (UNIT(s)->load_state != UNIT_LOADED ||
284 UNIT(m)->load_state != UNIT_LOADED)
287 if (!socket_needs_mount(s, m->where))
290 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
297 static int socket_add_mount_links(Socket *s) {
303 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
304 r = socket_add_one_mount_link(s, MOUNT(other));
312 static int socket_add_device_link(Socket *s) {
318 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
321 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
324 r = unit_add_node_link(UNIT(s), t, false);
330 static int socket_add_default_dependencies(Socket *s) {
334 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
335 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
338 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
342 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
345 static bool socket_has_exec(Socket *s) {
349 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
350 if (s->exec_command[i])
356 static int socket_load(Unit *u) {
357 Socket *s = SOCKET(u);
361 assert(u->load_state == UNIT_STUB);
363 if ((r = unit_load_fragment_and_dropin(u)) < 0)
366 /* This is a new unit? Then let's add in some extras */
367 if (u->load_state == UNIT_LOADED) {
369 if (have_non_accept_socket(s)) {
371 if (!UNIT_DEREF(s->service)) {
374 r = unit_load_related_unit(u, ".service", &x);
378 unit_ref_set(&s->service, x);
381 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
386 if ((r = socket_add_mount_links(s)) < 0)
389 if ((r = socket_add_device_link(s)) < 0)
392 if (socket_has_exec(s))
393 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
396 if ((r = unit_add_default_cgroups(u)) < 0)
399 if (UNIT(s)->default_dependencies)
400 if ((r = socket_add_default_dependencies(s)) < 0)
403 r = unit_exec_context_defaults(u, &s->exec_context);
408 return socket_verify(s);
411 static const char* listen_lookup(int family, int type) {
413 if (family == AF_NETLINK)
414 return "ListenNetlink";
416 if (type == SOCK_STREAM)
417 return "ListenStream";
418 else if (type == SOCK_DGRAM)
419 return "ListenDatagram";
420 else if (type == SOCK_SEQPACKET)
421 return "ListenSequentialPacket";
423 assert_not_reached("Unknown socket type");
427 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
430 Socket *s = SOCKET(u);
438 p2 = strappend(prefix, "\t");
439 prefix2 = p2 ? p2 : prefix;
442 "%sSocket State: %s\n"
444 "%sBindIPv6Only: %s\n"
446 "%sSocketMode: %04o\n"
447 "%sDirectoryMode: %04o\n"
450 "%sTransparent: %s\n"
452 "%sPassCredentials: %s\n"
453 "%sPassSecurity: %s\n"
454 "%sTCPCongestion: %s\n",
455 prefix, socket_state_to_string(s->state),
456 prefix, socket_result_to_string(s->result),
457 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
459 prefix, s->socket_mode,
460 prefix, s->directory_mode,
461 prefix, yes_no(s->keep_alive),
462 prefix, yes_no(s->free_bind),
463 prefix, yes_no(s->transparent),
464 prefix, yes_no(s->broadcast),
465 prefix, yes_no(s->pass_cred),
466 prefix, yes_no(s->pass_sec),
467 prefix, strna(s->tcp_congestion));
469 if (s->control_pid > 0)
471 "%sControl PID: %lu\n",
472 prefix, (unsigned long) s->control_pid);
474 if (s->bind_to_device)
476 "%sBindToDevice: %s\n",
477 prefix, s->bind_to_device);
482 "%sNConnections: %u\n"
483 "%sMaxConnections: %u\n",
484 prefix, s->n_accepted,
485 prefix, s->n_connections,
486 prefix, s->max_connections);
488 if (s->priority >= 0)
491 prefix, s->priority);
493 if (s->receive_buffer > 0)
495 "%sReceiveBuffer: %zu\n",
496 prefix, s->receive_buffer);
498 if (s->send_buffer > 0)
500 "%sSendBuffer: %zu\n",
501 prefix, s->send_buffer);
513 if (s->pipe_size > 0)
516 prefix, s->pipe_size);
523 if (s->mq_maxmsg > 0)
525 "%sMessageQueueMaxMessages: %li\n",
526 prefix, s->mq_maxmsg);
528 if (s->mq_msgsize > 0)
530 "%sMessageQueueMessageSize: %li\n",
531 prefix, s->mq_msgsize);
535 "%sSmackLabel: %s\n",
540 "%sSmackLabelIPIn: %s\n",
541 prefix, s->smack_ip_in);
545 "%sSmackLabelIPOut: %s\n",
546 prefix, s->smack_ip_out);
548 LIST_FOREACH(port, p, s->ports) {
550 if (p->type == SOCKET_SOCKET) {
555 if ((r = socket_address_print(&p->address, &k)) < 0)
560 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
562 } else if (p->type == SOCKET_SPECIAL)
563 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
564 else if (p->type == SOCKET_MQUEUE)
565 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
567 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
570 exec_context_dump(&s->exec_context, f, prefix);
571 kill_context_dump(&s->kill_context, f, prefix);
573 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
574 if (!s->exec_command[c])
577 fprintf(f, "%s-> %s:\n",
578 prefix, socket_exec_command_to_string(c));
580 exec_command_dump_list(s->exec_command[c], f, prefix2);
586 static int instance_from_socket(int fd, unsigned nr, char **instance) {
591 struct sockaddr_un un;
592 struct sockaddr_in in;
593 struct sockaddr_in6 in6;
594 struct sockaddr_storage storage;
601 if (getsockname(fd, &local.sa, &l) < 0)
605 if (getpeername(fd, &remote.sa, &l) < 0)
608 switch (local.sa.sa_family) {
612 a = ntohl(local.in.sin_addr.s_addr),
613 b = ntohl(remote.in.sin_addr.s_addr);
616 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
618 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
619 ntohs(local.in.sin_port),
620 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
621 ntohs(remote.in.sin_port)) < 0)
628 static const unsigned char ipv4_prefix[] = {
629 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
632 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
633 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
635 *a = local.in6.sin6_addr.s6_addr+12,
636 *b = remote.in6.sin6_addr.s6_addr+12;
639 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
641 a[0], a[1], a[2], a[3],
642 ntohs(local.in6.sin6_port),
643 b[0], b[1], b[2], b[3],
644 ntohs(remote.in6.sin6_port)) < 0)
647 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
652 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
653 ntohs(local.in6.sin6_port),
654 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
655 ntohs(remote.in6.sin6_port)) < 0)
666 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
672 (unsigned long) ucred.pid,
673 (unsigned long) ucred.uid) < 0)
680 assert_not_reached("Unhandled socket type.");
687 static void socket_close_fds(Socket *s) {
692 LIST_FOREACH(port, p, s->ports) {
696 unit_unwatch_fd(UNIT(s), &p->fd_watch);
697 close_nointr_nofail(p->fd);
699 /* One little note: we should never delete any sockets
700 * in the file system here! After all some other
701 * process we spawned might still have a reference of
702 * this fd and wants to continue to use it. Therefore
703 * we delete sockets in the file system before we
704 * create a new one, not after we stopped using
711 static void socket_apply_socket_options(Socket *s, int fd) {
716 int b = s->keep_alive;
717 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
718 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
723 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
729 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
735 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
739 if (s->priority >= 0)
740 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
741 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
743 if (s->receive_buffer > 0) {
744 int value = (int) s->receive_buffer;
746 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
748 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
749 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
750 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
753 if (s->send_buffer > 0) {
754 int value = (int) s->send_buffer;
755 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
756 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
757 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
761 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
765 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
766 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
768 if (s->ip_ttl >= 0) {
771 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
773 if (socket_ipv6_is_supported())
774 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
777 errno = EAFNOSUPPORT;
781 log_warning_unit(UNIT(s)->id,
782 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
785 if (s->tcp_congestion)
786 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
787 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
789 #ifdef HAVE_ATTR_XATTR_H
791 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
792 log_error_unit(UNIT(s)->id,
793 "fsetxattr(\"security.SMACK64IPIN\"): %m");
796 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
797 log_error_unit(UNIT(s)->id,
798 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
802 static void socket_apply_fifo_options(Socket *s, int fd) {
806 if (s->pipe_size > 0)
807 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
808 log_warning_unit(UNIT(s)->id,
811 #ifdef HAVE_ATTR_XATTR_H
813 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
814 log_error_unit(UNIT(s)->id,
815 "fsetxattr(\"security.SMACK64\"): %m");
819 static int fifo_address_create(
821 mode_t directory_mode,
832 mkdir_parents_label(path, directory_mode);
834 r = label_context_set(path, S_IFIFO);
838 /* Enforce the right access mode for the fifo */
839 old_mask = umask(~ socket_mode);
841 /* Include the original umask in our mask */
842 umask(~socket_mode | old_mask);
844 r = mkfifo(path, socket_mode);
847 if (r < 0 && errno != EEXIST) {
852 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
857 label_context_clear();
859 if (fstat(fd, &st) < 0) {
864 if (!S_ISFIFO(st.st_mode) ||
865 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
866 st.st_uid != getuid() ||
867 st.st_gid != getgid()) {
877 label_context_clear();
880 close_nointr_nofail(fd);
885 static int special_address_create(
895 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
900 if (fstat(fd, &st) < 0) {
905 /* Check whether this is a /proc, /sys or /dev file or char device */
906 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
916 close_nointr_nofail(fd);
921 static int mq_address_create(
931 struct mq_attr _attr, *attr = NULL;
936 if (maxmsg > 0 && msgsize > 0) {
938 _attr.mq_flags = O_NONBLOCK;
939 _attr.mq_maxmsg = maxmsg;
940 _attr.mq_msgsize = msgsize;
944 /* Enforce the right access mode for the mq */
945 old_mask = umask(~ mq_mode);
947 /* Include the original umask in our mask */
948 umask(~mq_mode | old_mask);
950 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
958 if (fstat(fd, &st) < 0) {
963 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
964 st.st_uid != getuid() ||
965 st.st_gid != getgid()) {
976 close_nointr_nofail(fd);
981 static int socket_open_fds(Socket *s) {
985 bool know_label = false;
989 LIST_FOREACH(port, p, s->ports) {
994 if (p->type == SOCKET_SOCKET) {
998 if ((r = socket_instantiate_service(s)) < 0)
1001 if (UNIT_DEREF(s->service) &&
1002 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1003 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1014 if ((r = socket_address_listen(
1027 socket_apply_socket_options(s, p->fd);
1029 } else if (p->type == SOCKET_SPECIAL) {
1031 if ((r = special_address_create(
1036 } else if (p->type == SOCKET_FIFO) {
1038 if ((r = fifo_address_create(
1045 socket_apply_fifo_options(s, p->fd);
1046 } else if (p->type == SOCKET_MQUEUE) {
1048 if ((r = mq_address_create(
1056 assert_not_reached("Unknown port type");
1063 socket_close_fds(s);
1068 static void socket_unwatch_fds(Socket *s) {
1073 LIST_FOREACH(port, p, s->ports) {
1077 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1081 static int socket_watch_fds(Socket *s) {
1087 LIST_FOREACH(port, p, s->ports) {
1091 p->fd_watch.socket_accept =
1093 p->type == SOCKET_SOCKET &&
1094 socket_address_can_accept(&p->address);
1096 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1103 socket_unwatch_fds(s);
1107 static void socket_set_state(Socket *s, SocketState state) {
1108 SocketState old_state;
1111 old_state = s->state;
1114 if (state != SOCKET_START_PRE &&
1115 state != SOCKET_START_POST &&
1116 state != SOCKET_STOP_PRE &&
1117 state != SOCKET_STOP_PRE_SIGTERM &&
1118 state != SOCKET_STOP_PRE_SIGKILL &&
1119 state != SOCKET_STOP_POST &&
1120 state != SOCKET_FINAL_SIGTERM &&
1121 state != SOCKET_FINAL_SIGKILL) {
1122 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1123 socket_unwatch_control_pid(s);
1124 s->control_command = NULL;
1125 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1128 if (state != SOCKET_LISTENING)
1129 socket_unwatch_fds(s);
1131 if (state != SOCKET_START_POST &&
1132 state != SOCKET_LISTENING &&
1133 state != SOCKET_RUNNING &&
1134 state != SOCKET_STOP_PRE &&
1135 state != SOCKET_STOP_PRE_SIGTERM &&
1136 state != SOCKET_STOP_PRE_SIGKILL)
1137 socket_close_fds(s);
1139 if (state != old_state)
1140 log_debug_unit(UNIT(s)->id,
1141 "%s changed %s -> %s", UNIT(s)->id,
1142 socket_state_to_string(old_state),
1143 socket_state_to_string(state));
1145 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1148 static int socket_coldplug(Unit *u) {
1149 Socket *s = SOCKET(u);
1153 assert(s->state == SOCKET_DEAD);
1155 if (s->deserialized_state != s->state) {
1157 if (s->deserialized_state == SOCKET_START_PRE ||
1158 s->deserialized_state == SOCKET_START_POST ||
1159 s->deserialized_state == SOCKET_STOP_PRE ||
1160 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1161 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1162 s->deserialized_state == SOCKET_STOP_POST ||
1163 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1164 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1166 if (s->control_pid <= 0)
1169 r = unit_watch_pid(UNIT(s), s->control_pid);
1173 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1178 if (s->deserialized_state == SOCKET_START_POST ||
1179 s->deserialized_state == SOCKET_LISTENING ||
1180 s->deserialized_state == SOCKET_RUNNING ||
1181 s->deserialized_state == SOCKET_STOP_PRE ||
1182 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1183 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1184 if ((r = socket_open_fds(s)) < 0)
1187 if (s->deserialized_state == SOCKET_LISTENING)
1188 if ((r = socket_watch_fds(s)) < 0)
1191 socket_set_state(s, s->deserialized_state);
1197 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1206 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1210 argv = unit_full_printf_strv(UNIT(s), c->argv);
1220 UNIT(s)->manager->environment,
1224 UNIT(s)->manager->confirm_spawn,
1225 UNIT(s)->cgroup_bondings,
1226 UNIT(s)->cgroup_attributes,
1236 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1237 /* FIXME: we need to do something here */
1245 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1250 static void socket_enter_dead(Socket *s, SocketResult f) {
1253 if (f != SOCKET_SUCCESS)
1256 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1259 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1261 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1265 if (f != SOCKET_SUCCESS)
1268 socket_unwatch_control_pid(s);
1270 s->control_command_id = SOCKET_EXEC_STOP_POST;
1272 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1273 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1276 socket_set_state(s, SOCKET_STOP_POST);
1278 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1283 log_warning_unit(UNIT(s)->id,
1284 "%s failed to run 'stop-post' task: %s",
1285 UNIT(s)->id, strerror(-r));
1286 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1289 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1294 if (f != SOCKET_SUCCESS)
1297 r = unit_kill_context(
1300 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1308 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1312 socket_set_state(s, state);
1313 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1314 socket_enter_stop_post(s, SOCKET_SUCCESS);
1316 socket_enter_dead(s, SOCKET_SUCCESS);
1321 log_warning_unit(UNIT(s)->id,
1322 "%s failed to kill processes: %s",
1323 UNIT(s)->id, strerror(-r));
1325 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1326 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1328 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1331 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1335 if (f != SOCKET_SUCCESS)
1338 socket_unwatch_control_pid(s);
1340 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1342 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1343 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1346 socket_set_state(s, SOCKET_STOP_PRE);
1348 socket_enter_stop_post(s, SOCKET_SUCCESS);
1353 log_warning_unit(UNIT(s)->id,
1354 "%s failed to run 'stop-pre' task: %s",
1355 UNIT(s)->id, strerror(-r));
1356 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1359 static void socket_enter_listening(Socket *s) {
1363 r = socket_watch_fds(s);
1365 log_warning_unit(UNIT(s)->id,
1366 "%s failed to watch sockets: %s",
1367 UNIT(s)->id, strerror(-r));
1371 socket_set_state(s, SOCKET_LISTENING);
1375 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1378 static void socket_enter_start_post(Socket *s) {
1382 r = socket_open_fds(s);
1384 log_warning_unit(UNIT(s)->id,
1385 "%s failed to listen on sockets: %s",
1386 UNIT(s)->id, strerror(-r));
1390 socket_unwatch_control_pid(s);
1392 s->control_command_id = SOCKET_EXEC_START_POST;
1394 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1395 r = socket_spawn(s, s->control_command, &s->control_pid);
1397 log_warning_unit(UNIT(s)->id,
1398 "%s failed to run 'start-post' task: %s",
1399 UNIT(s)->id, strerror(-r));
1403 socket_set_state(s, SOCKET_START_POST);
1405 socket_enter_listening(s);
1410 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1413 static void socket_enter_start_pre(Socket *s) {
1417 socket_unwatch_control_pid(s);
1419 s->control_command_id = SOCKET_EXEC_START_PRE;
1421 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1422 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1425 socket_set_state(s, SOCKET_START_PRE);
1427 socket_enter_start_post(s);
1432 log_warning_unit(UNIT(s)->id,
1433 "%s failed to run 'start-pre' task: %s",
1434 UNIT(s)->id, strerror(-r));
1435 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1438 static void socket_enter_running(Socket *s, int cfd) {
1443 dbus_error_init(&error);
1445 /* We don't take connections anymore if we are supposed to
1446 * shut down anyway */
1447 if (unit_pending_inactive(UNIT(s))) {
1448 log_debug_unit(UNIT(s)->id,
1449 "Suppressing connection request on %s since unit stop is scheduled.",
1453 close_nointr_nofail(cfd);
1455 /* Flush all sockets by closing and reopening them */
1456 socket_close_fds(s);
1458 r = socket_watch_fds(s);
1460 log_warning_unit(UNIT(s)->id,
1461 "%s failed to watch sockets: %s",
1462 UNIT(s)->id, strerror(-r));
1463 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1473 bool pending = false;
1475 /* If there's already a start pending don't bother to
1477 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1478 if (unit_pending_active(u)) {
1484 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1489 socket_set_state(s, SOCKET_RUNNING);
1491 char *prefix, *instance = NULL, *name;
1494 if (s->n_connections >= s->max_connections) {
1495 log_warning_unit(UNIT(s)->id,
1496 "%s: Too many incoming connections (%u)",
1497 UNIT(s)->id, s->n_connections);
1498 close_nointr_nofail(cfd);
1502 r = socket_instantiate_service(s);
1506 r = instance_from_socket(cfd, s->n_accepted, &instance);
1511 /* ENOTCONN is legitimate if TCP RST was received.
1512 * This connection is over, but the socket unit lives on. */
1513 close_nointr_nofail(cfd);
1517 prefix = unit_name_to_prefix(UNIT(s)->id);
1524 name = unit_name_build(prefix, instance, ".service");
1533 r = unit_add_name(UNIT_DEREF(s->service), name);
1539 service = SERVICE(UNIT_DEREF(s->service));
1540 unit_ref_unset(&s->service);
1543 UNIT(service)->no_gc = false;
1545 unit_choose_id(UNIT(service), name);
1548 r = service_set_socket_fd(service, cfd, s);
1553 s->n_connections ++;
1555 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1559 /* Notify clients about changed counters */
1560 unit_add_to_dbus_queue(UNIT(s));
1566 log_warning_unit(UNIT(s)->id,
1567 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1569 cfd >= 0 ? "template" : "non-template",
1570 bus_error(&error, r));
1571 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1574 close_nointr_nofail(cfd);
1576 dbus_error_free(&error);
1579 static void socket_run_next(Socket *s) {
1583 assert(s->control_command);
1584 assert(s->control_command->command_next);
1586 socket_unwatch_control_pid(s);
1588 s->control_command = s->control_command->command_next;
1590 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1596 log_warning_unit(UNIT(s)->id,
1597 "%s failed to run next task: %s",
1598 UNIT(s)->id, strerror(-r));
1600 if (s->state == SOCKET_START_POST)
1601 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1602 else if (s->state == SOCKET_STOP_POST)
1603 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1605 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1608 static int socket_start(Unit *u) {
1609 Socket *s = SOCKET(u);
1613 /* We cannot fulfill this request right now, try again later
1615 if (s->state == SOCKET_STOP_PRE ||
1616 s->state == SOCKET_STOP_PRE_SIGKILL ||
1617 s->state == SOCKET_STOP_PRE_SIGTERM ||
1618 s->state == SOCKET_STOP_POST ||
1619 s->state == SOCKET_FINAL_SIGTERM ||
1620 s->state == SOCKET_FINAL_SIGKILL)
1623 if (s->state == SOCKET_START_PRE ||
1624 s->state == SOCKET_START_POST)
1627 /* Cannot run this without the service being around */
1628 if (UNIT_DEREF(s->service)) {
1631 service = SERVICE(UNIT_DEREF(s->service));
1633 if (UNIT(service)->load_state != UNIT_LOADED) {
1634 log_error_unit(UNIT(service)->id,
1635 "Socket service %s not loaded, refusing.",
1640 /* If the service is already active we cannot start the
1642 if (service->state != SERVICE_DEAD &&
1643 service->state != SERVICE_FAILED &&
1644 service->state != SERVICE_AUTO_RESTART) {
1645 log_error_unit(UNIT(service)->id,
1646 "Socket service %s already active, refusing.",
1651 #ifdef HAVE_SYSV_COMPAT
1652 if (service->is_sysv) {
1653 log_error_unit(UNIT(s)->id,
1654 "Using SysV services for socket activation is not supported. Refusing.");
1660 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1662 s->result = SOCKET_SUCCESS;
1663 socket_enter_start_pre(s);
1667 static int socket_stop(Unit *u) {
1668 Socket *s = SOCKET(u);
1673 if (s->state == SOCKET_STOP_PRE ||
1674 s->state == SOCKET_STOP_PRE_SIGTERM ||
1675 s->state == SOCKET_STOP_PRE_SIGKILL ||
1676 s->state == SOCKET_STOP_POST ||
1677 s->state == SOCKET_FINAL_SIGTERM ||
1678 s->state == SOCKET_FINAL_SIGKILL)
1681 /* If there's already something running we go directly into
1683 if (s->state == SOCKET_START_PRE ||
1684 s->state == SOCKET_START_POST) {
1685 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1689 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1691 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1695 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1696 Socket *s = SOCKET(u);
1704 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1705 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1706 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1708 if (s->control_pid > 0)
1709 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1711 if (s->control_command_id >= 0)
1712 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1714 LIST_FOREACH(port, p, s->ports) {
1720 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1723 if (p->type == SOCKET_SOCKET) {
1726 r = socket_address_print(&p->address, &t);
1730 if (socket_address_family(&p->address) == AF_NETLINK)
1731 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1733 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1735 } else if (p->type == SOCKET_SPECIAL)
1736 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1737 else if (p->type == SOCKET_MQUEUE)
1738 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1740 assert(p->type == SOCKET_FIFO);
1741 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1748 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1749 Socket *s = SOCKET(u);
1756 if (streq(key, "state")) {
1759 state = socket_state_from_string(value);
1761 log_debug_unit(u->id,
1762 "Failed to parse state value %s", value);
1764 s->deserialized_state = state;
1765 } else if (streq(key, "result")) {
1768 f = socket_result_from_string(value);
1770 log_debug_unit(u->id,
1771 "Failed to parse result value %s", value);
1772 else if (f != SOCKET_SUCCESS)
1775 } else if (streq(key, "n-accepted")) {
1778 if (safe_atou(value, &k) < 0)
1779 log_debug_unit(u->id,
1780 "Failed to parse n-accepted value %s", value);
1783 } else if (streq(key, "control-pid")) {
1786 if (parse_pid(value, &pid) < 0)
1787 log_debug_unit(u->id,
1788 "Failed to parse control-pid value %s", value);
1790 s->control_pid = pid;
1791 } else if (streq(key, "control-command")) {
1792 SocketExecCommand id;
1794 id = socket_exec_command_from_string(value);
1796 log_debug_unit(u->id,
1797 "Failed to parse exec-command value %s", value);
1799 s->control_command_id = id;
1800 s->control_command = s->exec_command[id];
1802 } else if (streq(key, "fifo")) {
1806 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1807 log_debug_unit(u->id,
1808 "Failed to parse fifo value %s", value);
1811 LIST_FOREACH(port, p, s->ports)
1812 if (p->type == SOCKET_FIFO &&
1813 streq_ptr(p->path, value+skip))
1818 close_nointr_nofail(p->fd);
1819 p->fd = fdset_remove(fds, fd);
1823 } else if (streq(key, "special")) {
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 special value %s", value);
1832 LIST_FOREACH(port, p, s->ports)
1833 if (p->type == SOCKET_SPECIAL &&
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, "mqueue")) {
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 mqueue value %s", value);
1853 LIST_FOREACH(port, p, s->ports)
1854 if (p->type == SOCKET_MQUEUE &&
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, "socket")) {
1866 int fd, type, skip = 0;
1869 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1870 log_debug_unit(u->id,
1871 "Failed to parse socket value %s", value);
1874 LIST_FOREACH(port, p, s->ports)
1875 if (socket_address_is(&p->address, value+skip, type))
1880 close_nointr_nofail(p->fd);
1881 p->fd = fdset_remove(fds, fd);
1885 } else if (streq(key, "netlink")) {
1889 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1890 log_debug_unit(u->id,
1891 "Failed to parse socket value %s", value);
1894 LIST_FOREACH(port, p, s->ports)
1895 if (socket_address_is_netlink(&p->address, value+skip))
1900 close_nointr_nofail(p->fd);
1901 p->fd = fdset_remove(fds, fd);
1906 log_debug_unit(UNIT(s)->id,
1907 "Unknown serialization key '%s'", key);
1912 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1913 Socket *s = SOCKET(u);
1918 LIST_FOREACH(port, p, s->ports) {
1922 if (p->type != SOCKET_SOCKET)
1928 FDSET_FOREACH(fd, fds, i) {
1929 if (socket_address_matches_fd(&p->address, fd)) {
1930 p->fd = fdset_remove(fds, fd);
1931 s->deserialized_state = SOCKET_LISTENING;
1940 static UnitActiveState socket_active_state(Unit *u) {
1943 return state_translation_table[SOCKET(u)->state];
1946 static const char *socket_sub_state_to_string(Unit *u) {
1949 return socket_state_to_string(SOCKET(u)->state);
1952 static bool socket_check_gc(Unit *u) {
1953 Socket *s = SOCKET(u);
1957 return s->n_connections > 0;
1960 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1961 Socket *s = SOCKET(u);
1967 if (s->state != SOCKET_LISTENING)
1970 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1972 if (events != EPOLLIN) {
1974 if (events & EPOLLHUP)
1975 log_error_unit(u->id,
1976 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
1979 log_error_unit(u->id,
1980 "%s: Got unexpected poll event (0x%x) on socket.",
1986 if (w->socket_accept) {
1989 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1995 log_error_unit(u->id,
1996 "Failed to accept socket: %m");
2003 socket_apply_socket_options(s, cfd);
2006 socket_enter_running(s, cfd);
2010 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2013 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2014 Socket *s = SOCKET(u);
2020 if (pid != s->control_pid)
2025 if (is_clean_exit(code, status, NULL))
2027 else if (code == CLD_EXITED)
2028 f = SOCKET_FAILURE_EXIT_CODE;
2029 else if (code == CLD_KILLED)
2030 f = SOCKET_FAILURE_SIGNAL;
2031 else if (code == CLD_DUMPED)
2032 f = SOCKET_FAILURE_CORE_DUMP;
2034 assert_not_reached("Unknown code");
2036 if (s->control_command) {
2037 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2039 if (s->control_command->ignore)
2043 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2045 "%s control process exited, code=%s status=%i",
2046 u->id, sigchld_code_to_string(code), status);
2048 if (f != SOCKET_SUCCESS)
2051 if (s->control_command &&
2052 s->control_command->command_next &&
2053 f == SOCKET_SUCCESS) {
2055 log_debug_unit(u->id,
2056 "%s running next command for state %s",
2057 u->id, socket_state_to_string(s->state));
2060 s->control_command = NULL;
2061 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2063 /* No further commands for this step, so let's figure
2064 * out what to do next */
2066 log_debug_unit(u->id,
2067 "%s got final SIGCHLD for state %s",
2068 u->id, socket_state_to_string(s->state));
2072 case SOCKET_START_PRE:
2073 if (f == SOCKET_SUCCESS)
2074 socket_enter_start_post(s);
2076 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2079 case SOCKET_START_POST:
2080 if (f == SOCKET_SUCCESS)
2081 socket_enter_listening(s);
2083 socket_enter_stop_pre(s, f);
2086 case SOCKET_STOP_PRE:
2087 case SOCKET_STOP_PRE_SIGTERM:
2088 case SOCKET_STOP_PRE_SIGKILL:
2089 socket_enter_stop_post(s, f);
2092 case SOCKET_STOP_POST:
2093 case SOCKET_FINAL_SIGTERM:
2094 case SOCKET_FINAL_SIGKILL:
2095 socket_enter_dead(s, f);
2099 assert_not_reached("Uh, control process died at wrong time.");
2103 /* Notify clients about changed exit status */
2104 unit_add_to_dbus_queue(u);
2107 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2108 Socket *s = SOCKET(u);
2111 assert(elapsed == 1);
2112 assert(w == &s->timer_watch);
2116 case SOCKET_START_PRE:
2117 log_warning_unit(u->id,
2118 "%s starting timed out. Terminating.", u->id);
2119 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2122 case SOCKET_START_POST:
2123 log_warning_unit(u->id,
2124 "%s starting timed out. Stopping.", u->id);
2125 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2128 case SOCKET_STOP_PRE:
2129 log_warning_unit(u->id,
2130 "%s stopping timed out. Terminating.", u->id);
2131 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2134 case SOCKET_STOP_PRE_SIGTERM:
2135 if (s->kill_context.send_sigkill) {
2136 log_warning_unit(u->id,
2137 "%s stopping timed out. Killing.", u->id);
2138 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2140 log_warning_unit(u->id,
2141 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2143 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2147 case SOCKET_STOP_PRE_SIGKILL:
2148 log_warning_unit(u->id,
2149 "%s still around after SIGKILL. Ignoring.", u->id);
2150 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2153 case SOCKET_STOP_POST:
2154 log_warning_unit(u->id,
2155 "%s stopping timed out (2). Terminating.", u->id);
2156 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2159 case SOCKET_FINAL_SIGTERM:
2160 if (s->kill_context.send_sigkill) {
2161 log_warning_unit(u->id,
2162 "%s stopping timed out (2). Killing.", u->id);
2163 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2165 log_warning_unit(u->id,
2166 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2168 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2172 case SOCKET_FINAL_SIGKILL:
2173 log_warning_unit(u->id,
2174 "%s still around after SIGKILL (2). Entering failed mode.",
2176 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2180 assert_not_reached("Timeout at wrong time.");
2184 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2193 /* Called from the service code for requesting our fds */
2196 LIST_FOREACH(port, p, s->ports)
2206 if (!(rfds = new(int, rn_fds)))
2210 LIST_FOREACH(port, p, s->ports)
2214 assert(k == rn_fds);
2222 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2225 /* The service is dead. Dang!
2227 * This is strictly for one-instance-for-all-connections
2230 if (s->state == SOCKET_RUNNING) {
2231 log_debug_unit(UNIT(s)->id,
2232 "%s got notified about service death (failed permanently: %s)",
2233 UNIT(s)->id, yes_no(failed_permanent));
2234 if (failed_permanent)
2235 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2237 socket_enter_listening(s);
2241 void socket_connection_unref(Socket *s) {
2244 /* The service is dead. Yay!
2246 * This is strictly for one-instance-per-connection
2249 assert(s->n_connections > 0);
2252 log_debug_unit(UNIT(s)->id,
2253 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2256 static void socket_reset_failed(Unit *u) {
2257 Socket *s = SOCKET(u);
2261 if (s->state == SOCKET_FAILED)
2262 socket_set_state(s, SOCKET_DEAD);
2264 s->result = SOCKET_SUCCESS;
2267 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2268 Socket *s = SOCKET(u);
2270 Set *pid_set = NULL;
2274 if (who == KILL_MAIN) {
2275 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2279 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2280 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2284 if (who == KILL_CONTROL || who == KILL_ALL)
2285 if (s->control_pid > 0)
2286 if (kill(s->control_pid, signo) < 0)
2289 if (who == KILL_ALL) {
2292 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2296 /* Exclude the control pid from being killed via the cgroup */
2297 if (s->control_pid > 0) {
2298 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2305 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2306 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2317 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2318 [SOCKET_DEAD] = "dead",
2319 [SOCKET_START_PRE] = "start-pre",
2320 [SOCKET_START_POST] = "start-post",
2321 [SOCKET_LISTENING] = "listening",
2322 [SOCKET_RUNNING] = "running",
2323 [SOCKET_STOP_PRE] = "stop-pre",
2324 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2325 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2326 [SOCKET_STOP_POST] = "stop-post",
2327 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2328 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2329 [SOCKET_FAILED] = "failed"
2332 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2334 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2335 [SOCKET_EXEC_START_PRE] = "StartPre",
2336 [SOCKET_EXEC_START_POST] = "StartPost",
2337 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2338 [SOCKET_EXEC_STOP_POST] = "StopPost"
2341 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2343 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2344 [SOCKET_SUCCESS] = "success",
2345 [SOCKET_FAILURE_RESOURCES] = "resources",
2346 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2347 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2348 [SOCKET_FAILURE_SIGNAL] = "signal",
2349 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2350 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2353 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2355 const UnitVTable socket_vtable = {
2356 .object_size = sizeof(Socket),
2363 .exec_context_offset = offsetof(Socket, exec_context),
2364 .exec_section = "Socket",
2366 .init = socket_init,
2367 .done = socket_done,
2368 .load = socket_load,
2370 .kill = socket_kill,
2372 .coldplug = socket_coldplug,
2374 .dump = socket_dump,
2376 .start = socket_start,
2377 .stop = socket_stop,
2379 .serialize = socket_serialize,
2380 .deserialize_item = socket_deserialize_item,
2381 .distribute_fds = socket_distribute_fds,
2383 .active_state = socket_active_state,
2384 .sub_state_to_string = socket_sub_state_to_string,
2386 .check_gc = socket_check_gc,
2388 .fd_event = socket_fd_event,
2389 .sigchld_event = socket_sigchld_event,
2390 .timer_event = socket_timer_event,
2392 .reset_failed = socket_reset_failed,
2394 .bus_interface = "org.freedesktop.systemd1.Socket",
2395 .bus_message_handler = bus_socket_message_handler,
2396 .bus_invalidating_properties = bus_socket_invalidating_properties,
2398 .status_message_formats = {
2399 /*.starting_stopping = {
2400 [0] = "Starting socket %s...",
2401 [1] = "Stopping socket %s...",
2403 .finished_start_job = {
2404 [JOB_DONE] = "Listening on %s.",
2405 [JOB_FAILED] = "Failed to listen on %s.",
2406 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2407 [JOB_TIMEOUT] = "Timed out starting %s.",
2409 .finished_stop_job = {
2410 [JOB_DONE] = "Closed %s.",
2411 [JOB_FAILED] = "Failed stopping %s.",
2412 [JOB_TIMEOUT] = "Timed out stopping %s.",