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 "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);
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, manager_is_reloading_or_reexecuting(u->manager));
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 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
338 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
339 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
344 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
347 static bool socket_has_exec(Socket *s) {
351 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
352 if (s->exec_command[i])
358 static int socket_load(Unit *u) {
359 Socket *s = SOCKET(u);
363 assert(u->load_state == UNIT_STUB);
365 if ((r = unit_load_fragment_and_dropin(u)) < 0)
368 /* This is a new unit? Then let's add in some extras */
369 if (u->load_state == UNIT_LOADED) {
371 if (have_non_accept_socket(s)) {
373 if (!UNIT_DEREF(s->service)) {
376 r = unit_load_related_unit(u, ".service", &x);
380 unit_ref_set(&s->service, x);
383 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
388 if ((r = socket_add_mount_links(s)) < 0)
391 if ((r = socket_add_device_link(s)) < 0)
394 if (socket_has_exec(s))
395 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
398 if ((r = unit_add_default_cgroups(u)) < 0)
401 if (UNIT(s)->default_dependencies)
402 if ((r = socket_add_default_dependencies(s)) < 0)
405 r = unit_exec_context_defaults(u, &s->exec_context);
410 return socket_verify(s);
413 static const char* listen_lookup(int family, int type) {
415 if (family == AF_NETLINK)
416 return "ListenNetlink";
418 if (type == SOCK_STREAM)
419 return "ListenStream";
420 else if (type == SOCK_DGRAM)
421 return "ListenDatagram";
422 else if (type == SOCK_SEQPACKET)
423 return "ListenSequentialPacket";
425 assert_not_reached("Unknown socket type");
429 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
432 Socket *s = SOCKET(u);
440 p2 = strappend(prefix, "\t");
441 prefix2 = p2 ? p2 : prefix;
444 "%sSocket State: %s\n"
446 "%sBindIPv6Only: %s\n"
448 "%sSocketMode: %04o\n"
449 "%sDirectoryMode: %04o\n"
452 "%sTransparent: %s\n"
454 "%sPassCredentials: %s\n"
455 "%sPassSecurity: %s\n"
456 "%sTCPCongestion: %s\n",
457 prefix, socket_state_to_string(s->state),
458 prefix, socket_result_to_string(s->result),
459 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
461 prefix, s->socket_mode,
462 prefix, s->directory_mode,
463 prefix, yes_no(s->keep_alive),
464 prefix, yes_no(s->free_bind),
465 prefix, yes_no(s->transparent),
466 prefix, yes_no(s->broadcast),
467 prefix, yes_no(s->pass_cred),
468 prefix, yes_no(s->pass_sec),
469 prefix, strna(s->tcp_congestion));
471 if (s->control_pid > 0)
473 "%sControl PID: %lu\n",
474 prefix, (unsigned long) s->control_pid);
476 if (s->bind_to_device)
478 "%sBindToDevice: %s\n",
479 prefix, s->bind_to_device);
484 "%sNConnections: %u\n"
485 "%sMaxConnections: %u\n",
486 prefix, s->n_accepted,
487 prefix, s->n_connections,
488 prefix, s->max_connections);
490 if (s->priority >= 0)
493 prefix, s->priority);
495 if (s->receive_buffer > 0)
497 "%sReceiveBuffer: %zu\n",
498 prefix, s->receive_buffer);
500 if (s->send_buffer > 0)
502 "%sSendBuffer: %zu\n",
503 prefix, s->send_buffer);
515 if (s->pipe_size > 0)
518 prefix, s->pipe_size);
525 if (s->mq_maxmsg > 0)
527 "%sMessageQueueMaxMessages: %li\n",
528 prefix, s->mq_maxmsg);
530 if (s->mq_msgsize > 0)
532 "%sMessageQueueMessageSize: %li\n",
533 prefix, s->mq_msgsize);
537 "%sSmackLabel: %s\n",
542 "%sSmackLabelIPIn: %s\n",
543 prefix, s->smack_ip_in);
547 "%sSmackLabelIPOut: %s\n",
548 prefix, s->smack_ip_out);
550 LIST_FOREACH(port, p, s->ports) {
552 if (p->type == SOCKET_SOCKET) {
557 if ((r = socket_address_print(&p->address, &k)) < 0)
562 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
564 } else if (p->type == SOCKET_SPECIAL)
565 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
566 else if (p->type == SOCKET_MQUEUE)
567 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
569 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
572 exec_context_dump(&s->exec_context, f, prefix);
573 kill_context_dump(&s->kill_context, f, prefix);
575 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
576 if (!s->exec_command[c])
579 fprintf(f, "%s-> %s:\n",
580 prefix, socket_exec_command_to_string(c));
582 exec_command_dump_list(s->exec_command[c], f, prefix2);
588 static int instance_from_socket(int fd, unsigned nr, char **instance) {
593 struct sockaddr_un un;
594 struct sockaddr_in in;
595 struct sockaddr_in6 in6;
596 struct sockaddr_storage storage;
603 if (getsockname(fd, &local.sa, &l) < 0)
607 if (getpeername(fd, &remote.sa, &l) < 0)
610 switch (local.sa.sa_family) {
614 a = ntohl(local.in.sin_addr.s_addr),
615 b = ntohl(remote.in.sin_addr.s_addr);
618 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
620 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
621 ntohs(local.in.sin_port),
622 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
623 ntohs(remote.in.sin_port)) < 0)
630 static const unsigned char ipv4_prefix[] = {
631 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
634 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
635 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
637 *a = local.in6.sin6_addr.s6_addr+12,
638 *b = remote.in6.sin6_addr.s6_addr+12;
641 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
643 a[0], a[1], a[2], a[3],
644 ntohs(local.in6.sin6_port),
645 b[0], b[1], b[2], b[3],
646 ntohs(remote.in6.sin6_port)) < 0)
649 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
654 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
655 ntohs(local.in6.sin6_port),
656 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
657 ntohs(remote.in6.sin6_port)) < 0)
668 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
674 (unsigned long) ucred.pid,
675 (unsigned long) ucred.uid) < 0)
682 assert_not_reached("Unhandled socket type.");
689 static void socket_close_fds(Socket *s) {
694 LIST_FOREACH(port, p, s->ports) {
698 unit_unwatch_fd(UNIT(s), &p->fd_watch);
699 close_nointr_nofail(p->fd);
701 /* One little note: we should never delete any sockets
702 * in the file system here! After all some other
703 * process we spawned might still have a reference of
704 * this fd and wants to continue to use it. Therefore
705 * we delete sockets in the file system before we
706 * create a new one, not after we stopped using
713 static void socket_apply_socket_options(Socket *s, int fd) {
718 int b = s->keep_alive;
719 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
720 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
725 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
726 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
731 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
732 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
737 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
738 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
741 if (s->priority >= 0)
742 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
743 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
745 if (s->receive_buffer > 0) {
746 int value = (int) s->receive_buffer;
748 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
750 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
751 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
752 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
755 if (s->send_buffer > 0) {
756 int value = (int) s->send_buffer;
757 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
758 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
759 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
763 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
764 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
767 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
768 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
770 if (s->ip_ttl >= 0) {
773 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
775 if (socket_ipv6_is_supported())
776 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
779 errno = EAFNOSUPPORT;
783 log_warning_unit(UNIT(s)->id,
784 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
787 if (s->tcp_congestion)
788 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
789 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
791 #ifdef HAVE_ATTR_XATTR_H
793 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
794 log_error_unit(UNIT(s)->id,
795 "fsetxattr(\"security.SMACK64IPIN\"): %m");
798 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
799 log_error_unit(UNIT(s)->id,
800 "fsetxattr(\"security.SMACK64IPOUT\"): %m");
804 static void socket_apply_fifo_options(Socket *s, int fd) {
808 if (s->pipe_size > 0)
809 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
810 log_warning_unit(UNIT(s)->id,
813 #ifdef HAVE_ATTR_XATTR_H
815 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
816 log_error_unit(UNIT(s)->id,
817 "fsetxattr(\"security.SMACK64\"): %m");
821 static int fifo_address_create(
823 mode_t directory_mode,
834 mkdir_parents_label(path, directory_mode);
836 r = label_context_set(path, S_IFIFO);
840 /* Enforce the right access mode for the fifo */
841 old_mask = umask(~ socket_mode);
843 /* Include the original umask in our mask */
844 umask(~socket_mode | old_mask);
846 r = mkfifo(path, socket_mode);
849 if (r < 0 && errno != EEXIST) {
854 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
859 label_context_clear();
861 if (fstat(fd, &st) < 0) {
866 if (!S_ISFIFO(st.st_mode) ||
867 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
868 st.st_uid != getuid() ||
869 st.st_gid != getgid()) {
879 label_context_clear();
882 close_nointr_nofail(fd);
887 static int special_address_create(
897 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
902 if (fstat(fd, &st) < 0) {
907 /* Check whether this is a /proc, /sys or /dev file or char device */
908 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
918 close_nointr_nofail(fd);
923 static int mq_address_create(
933 struct mq_attr _attr, *attr = NULL;
938 if (maxmsg > 0 && msgsize > 0) {
940 _attr.mq_flags = O_NONBLOCK;
941 _attr.mq_maxmsg = maxmsg;
942 _attr.mq_msgsize = msgsize;
946 /* Enforce the right access mode for the mq */
947 old_mask = umask(~ mq_mode);
949 /* Include the original umask in our mask */
950 umask(~mq_mode | old_mask);
952 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
960 if (fstat(fd, &st) < 0) {
965 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
966 st.st_uid != getuid() ||
967 st.st_gid != getgid()) {
978 close_nointr_nofail(fd);
983 static int socket_open_fds(Socket *s) {
987 bool know_label = false;
991 LIST_FOREACH(port, p, s->ports) {
996 if (p->type == SOCKET_SOCKET) {
1000 if ((r = socket_instantiate_service(s)) < 0)
1003 if (UNIT_DEREF(s->service) &&
1004 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1005 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1016 if ((r = socket_address_listen(
1029 socket_apply_socket_options(s, p->fd);
1031 } else if (p->type == SOCKET_SPECIAL) {
1033 if ((r = special_address_create(
1038 } else if (p->type == SOCKET_FIFO) {
1040 if ((r = fifo_address_create(
1047 socket_apply_fifo_options(s, p->fd);
1048 } else if (p->type == SOCKET_MQUEUE) {
1050 if ((r = mq_address_create(
1058 assert_not_reached("Unknown port type");
1065 socket_close_fds(s);
1070 static void socket_unwatch_fds(Socket *s) {
1075 LIST_FOREACH(port, p, s->ports) {
1079 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1083 static int socket_watch_fds(Socket *s) {
1089 LIST_FOREACH(port, p, s->ports) {
1093 p->fd_watch.socket_accept =
1095 p->type == SOCKET_SOCKET &&
1096 socket_address_can_accept(&p->address);
1098 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1105 socket_unwatch_fds(s);
1109 static void socket_set_state(Socket *s, SocketState state) {
1110 SocketState old_state;
1113 old_state = s->state;
1116 if (state != SOCKET_START_PRE &&
1117 state != SOCKET_START_POST &&
1118 state != SOCKET_STOP_PRE &&
1119 state != SOCKET_STOP_PRE_SIGTERM &&
1120 state != SOCKET_STOP_PRE_SIGKILL &&
1121 state != SOCKET_STOP_POST &&
1122 state != SOCKET_FINAL_SIGTERM &&
1123 state != SOCKET_FINAL_SIGKILL) {
1124 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1125 socket_unwatch_control_pid(s);
1126 s->control_command = NULL;
1127 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1130 if (state != SOCKET_LISTENING)
1131 socket_unwatch_fds(s);
1133 if (state != SOCKET_START_POST &&
1134 state != SOCKET_LISTENING &&
1135 state != SOCKET_RUNNING &&
1136 state != SOCKET_STOP_PRE &&
1137 state != SOCKET_STOP_PRE_SIGTERM &&
1138 state != SOCKET_STOP_PRE_SIGKILL)
1139 socket_close_fds(s);
1141 if (state != old_state)
1142 log_debug_unit(UNIT(s)->id,
1143 "%s changed %s -> %s", UNIT(s)->id,
1144 socket_state_to_string(old_state),
1145 socket_state_to_string(state));
1147 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1150 static int socket_coldplug(Unit *u) {
1151 Socket *s = SOCKET(u);
1155 assert(s->state == SOCKET_DEAD);
1157 if (s->deserialized_state != s->state) {
1159 if (s->deserialized_state == SOCKET_START_PRE ||
1160 s->deserialized_state == SOCKET_START_POST ||
1161 s->deserialized_state == SOCKET_STOP_PRE ||
1162 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1163 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1164 s->deserialized_state == SOCKET_STOP_POST ||
1165 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1166 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1168 if (s->control_pid <= 0)
1171 r = unit_watch_pid(UNIT(s), s->control_pid);
1175 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1180 if (s->deserialized_state == SOCKET_START_POST ||
1181 s->deserialized_state == SOCKET_LISTENING ||
1182 s->deserialized_state == SOCKET_RUNNING ||
1183 s->deserialized_state == SOCKET_STOP_PRE ||
1184 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1185 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1186 if ((r = socket_open_fds(s)) < 0)
1189 if (s->deserialized_state == SOCKET_LISTENING)
1190 if ((r = socket_watch_fds(s)) < 0)
1193 socket_set_state(s, s->deserialized_state);
1199 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1208 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1212 argv = unit_full_printf_strv(UNIT(s), c->argv);
1222 UNIT(s)->manager->environment,
1226 UNIT(s)->manager->confirm_spawn,
1227 UNIT(s)->cgroup_bondings,
1228 UNIT(s)->cgroup_attributes,
1238 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1239 /* FIXME: we need to do something here */
1247 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1252 static void socket_enter_dead(Socket *s, SocketResult f) {
1255 if (f != SOCKET_SUCCESS)
1258 exec_context_tmp_dirs_done(&s->exec_context);
1259 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1262 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1264 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1268 if (f != SOCKET_SUCCESS)
1271 socket_unwatch_control_pid(s);
1273 s->control_command_id = SOCKET_EXEC_STOP_POST;
1275 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1276 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1279 socket_set_state(s, SOCKET_STOP_POST);
1281 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1286 log_warning_unit(UNIT(s)->id,
1287 "%s failed to run 'stop-post' task: %s",
1288 UNIT(s)->id, strerror(-r));
1289 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1292 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1297 if (f != SOCKET_SUCCESS)
1300 r = unit_kill_context(
1303 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1311 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1315 socket_set_state(s, state);
1316 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1317 socket_enter_stop_post(s, SOCKET_SUCCESS);
1319 socket_enter_dead(s, SOCKET_SUCCESS);
1324 log_warning_unit(UNIT(s)->id,
1325 "%s failed to kill processes: %s",
1326 UNIT(s)->id, strerror(-r));
1328 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1329 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1331 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1334 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1338 if (f != SOCKET_SUCCESS)
1341 socket_unwatch_control_pid(s);
1343 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1345 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1346 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1349 socket_set_state(s, SOCKET_STOP_PRE);
1351 socket_enter_stop_post(s, SOCKET_SUCCESS);
1356 log_warning_unit(UNIT(s)->id,
1357 "%s failed to run 'stop-pre' task: %s",
1358 UNIT(s)->id, strerror(-r));
1359 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1362 static void socket_enter_listening(Socket *s) {
1366 r = socket_watch_fds(s);
1368 log_warning_unit(UNIT(s)->id,
1369 "%s failed to watch sockets: %s",
1370 UNIT(s)->id, strerror(-r));
1374 socket_set_state(s, SOCKET_LISTENING);
1378 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1381 static void socket_enter_start_post(Socket *s) {
1385 r = socket_open_fds(s);
1387 log_warning_unit(UNIT(s)->id,
1388 "%s failed to listen on sockets: %s",
1389 UNIT(s)->id, strerror(-r));
1393 socket_unwatch_control_pid(s);
1395 s->control_command_id = SOCKET_EXEC_START_POST;
1397 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1398 r = socket_spawn(s, s->control_command, &s->control_pid);
1400 log_warning_unit(UNIT(s)->id,
1401 "%s failed to run 'start-post' task: %s",
1402 UNIT(s)->id, strerror(-r));
1406 socket_set_state(s, SOCKET_START_POST);
1408 socket_enter_listening(s);
1413 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1416 static void socket_enter_start_pre(Socket *s) {
1420 socket_unwatch_control_pid(s);
1422 s->control_command_id = SOCKET_EXEC_START_PRE;
1424 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1425 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1428 socket_set_state(s, SOCKET_START_PRE);
1430 socket_enter_start_post(s);
1435 log_warning_unit(UNIT(s)->id,
1436 "%s failed to run 'start-pre' task: %s",
1437 UNIT(s)->id, strerror(-r));
1438 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1441 static void socket_enter_running(Socket *s, int cfd) {
1446 dbus_error_init(&error);
1448 /* We don't take connections anymore if we are supposed to
1449 * shut down anyway */
1450 if (unit_pending_inactive(UNIT(s))) {
1451 log_debug_unit(UNIT(s)->id,
1452 "Suppressing connection request on %s since unit stop is scheduled.",
1456 close_nointr_nofail(cfd);
1458 /* Flush all sockets by closing and reopening them */
1459 socket_close_fds(s);
1461 r = socket_watch_fds(s);
1463 log_warning_unit(UNIT(s)->id,
1464 "%s failed to watch sockets: %s",
1465 UNIT(s)->id, strerror(-r));
1466 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1476 bool pending = false;
1478 /* If there's already a start pending don't bother to
1480 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1481 if (unit_pending_active(u)) {
1487 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1492 socket_set_state(s, SOCKET_RUNNING);
1494 char *prefix, *instance = NULL, *name;
1497 if (s->n_connections >= s->max_connections) {
1498 log_warning_unit(UNIT(s)->id,
1499 "%s: Too many incoming connections (%u)",
1500 UNIT(s)->id, s->n_connections);
1501 close_nointr_nofail(cfd);
1505 r = socket_instantiate_service(s);
1509 r = instance_from_socket(cfd, s->n_accepted, &instance);
1514 /* ENOTCONN is legitimate if TCP RST was received.
1515 * This connection is over, but the socket unit lives on. */
1516 close_nointr_nofail(cfd);
1520 prefix = unit_name_to_prefix(UNIT(s)->id);
1527 name = unit_name_build(prefix, instance, ".service");
1536 r = unit_add_name(UNIT_DEREF(s->service), name);
1542 service = SERVICE(UNIT_DEREF(s->service));
1543 unit_ref_unset(&s->service);
1546 UNIT(service)->no_gc = false;
1548 unit_choose_id(UNIT(service), name);
1551 r = service_set_socket_fd(service, cfd, s);
1556 s->n_connections ++;
1558 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1562 /* Notify clients about changed counters */
1563 unit_add_to_dbus_queue(UNIT(s));
1569 log_warning_unit(UNIT(s)->id,
1570 "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1572 cfd >= 0 ? "template" : "non-template",
1573 bus_error(&error, r));
1574 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1577 close_nointr_nofail(cfd);
1579 dbus_error_free(&error);
1582 static void socket_run_next(Socket *s) {
1586 assert(s->control_command);
1587 assert(s->control_command->command_next);
1589 socket_unwatch_control_pid(s);
1591 s->control_command = s->control_command->command_next;
1593 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1599 log_warning_unit(UNIT(s)->id,
1600 "%s failed to run next task: %s",
1601 UNIT(s)->id, strerror(-r));
1603 if (s->state == SOCKET_START_POST)
1604 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1605 else if (s->state == SOCKET_STOP_POST)
1606 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1608 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1611 static int socket_start(Unit *u) {
1612 Socket *s = SOCKET(u);
1616 /* We cannot fulfill this request right now, try again later
1618 if (s->state == SOCKET_STOP_PRE ||
1619 s->state == SOCKET_STOP_PRE_SIGKILL ||
1620 s->state == SOCKET_STOP_PRE_SIGTERM ||
1621 s->state == SOCKET_STOP_POST ||
1622 s->state == SOCKET_FINAL_SIGTERM ||
1623 s->state == SOCKET_FINAL_SIGKILL)
1626 if (s->state == SOCKET_START_PRE ||
1627 s->state == SOCKET_START_POST)
1630 /* Cannot run this without the service being around */
1631 if (UNIT_DEREF(s->service)) {
1634 service = SERVICE(UNIT_DEREF(s->service));
1636 if (UNIT(service)->load_state != UNIT_LOADED) {
1637 log_error_unit(u->id,
1638 "Socket service %s not loaded, refusing.",
1643 /* If the service is already active we cannot start the
1645 if (service->state != SERVICE_DEAD &&
1646 service->state != SERVICE_FAILED &&
1647 service->state != SERVICE_AUTO_RESTART) {
1648 log_error_unit(u->id,
1649 "Socket service %s already active, refusing.",
1654 #ifdef HAVE_SYSV_COMPAT
1655 if (service->is_sysv) {
1656 log_error_unit(u->id,
1657 "Using SysV services for socket activation is not supported. Refusing.");
1663 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1665 s->result = SOCKET_SUCCESS;
1666 socket_enter_start_pre(s);
1670 static int socket_stop(Unit *u) {
1671 Socket *s = SOCKET(u);
1676 if (s->state == SOCKET_STOP_PRE ||
1677 s->state == SOCKET_STOP_PRE_SIGTERM ||
1678 s->state == SOCKET_STOP_PRE_SIGKILL ||
1679 s->state == SOCKET_STOP_POST ||
1680 s->state == SOCKET_FINAL_SIGTERM ||
1681 s->state == SOCKET_FINAL_SIGKILL)
1684 /* If there's already something running we go directly into
1686 if (s->state == SOCKET_START_PRE ||
1687 s->state == SOCKET_START_POST) {
1688 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1692 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1694 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1698 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1699 Socket *s = SOCKET(u);
1707 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1708 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1709 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1711 if (s->control_pid > 0)
1712 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1714 if (s->control_command_id >= 0)
1715 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1717 LIST_FOREACH(port, p, s->ports) {
1723 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1726 if (p->type == SOCKET_SOCKET) {
1729 r = socket_address_print(&p->address, &t);
1733 if (socket_address_family(&p->address) == AF_NETLINK)
1734 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1736 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1738 } else if (p->type == SOCKET_SPECIAL)
1739 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1740 else if (p->type == SOCKET_MQUEUE)
1741 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1743 assert(p->type == SOCKET_FIFO);
1744 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1748 exec_context_serialize(&s->exec_context, UNIT(s), f);
1753 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1754 Socket *s = SOCKET(u);
1761 if (streq(key, "state")) {
1764 state = socket_state_from_string(value);
1766 log_debug_unit(u->id,
1767 "Failed to parse state value %s", value);
1769 s->deserialized_state = state;
1770 } else if (streq(key, "result")) {
1773 f = socket_result_from_string(value);
1775 log_debug_unit(u->id,
1776 "Failed to parse result value %s", value);
1777 else if (f != SOCKET_SUCCESS)
1780 } else if (streq(key, "n-accepted")) {
1783 if (safe_atou(value, &k) < 0)
1784 log_debug_unit(u->id,
1785 "Failed to parse n-accepted value %s", value);
1788 } else if (streq(key, "control-pid")) {
1791 if (parse_pid(value, &pid) < 0)
1792 log_debug_unit(u->id,
1793 "Failed to parse control-pid value %s", value);
1795 s->control_pid = pid;
1796 } else if (streq(key, "control-command")) {
1797 SocketExecCommand id;
1799 id = socket_exec_command_from_string(value);
1801 log_debug_unit(u->id,
1802 "Failed to parse exec-command value %s", value);
1804 s->control_command_id = id;
1805 s->control_command = s->exec_command[id];
1807 } else if (streq(key, "fifo")) {
1811 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1812 log_debug_unit(u->id,
1813 "Failed to parse fifo value %s", value);
1816 LIST_FOREACH(port, p, s->ports)
1817 if (p->type == SOCKET_FIFO &&
1818 streq_ptr(p->path, value+skip))
1823 close_nointr_nofail(p->fd);
1824 p->fd = fdset_remove(fds, fd);
1828 } else if (streq(key, "special")) {
1832 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1833 log_debug_unit(u->id,
1834 "Failed to parse special value %s", value);
1837 LIST_FOREACH(port, p, s->ports)
1838 if (p->type == SOCKET_SPECIAL &&
1839 streq_ptr(p->path, value+skip))
1844 close_nointr_nofail(p->fd);
1845 p->fd = fdset_remove(fds, fd);
1849 } else if (streq(key, "mqueue")) {
1853 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1854 log_debug_unit(u->id,
1855 "Failed to parse mqueue value %s", value);
1858 LIST_FOREACH(port, p, s->ports)
1859 if (p->type == SOCKET_MQUEUE &&
1860 streq_ptr(p->path, value+skip))
1865 close_nointr_nofail(p->fd);
1866 p->fd = fdset_remove(fds, fd);
1870 } else if (streq(key, "socket")) {
1871 int fd, type, skip = 0;
1874 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1875 log_debug_unit(u->id,
1876 "Failed to parse socket value %s", value);
1879 LIST_FOREACH(port, p, s->ports)
1880 if (socket_address_is(&p->address, value+skip, type))
1885 close_nointr_nofail(p->fd);
1886 p->fd = fdset_remove(fds, fd);
1890 } else if (streq(key, "netlink")) {
1894 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1895 log_debug_unit(u->id,
1896 "Failed to parse socket value %s", value);
1899 LIST_FOREACH(port, p, s->ports)
1900 if (socket_address_is_netlink(&p->address, value+skip))
1905 close_nointr_nofail(p->fd);
1906 p->fd = fdset_remove(fds, fd);
1909 } else if (streq(key, "tmp-dir")) {
1916 s->exec_context.tmp_dir = t;
1917 } else if (streq(key, "var-tmp-dir")) {
1924 s->exec_context.var_tmp_dir = t;
1926 log_debug_unit(UNIT(s)->id,
1927 "Unknown serialization key '%s'", key);
1932 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1933 Socket *s = SOCKET(u);
1938 LIST_FOREACH(port, p, s->ports) {
1942 if (p->type != SOCKET_SOCKET)
1948 FDSET_FOREACH(fd, fds, i) {
1949 if (socket_address_matches_fd(&p->address, fd)) {
1950 p->fd = fdset_remove(fds, fd);
1951 s->deserialized_state = SOCKET_LISTENING;
1960 static UnitActiveState socket_active_state(Unit *u) {
1963 return state_translation_table[SOCKET(u)->state];
1966 static const char *socket_sub_state_to_string(Unit *u) {
1969 return socket_state_to_string(SOCKET(u)->state);
1972 const char* socket_port_type_to_string(SocketPort *p) {
1978 switch (p->address.type) {
1979 case SOCK_STREAM: return "Stream";
1980 case SOCK_DGRAM: return "Datagram";
1981 case SOCK_SEQPACKET: return "SequentialPacket";
1983 if (socket_address_family(&p->address) == AF_NETLINK)
1985 default: return "Invalid";
1987 case SOCKET_SPECIAL: return "Special";
1988 case SOCKET_MQUEUE: return "MessageQueue";
1989 case SOCKET_FIFO: return "FIFO";
1990 default: return NULL;
1994 static bool socket_check_gc(Unit *u) {
1995 Socket *s = SOCKET(u);
1999 return s->n_connections > 0;
2002 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2003 Socket *s = SOCKET(u);
2009 if (s->state != SOCKET_LISTENING)
2012 log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2014 if (events != EPOLLIN) {
2016 if (events & EPOLLHUP)
2017 log_error_unit(u->id,
2018 "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2021 log_error_unit(u->id,
2022 "%s: Got unexpected poll event (0x%x) on socket.",
2028 if (w->socket_accept) {
2031 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2037 log_error_unit(u->id,
2038 "Failed to accept socket: %m");
2045 socket_apply_socket_options(s, cfd);
2048 socket_enter_running(s, cfd);
2052 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2055 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2056 Socket *s = SOCKET(u);
2062 if (pid != s->control_pid)
2067 if (is_clean_exit(code, status, NULL))
2069 else if (code == CLD_EXITED)
2070 f = SOCKET_FAILURE_EXIT_CODE;
2071 else if (code == CLD_KILLED)
2072 f = SOCKET_FAILURE_SIGNAL;
2073 else if (code == CLD_DUMPED)
2074 f = SOCKET_FAILURE_CORE_DUMP;
2076 assert_not_reached("Unknown code");
2078 if (s->control_command) {
2079 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2081 if (s->control_command->ignore)
2085 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2087 "%s control process exited, code=%s status=%i",
2088 u->id, sigchld_code_to_string(code), status);
2090 if (f != SOCKET_SUCCESS)
2093 if (s->control_command &&
2094 s->control_command->command_next &&
2095 f == SOCKET_SUCCESS) {
2097 log_debug_unit(u->id,
2098 "%s running next command for state %s",
2099 u->id, socket_state_to_string(s->state));
2102 s->control_command = NULL;
2103 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2105 /* No further commands for this step, so let's figure
2106 * out what to do next */
2108 log_debug_unit(u->id,
2109 "%s got final SIGCHLD for state %s",
2110 u->id, socket_state_to_string(s->state));
2114 case SOCKET_START_PRE:
2115 if (f == SOCKET_SUCCESS)
2116 socket_enter_start_post(s);
2118 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2121 case SOCKET_START_POST:
2122 if (f == SOCKET_SUCCESS)
2123 socket_enter_listening(s);
2125 socket_enter_stop_pre(s, f);
2128 case SOCKET_STOP_PRE:
2129 case SOCKET_STOP_PRE_SIGTERM:
2130 case SOCKET_STOP_PRE_SIGKILL:
2131 socket_enter_stop_post(s, f);
2134 case SOCKET_STOP_POST:
2135 case SOCKET_FINAL_SIGTERM:
2136 case SOCKET_FINAL_SIGKILL:
2137 socket_enter_dead(s, f);
2141 assert_not_reached("Uh, control process died at wrong time.");
2145 /* Notify clients about changed exit status */
2146 unit_add_to_dbus_queue(u);
2149 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2150 Socket *s = SOCKET(u);
2153 assert(elapsed == 1);
2154 assert(w == &s->timer_watch);
2158 case SOCKET_START_PRE:
2159 log_warning_unit(u->id,
2160 "%s starting timed out. Terminating.", u->id);
2161 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2164 case SOCKET_START_POST:
2165 log_warning_unit(u->id,
2166 "%s starting timed out. Stopping.", u->id);
2167 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2170 case SOCKET_STOP_PRE:
2171 log_warning_unit(u->id,
2172 "%s stopping timed out. Terminating.", u->id);
2173 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2176 case SOCKET_STOP_PRE_SIGTERM:
2177 if (s->kill_context.send_sigkill) {
2178 log_warning_unit(u->id,
2179 "%s stopping timed out. Killing.", u->id);
2180 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2182 log_warning_unit(u->id,
2183 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2185 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2189 case SOCKET_STOP_PRE_SIGKILL:
2190 log_warning_unit(u->id,
2191 "%s still around after SIGKILL. Ignoring.", u->id);
2192 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2195 case SOCKET_STOP_POST:
2196 log_warning_unit(u->id,
2197 "%s stopping timed out (2). Terminating.", u->id);
2198 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2201 case SOCKET_FINAL_SIGTERM:
2202 if (s->kill_context.send_sigkill) {
2203 log_warning_unit(u->id,
2204 "%s stopping timed out (2). Killing.", u->id);
2205 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2207 log_warning_unit(u->id,
2208 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2210 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2214 case SOCKET_FINAL_SIGKILL:
2215 log_warning_unit(u->id,
2216 "%s still around after SIGKILL (2). Entering failed mode.",
2218 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2222 assert_not_reached("Timeout at wrong time.");
2226 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2235 /* Called from the service code for requesting our fds */
2238 LIST_FOREACH(port, p, s->ports)
2248 if (!(rfds = new(int, rn_fds)))
2252 LIST_FOREACH(port, p, s->ports)
2256 assert(k == rn_fds);
2264 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2267 /* The service is dead. Dang!
2269 * This is strictly for one-instance-for-all-connections
2272 if (s->state == SOCKET_RUNNING) {
2273 log_debug_unit(UNIT(s)->id,
2274 "%s got notified about service death (failed permanently: %s)",
2275 UNIT(s)->id, yes_no(failed_permanent));
2276 if (failed_permanent)
2277 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2279 socket_enter_listening(s);
2283 void socket_connection_unref(Socket *s) {
2286 /* The service is dead. Yay!
2288 * This is strictly for one-instance-per-connection
2291 assert(s->n_connections > 0);
2294 log_debug_unit(UNIT(s)->id,
2295 "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2298 static void socket_reset_failed(Unit *u) {
2299 Socket *s = SOCKET(u);
2303 if (s->state == SOCKET_FAILED)
2304 socket_set_state(s, SOCKET_DEAD);
2306 s->result = SOCKET_SUCCESS;
2309 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2310 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2313 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2314 [SOCKET_DEAD] = "dead",
2315 [SOCKET_START_PRE] = "start-pre",
2316 [SOCKET_START_POST] = "start-post",
2317 [SOCKET_LISTENING] = "listening",
2318 [SOCKET_RUNNING] = "running",
2319 [SOCKET_STOP_PRE] = "stop-pre",
2320 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2321 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2322 [SOCKET_STOP_POST] = "stop-post",
2323 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2324 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2325 [SOCKET_FAILED] = "failed"
2328 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2330 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2331 [SOCKET_EXEC_START_PRE] = "StartPre",
2332 [SOCKET_EXEC_START_POST] = "StartPost",
2333 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2334 [SOCKET_EXEC_STOP_POST] = "StopPost"
2337 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2339 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2340 [SOCKET_SUCCESS] = "success",
2341 [SOCKET_FAILURE_RESOURCES] = "resources",
2342 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2343 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2344 [SOCKET_FAILURE_SIGNAL] = "signal",
2345 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2346 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2349 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2351 const UnitVTable socket_vtable = {
2352 .object_size = sizeof(Socket),
2359 .exec_context_offset = offsetof(Socket, exec_context),
2360 .exec_section = "Socket",
2362 .init = socket_init,
2363 .done = socket_done,
2364 .load = socket_load,
2366 .kill = socket_kill,
2368 .coldplug = socket_coldplug,
2370 .dump = socket_dump,
2372 .start = socket_start,
2373 .stop = socket_stop,
2375 .serialize = socket_serialize,
2376 .deserialize_item = socket_deserialize_item,
2377 .distribute_fds = socket_distribute_fds,
2379 .active_state = socket_active_state,
2380 .sub_state_to_string = socket_sub_state_to_string,
2382 .check_gc = socket_check_gc,
2384 .fd_event = socket_fd_event,
2385 .sigchld_event = socket_sigchld_event,
2386 .timer_event = socket_timer_event,
2388 .reset_failed = socket_reset_failed,
2390 .bus_interface = "org.freedesktop.systemd1.Socket",
2391 .bus_message_handler = bus_socket_message_handler,
2392 .bus_invalidating_properties = bus_socket_invalidating_properties,
2394 .status_message_formats = {
2395 /*.starting_stopping = {
2396 [0] = "Starting socket %s...",
2397 [1] = "Stopping socket %s...",
2399 .finished_start_job = {
2400 [JOB_DONE] = "Listening on %s.",
2401 [JOB_FAILED] = "Failed to listen on %s.",
2402 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2403 [JOB_TIMEOUT] = "Timed out starting %s.",
2405 .finished_stop_job = {
2406 [JOB_DONE] = "Closed %s.",
2407 [JOB_FAILED] = "Failed stopping %s.",
2408 [JOB_TIMEOUT] = "Timed out stopping %s.",