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) {
1291 Set *pid_set = NULL;
1292 bool wait_for_exit = false;
1296 if (f != SOCKET_SUCCESS)
1299 if (s->kill_context.kill_mode != KILL_NONE) {
1300 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1302 if (s->control_pid > 0) {
1303 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1305 log_warning_unit(UNIT(s)->id,
1306 "Failed to kill control process %li: %m",
1307 (long) s->control_pid);
1309 wait_for_exit = true;
1312 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1314 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1319 /* Exclude the control pid from being killed via the cgroup */
1320 if (s->control_pid > 0)
1321 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1324 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1326 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1327 log_warning_unit(UNIT(s)->id,
1328 "Failed to kill control group: %s",
1331 wait_for_exit = true;
1338 if (wait_for_exit) {
1339 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1343 socket_set_state(s, state);
1344 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1345 socket_enter_stop_post(s, SOCKET_SUCCESS);
1347 socket_enter_dead(s, SOCKET_SUCCESS);
1352 log_warning_unit(UNIT(s)->id,
1353 "%s failed to kill processes: %s",
1354 UNIT(s)->id, strerror(-r));
1356 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1357 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1359 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1365 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1369 if (f != SOCKET_SUCCESS)
1372 socket_unwatch_control_pid(s);
1374 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1376 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1377 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1380 socket_set_state(s, SOCKET_STOP_PRE);
1382 socket_enter_stop_post(s, SOCKET_SUCCESS);
1387 log_warning_unit(UNIT(s)->id,
1388 "%s failed to run 'stop-pre' task: %s",
1389 UNIT(s)->id, strerror(-r));
1390 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1393 static void socket_enter_listening(Socket *s) {
1397 r = socket_watch_fds(s);
1399 log_warning_unit(UNIT(s)->id,
1400 "%s failed to watch sockets: %s",
1401 UNIT(s)->id, strerror(-r));
1405 socket_set_state(s, SOCKET_LISTENING);
1409 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1412 static void socket_enter_start_post(Socket *s) {
1416 r = socket_open_fds(s);
1418 log_warning_unit(UNIT(s)->id,
1419 "%s failed to listen on sockets: %s",
1420 UNIT(s)->id, strerror(-r));
1424 socket_unwatch_control_pid(s);
1426 s->control_command_id = SOCKET_EXEC_START_POST;
1428 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1429 r = socket_spawn(s, s->control_command, &s->control_pid);
1431 log_warning_unit(UNIT(s)->id,
1432 "%s failed to run 'start-post' task: %s",
1433 UNIT(s)->id, strerror(-r));
1437 socket_set_state(s, SOCKET_START_POST);
1439 socket_enter_listening(s);
1444 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1447 static void socket_enter_start_pre(Socket *s) {
1451 socket_unwatch_control_pid(s);
1453 s->control_command_id = SOCKET_EXEC_START_PRE;
1455 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1456 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1459 socket_set_state(s, SOCKET_START_PRE);
1461 socket_enter_start_post(s);
1466 log_warning_unit(UNIT(s)->id,
1467 "%s failed to run 'start-pre' task: %s",
1468 UNIT(s)->id, strerror(-r));
1469 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1472 static void socket_enter_running(Socket *s, int cfd) {
1477 dbus_error_init(&error);
1479 /* We don't take connections anymore if we are supposed to
1480 * shut down anyway */
1481 if (unit_pending_inactive(UNIT(s))) {
1482 log_debug_unit(UNIT(s)->id,
1483 "Suppressing connection request on %s since unit stop is scheduled.",
1487 close_nointr_nofail(cfd);
1489 /* Flush all sockets by closing and reopening them */
1490 socket_close_fds(s);
1492 r = socket_watch_fds(s);
1494 log_warning_unit(UNIT(s)->id,
1495 "%s failed to watch sockets: %s",
1496 UNIT(s)->id, strerror(-r));
1497 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1507 bool pending = false;
1509 /* If there's already a start pending don't bother to
1511 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1512 if (unit_pending_active(u)) {
1518 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1523 socket_set_state(s, SOCKET_RUNNING);
1525 char *prefix, *instance = NULL, *name;
1528 if (s->n_connections >= s->max_connections) {
1529 log_warning_unit(UNIT(s)->id,
1530 "%s: Too many incoming connections (%u)",
1531 UNIT(s)->id, s->n_connections);
1532 close_nointr_nofail(cfd);
1536 r = socket_instantiate_service(s);
1540 r = instance_from_socket(cfd, s->n_accepted, &instance);
1545 /* ENOTCONN is legitimate if TCP RST was received.
1546 * This connection is over, but the socket unit lives on. */
1547 close_nointr_nofail(cfd);
1551 prefix = unit_name_to_prefix(UNIT(s)->id);
1558 name = unit_name_build(prefix, instance, ".service");
1567 r = unit_add_name(UNIT_DEREF(s->service), name);
1573 service = SERVICE(UNIT_DEREF(s->service));
1574 unit_ref_unset(&s->service);
1577 UNIT(service)->no_gc = false;
1579 unit_choose_id(UNIT(service), name);
1582 r = service_set_socket_fd(service, cfd, s);
1587 s->n_connections ++;
1589 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1593 /* Notify clients about changed counters */
1594 unit_add_to_dbus_queue(UNIT(s));
1600 log_warning_unit(UNIT(s)->id,
1601 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1603 cfd >= 0 ? "template" : "non-template",
1604 bus_error(&error, r));
1605 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1608 close_nointr_nofail(cfd);
1610 dbus_error_free(&error);
1613 static void socket_run_next(Socket *s) {
1617 assert(s->control_command);
1618 assert(s->control_command->command_next);
1620 socket_unwatch_control_pid(s);
1622 s->control_command = s->control_command->command_next;
1624 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1630 log_warning_unit(UNIT(s)->id,
1631 "%s failed to run next task: %s",
1632 UNIT(s)->id, strerror(-r));
1634 if (s->state == SOCKET_START_POST)
1635 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1636 else if (s->state == SOCKET_STOP_POST)
1637 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1639 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1642 static int socket_start(Unit *u) {
1643 Socket *s = SOCKET(u);
1647 /* We cannot fulfill this request right now, try again later
1649 if (s->state == SOCKET_STOP_PRE ||
1650 s->state == SOCKET_STOP_PRE_SIGKILL ||
1651 s->state == SOCKET_STOP_PRE_SIGTERM ||
1652 s->state == SOCKET_STOP_POST ||
1653 s->state == SOCKET_FINAL_SIGTERM ||
1654 s->state == SOCKET_FINAL_SIGKILL)
1657 if (s->state == SOCKET_START_PRE ||
1658 s->state == SOCKET_START_POST)
1661 /* Cannot run this without the service being around */
1662 if (UNIT_DEREF(s->service)) {
1665 service = SERVICE(UNIT_DEREF(s->service));
1667 if (UNIT(service)->load_state != UNIT_LOADED) {
1668 log_error_unit(UNIT(service)->id,
1669 "Socket service %s not loaded, refusing.",
1674 /* If the service is already active we cannot start the
1676 if (service->state != SERVICE_DEAD &&
1677 service->state != SERVICE_FAILED &&
1678 service->state != SERVICE_AUTO_RESTART) {
1679 log_error_unit(UNIT(service)->id,
1680 "Socket service %s already active, refusing.",
1685 #ifdef HAVE_SYSV_COMPAT
1686 if (service->is_sysv) {
1687 log_error_unit(UNIT(s)->id,
1688 "Using SysV services for socket activation is not supported. Refusing.");
1694 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1696 s->result = SOCKET_SUCCESS;
1697 socket_enter_start_pre(s);
1701 static int socket_stop(Unit *u) {
1702 Socket *s = SOCKET(u);
1707 if (s->state == SOCKET_STOP_PRE ||
1708 s->state == SOCKET_STOP_PRE_SIGTERM ||
1709 s->state == SOCKET_STOP_PRE_SIGKILL ||
1710 s->state == SOCKET_STOP_POST ||
1711 s->state == SOCKET_FINAL_SIGTERM ||
1712 s->state == SOCKET_FINAL_SIGKILL)
1715 /* If there's already something running we go directly into
1717 if (s->state == SOCKET_START_PRE ||
1718 s->state == SOCKET_START_POST) {
1719 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1723 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1725 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1729 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1730 Socket *s = SOCKET(u);
1738 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1739 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1740 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1742 if (s->control_pid > 0)
1743 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1745 if (s->control_command_id >= 0)
1746 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1748 LIST_FOREACH(port, p, s->ports) {
1754 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1757 if (p->type == SOCKET_SOCKET) {
1760 r = socket_address_print(&p->address, &t);
1764 if (socket_address_family(&p->address) == AF_NETLINK)
1765 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1767 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1769 } else if (p->type == SOCKET_SPECIAL)
1770 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1771 else if (p->type == SOCKET_MQUEUE)
1772 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1774 assert(p->type == SOCKET_FIFO);
1775 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1782 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1783 Socket *s = SOCKET(u);
1790 if (streq(key, "state")) {
1793 state = socket_state_from_string(value);
1795 log_debug_unit(u->id,
1796 "Failed to parse state value %s", value);
1798 s->deserialized_state = state;
1799 } else if (streq(key, "result")) {
1802 f = socket_result_from_string(value);
1804 log_debug_unit(u->id,
1805 "Failed to parse result value %s", value);
1806 else if (f != SOCKET_SUCCESS)
1809 } else if (streq(key, "n-accepted")) {
1812 if (safe_atou(value, &k) < 0)
1813 log_debug_unit(u->id,
1814 "Failed to parse n-accepted value %s", value);
1817 } else if (streq(key, "control-pid")) {
1820 if (parse_pid(value, &pid) < 0)
1821 log_debug_unit(u->id,
1822 "Failed to parse control-pid value %s", value);
1824 s->control_pid = pid;
1825 } else if (streq(key, "control-command")) {
1826 SocketExecCommand id;
1828 id = socket_exec_command_from_string(value);
1830 log_debug_unit(u->id,
1831 "Failed to parse exec-command value %s", value);
1833 s->control_command_id = id;
1834 s->control_command = s->exec_command[id];
1836 } else if (streq(key, "fifo")) {
1840 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1841 log_debug_unit(u->id,
1842 "Failed to parse fifo value %s", value);
1845 LIST_FOREACH(port, p, s->ports)
1846 if (p->type == SOCKET_FIFO &&
1847 streq_ptr(p->path, value+skip))
1852 close_nointr_nofail(p->fd);
1853 p->fd = fdset_remove(fds, fd);
1857 } else if (streq(key, "special")) {
1861 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1862 log_debug_unit(u->id,
1863 "Failed to parse special value %s", value);
1866 LIST_FOREACH(port, p, s->ports)
1867 if (p->type == SOCKET_SPECIAL &&
1868 streq_ptr(p->path, value+skip))
1873 close_nointr_nofail(p->fd);
1874 p->fd = fdset_remove(fds, fd);
1878 } else if (streq(key, "mqueue")) {
1882 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1883 log_debug_unit(u->id,
1884 "Failed to parse mqueue value %s", value);
1887 LIST_FOREACH(port, p, s->ports)
1888 if (p->type == SOCKET_MQUEUE &&
1889 streq_ptr(p->path, value+skip))
1894 close_nointr_nofail(p->fd);
1895 p->fd = fdset_remove(fds, fd);
1899 } else if (streq(key, "socket")) {
1900 int fd, type, skip = 0;
1903 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1904 log_debug_unit(u->id,
1905 "Failed to parse socket value %s", value);
1908 LIST_FOREACH(port, p, s->ports)
1909 if (socket_address_is(&p->address, value+skip, type))
1914 close_nointr_nofail(p->fd);
1915 p->fd = fdset_remove(fds, fd);
1919 } else if (streq(key, "netlink")) {
1923 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1924 log_debug_unit(u->id,
1925 "Failed to parse socket value %s", value);
1928 LIST_FOREACH(port, p, s->ports)
1929 if (socket_address_is_netlink(&p->address, value+skip))
1934 close_nointr_nofail(p->fd);
1935 p->fd = fdset_remove(fds, fd);
1940 log_debug_unit(UNIT(s)->id,
1941 "Unknown serialization key '%s'", key);
1946 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1947 Socket *s = SOCKET(u);
1952 LIST_FOREACH(port, p, s->ports) {
1956 if (p->type != SOCKET_SOCKET)
1962 FDSET_FOREACH(fd, fds, i) {
1963 if (socket_address_matches_fd(&p->address, fd)) {
1964 p->fd = fdset_remove(fds, fd);
1965 s->deserialized_state = SOCKET_LISTENING;
1974 static UnitActiveState socket_active_state(Unit *u) {
1977 return state_translation_table[SOCKET(u)->state];
1980 static const char *socket_sub_state_to_string(Unit *u) {
1983 return socket_state_to_string(SOCKET(u)->state);
1986 static bool socket_check_gc(Unit *u) {
1987 Socket *s = SOCKET(u);
1991 return s->n_connections > 0;
1994 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1995 Socket *s = SOCKET(u);
2001 if (s->state != SOCKET_LISTENING)
2004 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2006 if (events != EPOLLIN) {
2008 if (events & EPOLLHUP)
2009 log_error_unit(u->id,
2010 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2013 log_error_unit(u->id,
2014 "%s: Got unexpected poll event (0x%x) on socket.",
2020 if (w->socket_accept) {
2023 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2029 log_error_unit(u->id,
2030 "Failed to accept socket: %m");
2037 socket_apply_socket_options(s, cfd);
2040 socket_enter_running(s, cfd);
2044 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2047 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2048 Socket *s = SOCKET(u);
2054 if (pid != s->control_pid)
2059 if (is_clean_exit(code, status, NULL))
2061 else if (code == CLD_EXITED)
2062 f = SOCKET_FAILURE_EXIT_CODE;
2063 else if (code == CLD_KILLED)
2064 f = SOCKET_FAILURE_SIGNAL;
2065 else if (code == CLD_DUMPED)
2066 f = SOCKET_FAILURE_CORE_DUMP;
2068 assert_not_reached("Unknown code");
2070 if (s->control_command) {
2071 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2073 if (s->control_command->ignore)
2077 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2079 "%s control process exited, code=%s status=%i",
2080 u->id, sigchld_code_to_string(code), status);
2082 if (f != SOCKET_SUCCESS)
2085 if (s->control_command &&
2086 s->control_command->command_next &&
2087 f == SOCKET_SUCCESS) {
2089 log_debug_unit(u->id,
2090 "%s running next command for state %s",
2091 u->id, socket_state_to_string(s->state));
2094 s->control_command = NULL;
2095 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2097 /* No further commands for this step, so let's figure
2098 * out what to do next */
2100 log_debug_unit(u->id,
2101 "%s got final SIGCHLD for state %s",
2102 u->id, socket_state_to_string(s->state));
2106 case SOCKET_START_PRE:
2107 if (f == SOCKET_SUCCESS)
2108 socket_enter_start_post(s);
2110 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2113 case SOCKET_START_POST:
2114 if (f == SOCKET_SUCCESS)
2115 socket_enter_listening(s);
2117 socket_enter_stop_pre(s, f);
2120 case SOCKET_STOP_PRE:
2121 case SOCKET_STOP_PRE_SIGTERM:
2122 case SOCKET_STOP_PRE_SIGKILL:
2123 socket_enter_stop_post(s, f);
2126 case SOCKET_STOP_POST:
2127 case SOCKET_FINAL_SIGTERM:
2128 case SOCKET_FINAL_SIGKILL:
2129 socket_enter_dead(s, f);
2133 assert_not_reached("Uh, control process died at wrong time.");
2137 /* Notify clients about changed exit status */
2138 unit_add_to_dbus_queue(u);
2141 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2142 Socket *s = SOCKET(u);
2145 assert(elapsed == 1);
2146 assert(w == &s->timer_watch);
2150 case SOCKET_START_PRE:
2151 log_warning_unit(u->id,
2152 "%s starting timed out. Terminating.", u->id);
2153 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2156 case SOCKET_START_POST:
2157 log_warning_unit(u->id,
2158 "%s starting timed out. Stopping.", u->id);
2159 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2162 case SOCKET_STOP_PRE:
2163 log_warning_unit(u->id,
2164 "%s stopping timed out. Terminating.", u->id);
2165 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2168 case SOCKET_STOP_PRE_SIGTERM:
2169 if (s->kill_context.send_sigkill) {
2170 log_warning_unit(u->id,
2171 "%s stopping timed out. Killing.", u->id);
2172 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2174 log_warning_unit(u->id,
2175 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2177 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2181 case SOCKET_STOP_PRE_SIGKILL:
2182 log_warning_unit(u->id,
2183 "%s still around after SIGKILL. Ignoring.", u->id);
2184 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2187 case SOCKET_STOP_POST:
2188 log_warning_unit(u->id,
2189 "%s stopping timed out (2). Terminating.", u->id);
2190 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2193 case SOCKET_FINAL_SIGTERM:
2194 if (s->kill_context.send_sigkill) {
2195 log_warning_unit(u->id,
2196 "%s stopping timed out (2). Killing.", u->id);
2197 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2199 log_warning_unit(u->id,
2200 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2202 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2206 case SOCKET_FINAL_SIGKILL:
2207 log_warning_unit(u->id,
2208 "%s still around after SIGKILL (2). Entering failed mode.",
2210 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2214 assert_not_reached("Timeout at wrong time.");
2218 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2227 /* Called from the service code for requesting our fds */
2230 LIST_FOREACH(port, p, s->ports)
2240 if (!(rfds = new(int, rn_fds)))
2244 LIST_FOREACH(port, p, s->ports)
2248 assert(k == rn_fds);
2256 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2259 /* The service is dead. Dang!
2261 * This is strictly for one-instance-for-all-connections
2264 if (s->state == SOCKET_RUNNING) {
2265 log_debug_unit(UNIT(s)->id,
2266 "%s got notified about service death (failed permanently: %s)",
2267 UNIT(s)->id, yes_no(failed_permanent));
2268 if (failed_permanent)
2269 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2271 socket_enter_listening(s);
2275 void socket_connection_unref(Socket *s) {
2278 /* The service is dead. Yay!
2280 * This is strictly for one-instance-per-connection
2283 assert(s->n_connections > 0);
2286 log_debug_unit(UNIT(s)->id,
2287 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2290 static void socket_reset_failed(Unit *u) {
2291 Socket *s = SOCKET(u);
2295 if (s->state == SOCKET_FAILED)
2296 socket_set_state(s, SOCKET_DEAD);
2298 s->result = SOCKET_SUCCESS;
2301 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2302 Socket *s = SOCKET(u);
2304 Set *pid_set = NULL;
2308 if (who == KILL_MAIN) {
2309 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2313 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2314 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2318 if (who == KILL_CONTROL || who == KILL_ALL)
2319 if (s->control_pid > 0)
2320 if (kill(s->control_pid, signo) < 0)
2323 if (who == KILL_ALL) {
2326 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2330 /* Exclude the control pid from being killed via the cgroup */
2331 if (s->control_pid > 0) {
2332 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2339 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2340 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2351 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2352 [SOCKET_DEAD] = "dead",
2353 [SOCKET_START_PRE] = "start-pre",
2354 [SOCKET_START_POST] = "start-post",
2355 [SOCKET_LISTENING] = "listening",
2356 [SOCKET_RUNNING] = "running",
2357 [SOCKET_STOP_PRE] = "stop-pre",
2358 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2359 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2360 [SOCKET_STOP_POST] = "stop-post",
2361 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2362 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2363 [SOCKET_FAILED] = "failed"
2366 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2368 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2369 [SOCKET_EXEC_START_PRE] = "StartPre",
2370 [SOCKET_EXEC_START_POST] = "StartPost",
2371 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2372 [SOCKET_EXEC_STOP_POST] = "StopPost"
2375 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2377 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2378 [SOCKET_SUCCESS] = "success",
2379 [SOCKET_FAILURE_RESOURCES] = "resources",
2380 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2381 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2382 [SOCKET_FAILURE_SIGNAL] = "signal",
2383 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2384 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2387 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2389 const UnitVTable socket_vtable = {
2390 .object_size = sizeof(Socket),
2397 .exec_context_offset = offsetof(Socket, exec_context),
2398 .exec_section = "Socket",
2400 .init = socket_init,
2401 .done = socket_done,
2402 .load = socket_load,
2404 .kill = socket_kill,
2406 .coldplug = socket_coldplug,
2408 .dump = socket_dump,
2410 .start = socket_start,
2411 .stop = socket_stop,
2413 .serialize = socket_serialize,
2414 .deserialize_item = socket_deserialize_item,
2415 .distribute_fds = socket_distribute_fds,
2417 .active_state = socket_active_state,
2418 .sub_state_to_string = socket_sub_state_to_string,
2420 .check_gc = socket_check_gc,
2422 .fd_event = socket_fd_event,
2423 .sigchld_event = socket_sigchld_event,
2424 .timer_event = socket_timer_event,
2426 .reset_failed = socket_reset_failed,
2428 .bus_interface = "org.freedesktop.systemd1.Socket",
2429 .bus_message_handler = bus_socket_message_handler,
2430 .bus_invalidating_properties = bus_socket_invalidating_properties,
2432 .status_message_formats = {
2433 /*.starting_stopping = {
2434 [0] = "Starting socket %s...",
2435 [1] = "Stopping socket %s...",
2437 .finished_start_job = {
2438 [JOB_DONE] = "Listening on %s.",
2439 [JOB_FAILED] = "Failed to listen on %s.",
2440 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2441 [JOB_TIMEOUT] = "Timed out starting %s.",
2443 .finished_stop_job = {
2444 [JOB_DONE] = "Closed %s.",
2445 [JOB_FAILED] = "Failed stopping %s.",
2446 [JOB_TIMEOUT] = "Timed out stopping %s.",