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>
34 #include "netinet/tcp.h"
36 #include "load-dropin.h"
37 #include "load-fragment.h"
40 #include "path-util.h"
41 #include "unit-name.h"
42 #include "unit-printf.h"
43 #include "dbus-socket.h"
46 #include "bus-errors.h"
48 #include "exit-status.h"
51 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
52 [SOCKET_DEAD] = UNIT_INACTIVE,
53 [SOCKET_START_PRE] = UNIT_ACTIVATING,
54 [SOCKET_START_POST] = UNIT_ACTIVATING,
55 [SOCKET_LISTENING] = UNIT_ACTIVE,
56 [SOCKET_RUNNING] = UNIT_ACTIVE,
57 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
58 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
59 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
60 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
61 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
62 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
63 [SOCKET_FAILED] = UNIT_FAILED
66 static void socket_init(Unit *u) {
67 Socket *s = SOCKET(u);
70 assert(u->load_state == UNIT_STUB);
72 s->backlog = SOMAXCONN;
73 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
74 s->directory_mode = 0755;
75 s->socket_mode = 0666;
77 s->max_connections = 64;
84 exec_context_init(&s->exec_context);
85 s->exec_context.std_output = u->manager->default_std_output;
86 s->exec_context.std_error = u->manager->default_std_error;
87 kill_context_init(&s->kill_context);
89 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
92 static void socket_unwatch_control_pid(Socket *s) {
95 if (s->control_pid <= 0)
98 unit_unwatch_pid(UNIT(s), s->control_pid);
102 static void socket_done(Unit *u) {
103 Socket *s = SOCKET(u);
108 while ((p = s->ports)) {
109 LIST_REMOVE(SocketPort, port, s->ports, p);
112 unit_unwatch_fd(UNIT(s), &p->fd_watch);
113 close_nointr_nofail(p->fd);
120 exec_context_done(&s->exec_context);
121 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
122 s->control_command = NULL;
124 socket_unwatch_control_pid(s);
126 unit_ref_unset(&s->service);
128 free(s->tcp_congestion);
129 s->tcp_congestion = NULL;
131 free(s->bind_to_device);
132 s->bind_to_device = NULL;
134 unit_unwatch_timer(u, &s->timer_watch);
137 static int socket_instantiate_service(Socket *s) {
144 /* This fills in s->service if it isn't filled in yet. For
145 * Accept=yes sockets we create the next connection service
146 * here. For Accept=no this is mostly a NOP since the service
147 * is figured out at load time anyway. */
149 if (UNIT_DEREF(s->service))
154 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
157 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
163 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
169 #ifdef HAVE_SYSV_COMPAT
170 if (SERVICE(u)->is_sysv) {
171 log_error("Using SysV services for socket activation is not supported. Refusing.");
177 unit_ref_set(&s->service, u);
179 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
182 static bool have_non_accept_socket(Socket *s) {
190 LIST_FOREACH(port, p, s->ports) {
192 if (p->type != SOCKET_SOCKET)
195 if (!socket_address_can_accept(&p->address))
202 static int socket_verify(Socket *s) {
205 if (UNIT(s)->load_state != UNIT_LOADED)
209 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
213 if (s->accept && have_non_accept_socket(s)) {
214 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
218 if (s->accept && s->max_connections <= 0) {
219 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
223 if (s->accept && UNIT_DEREF(s->service)) {
224 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
228 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
229 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
236 static bool socket_needs_mount(Socket *s, const char *prefix) {
241 LIST_FOREACH(port, p, s->ports) {
243 if (p->type == SOCKET_SOCKET) {
244 if (socket_address_needs_mount(&p->address, prefix))
246 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
247 if (path_startswith(p->path, prefix))
255 int socket_add_one_mount_link(Socket *s, Mount *m) {
261 if (UNIT(s)->load_state != UNIT_LOADED ||
262 UNIT(m)->load_state != UNIT_LOADED)
265 if (!socket_needs_mount(s, m->where))
268 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
275 static int socket_add_mount_links(Socket *s) {
281 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
282 r = socket_add_one_mount_link(s, MOUNT(other));
290 static int socket_add_device_link(Socket *s) {
296 if (!s->bind_to_device)
299 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
302 r = unit_add_node_link(UNIT(s), t, false);
308 static int socket_add_default_dependencies(Socket *s) {
312 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
313 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
316 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
320 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
323 static bool socket_has_exec(Socket *s) {
327 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
328 if (s->exec_command[i])
334 static int socket_load(Unit *u) {
335 Socket *s = SOCKET(u);
339 assert(u->load_state == UNIT_STUB);
341 if ((r = unit_load_fragment_and_dropin(u)) < 0)
344 /* This is a new unit? Then let's add in some extras */
345 if (u->load_state == UNIT_LOADED) {
347 if (have_non_accept_socket(s)) {
349 if (!UNIT_DEREF(s->service)) {
352 r = unit_load_related_unit(u, ".service", &x);
356 unit_ref_set(&s->service, x);
359 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
364 if ((r = socket_add_mount_links(s)) < 0)
367 if ((r = socket_add_device_link(s)) < 0)
370 if (socket_has_exec(s))
371 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
374 if ((r = unit_add_default_cgroups(u)) < 0)
377 if (UNIT(s)->default_dependencies)
378 if ((r = socket_add_default_dependencies(s)) < 0)
381 r = unit_exec_context_defaults(u, &s->exec_context);
386 return socket_verify(s);
389 static const char* listen_lookup(int family, int type) {
391 if (family == AF_NETLINK)
392 return "ListenNetlink";
394 if (type == SOCK_STREAM)
395 return "ListenStream";
396 else if (type == SOCK_DGRAM)
397 return "ListenDatagram";
398 else if (type == SOCK_SEQPACKET)
399 return "ListenSequentialPacket";
401 assert_not_reached("Unknown socket type");
405 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
408 Socket *s = SOCKET(u);
416 p2 = strappend(prefix, "\t");
417 prefix2 = p2 ? p2 : prefix;
420 "%sSocket State: %s\n"
422 "%sBindIPv6Only: %s\n"
424 "%sSocketMode: %04o\n"
425 "%sDirectoryMode: %04o\n"
428 "%sTransparent: %s\n"
430 "%sPassCredentials: %s\n"
431 "%sPassSecurity: %s\n"
432 "%sTCPCongestion: %s\n",
433 prefix, socket_state_to_string(s->state),
434 prefix, socket_result_to_string(s->result),
435 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
437 prefix, s->socket_mode,
438 prefix, s->directory_mode,
439 prefix, yes_no(s->keep_alive),
440 prefix, yes_no(s->free_bind),
441 prefix, yes_no(s->transparent),
442 prefix, yes_no(s->broadcast),
443 prefix, yes_no(s->pass_cred),
444 prefix, yes_no(s->pass_sec),
445 prefix, strna(s->tcp_congestion));
447 if (s->control_pid > 0)
449 "%sControl PID: %lu\n",
450 prefix, (unsigned long) s->control_pid);
452 if (s->bind_to_device)
454 "%sBindToDevice: %s\n",
455 prefix, s->bind_to_device);
460 "%sNConnections: %u\n"
461 "%sMaxConnections: %u\n",
462 prefix, s->n_accepted,
463 prefix, s->n_connections,
464 prefix, s->max_connections);
466 if (s->priority >= 0)
469 prefix, s->priority);
471 if (s->receive_buffer > 0)
473 "%sReceiveBuffer: %zu\n",
474 prefix, s->receive_buffer);
476 if (s->send_buffer > 0)
478 "%sSendBuffer: %zu\n",
479 prefix, s->send_buffer);
491 if (s->pipe_size > 0)
494 prefix, s->pipe_size);
501 if (s->mq_maxmsg > 0)
503 "%sMessageQueueMaxMessages: %li\n",
504 prefix, s->mq_maxmsg);
506 if (s->mq_msgsize > 0)
508 "%sMessageQueueMessageSize: %li\n",
509 prefix, s->mq_msgsize);
511 LIST_FOREACH(port, p, s->ports) {
513 if (p->type == SOCKET_SOCKET) {
518 if ((r = socket_address_print(&p->address, &k)) < 0)
523 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
525 } else if (p->type == SOCKET_SPECIAL)
526 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
527 else if (p->type == SOCKET_MQUEUE)
528 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
530 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
533 exec_context_dump(&s->exec_context, f, prefix);
534 kill_context_dump(&s->kill_context, f, prefix);
536 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
537 if (!s->exec_command[c])
540 fprintf(f, "%s-> %s:\n",
541 prefix, socket_exec_command_to_string(c));
543 exec_command_dump_list(s->exec_command[c], f, prefix2);
549 static int instance_from_socket(int fd, unsigned nr, char **instance) {
554 struct sockaddr_un un;
555 struct sockaddr_in in;
556 struct sockaddr_in6 in6;
557 struct sockaddr_storage storage;
564 if (getsockname(fd, &local.sa, &l) < 0)
568 if (getpeername(fd, &remote.sa, &l) < 0)
571 switch (local.sa.sa_family) {
575 a = ntohl(local.in.sin_addr.s_addr),
576 b = ntohl(remote.in.sin_addr.s_addr);
579 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
581 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
582 ntohs(local.in.sin_port),
583 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
584 ntohs(remote.in.sin_port)) < 0)
591 static const unsigned char ipv4_prefix[] = {
592 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
595 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
596 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
598 *a = local.in6.sin6_addr.s6_addr+12,
599 *b = remote.in6.sin6_addr.s6_addr+12;
602 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
604 a[0], a[1], a[2], a[3],
605 ntohs(local.in6.sin6_port),
606 b[0], b[1], b[2], b[3],
607 ntohs(remote.in6.sin6_port)) < 0)
610 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
615 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
616 ntohs(local.in6.sin6_port),
617 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
618 ntohs(remote.in6.sin6_port)) < 0)
629 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
635 (unsigned long) ucred.pid,
636 (unsigned long) ucred.uid) < 0)
643 assert_not_reached("Unhandled socket type.");
650 static void socket_close_fds(Socket *s) {
655 LIST_FOREACH(port, p, s->ports) {
659 unit_unwatch_fd(UNIT(s), &p->fd_watch);
660 close_nointr_nofail(p->fd);
662 /* One little note: we should never delete any sockets
663 * in the file system here! After all some other
664 * process we spawned might still have a reference of
665 * this fd and wants to continue to use it. Therefore
666 * we delete sockets in the file system before we
667 * create a new one, not after we stopped using
674 static void socket_apply_socket_options(Socket *s, int fd) {
679 int b = s->keep_alive;
680 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
681 log_warning("SO_KEEPALIVE failed: %m");
686 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
687 log_warning("SO_BROADCAST failed: %m");
692 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
693 log_warning("SO_PASSCRED failed: %m");
698 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
699 log_warning("SO_PASSSEC failed: %m");
702 if (s->priority >= 0)
703 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
704 log_warning("SO_PRIORITY failed: %m");
706 if (s->receive_buffer > 0) {
707 int value = (int) s->receive_buffer;
709 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
711 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
712 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
713 log_warning("SO_RCVBUF failed: %m");
716 if (s->send_buffer > 0) {
717 int value = (int) s->send_buffer;
718 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
719 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
720 log_warning("SO_SNDBUF failed: %m");
724 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
725 log_warning("SO_MARK failed: %m");
728 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
729 log_warning("IP_TOS failed: %m");
731 if (s->ip_ttl >= 0) {
734 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
736 if (socket_ipv6_is_supported())
737 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
740 errno = EAFNOSUPPORT;
744 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
747 if (s->tcp_congestion)
748 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
749 log_warning("TCP_CONGESTION failed: %m");
752 static void socket_apply_fifo_options(Socket *s, int fd) {
756 if (s->pipe_size > 0)
757 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
758 log_warning("F_SETPIPE_SZ: %m");
761 static int fifo_address_create(
763 mode_t directory_mode,
774 mkdir_parents_label(path, directory_mode);
776 r = label_context_set(path, S_IFIFO);
780 /* Enforce the right access mode for the fifo */
781 old_mask = umask(~ socket_mode);
783 /* Include the original umask in our mask */
784 umask(~socket_mode | old_mask);
786 r = mkfifo(path, socket_mode);
789 if (r < 0 && errno != EEXIST) {
794 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
799 label_context_clear();
801 if (fstat(fd, &st) < 0) {
806 if (!S_ISFIFO(st.st_mode) ||
807 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
808 st.st_uid != getuid() ||
809 st.st_gid != getgid()) {
819 label_context_clear();
822 close_nointr_nofail(fd);
827 static int special_address_create(
837 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
842 if (fstat(fd, &st) < 0) {
847 /* Check whether this is a /proc, /sys or /dev file or char device */
848 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
858 close_nointr_nofail(fd);
863 static int mq_address_create(
873 struct mq_attr _attr, *attr = NULL;
878 if (maxmsg > 0 && msgsize > 0) {
880 _attr.mq_flags = O_NONBLOCK;
881 _attr.mq_maxmsg = maxmsg;
882 _attr.mq_msgsize = msgsize;
886 /* Enforce the right access mode for the mq */
887 old_mask = umask(~ mq_mode);
889 /* Include the original umask in our mask */
890 umask(~mq_mode | old_mask);
892 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
900 if (fstat(fd, &st) < 0) {
905 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
906 st.st_uid != getuid() ||
907 st.st_gid != getgid()) {
918 close_nointr_nofail(fd);
923 static int socket_open_fds(Socket *s) {
927 bool know_label = false;
931 LIST_FOREACH(port, p, s->ports) {
936 if (p->type == SOCKET_SOCKET) {
940 if ((r = socket_instantiate_service(s)) < 0)
943 if (UNIT_DEREF(s->service) &&
944 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
945 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
956 if ((r = socket_address_listen(
969 socket_apply_socket_options(s, p->fd);
971 } else if (p->type == SOCKET_SPECIAL) {
973 if ((r = special_address_create(
978 } else if (p->type == SOCKET_FIFO) {
980 if ((r = fifo_address_create(
987 socket_apply_fifo_options(s, p->fd);
988 } else if (p->type == SOCKET_MQUEUE) {
990 if ((r = mq_address_create(
998 assert_not_reached("Unknown port type");
1005 socket_close_fds(s);
1010 static void socket_unwatch_fds(Socket *s) {
1015 LIST_FOREACH(port, p, s->ports) {
1019 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1023 static int socket_watch_fds(Socket *s) {
1029 LIST_FOREACH(port, p, s->ports) {
1033 p->fd_watch.socket_accept =
1035 p->type == SOCKET_SOCKET &&
1036 socket_address_can_accept(&p->address);
1038 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1045 socket_unwatch_fds(s);
1049 static void socket_set_state(Socket *s, SocketState state) {
1050 SocketState old_state;
1053 old_state = s->state;
1056 if (state != SOCKET_START_PRE &&
1057 state != SOCKET_START_POST &&
1058 state != SOCKET_STOP_PRE &&
1059 state != SOCKET_STOP_PRE_SIGTERM &&
1060 state != SOCKET_STOP_PRE_SIGKILL &&
1061 state != SOCKET_STOP_POST &&
1062 state != SOCKET_FINAL_SIGTERM &&
1063 state != SOCKET_FINAL_SIGKILL) {
1064 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1065 socket_unwatch_control_pid(s);
1066 s->control_command = NULL;
1067 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1070 if (state != SOCKET_LISTENING)
1071 socket_unwatch_fds(s);
1073 if (state != SOCKET_START_POST &&
1074 state != SOCKET_LISTENING &&
1075 state != SOCKET_RUNNING &&
1076 state != SOCKET_STOP_PRE &&
1077 state != SOCKET_STOP_PRE_SIGTERM &&
1078 state != SOCKET_STOP_PRE_SIGKILL)
1079 socket_close_fds(s);
1081 if (state != old_state)
1082 log_debug("%s changed %s -> %s",
1084 socket_state_to_string(old_state),
1085 socket_state_to_string(state));
1087 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1090 static int socket_coldplug(Unit *u) {
1091 Socket *s = SOCKET(u);
1095 assert(s->state == SOCKET_DEAD);
1097 if (s->deserialized_state != s->state) {
1099 if (s->deserialized_state == SOCKET_START_PRE ||
1100 s->deserialized_state == SOCKET_START_POST ||
1101 s->deserialized_state == SOCKET_STOP_PRE ||
1102 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1103 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1104 s->deserialized_state == SOCKET_STOP_POST ||
1105 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1106 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1108 if (s->control_pid <= 0)
1111 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1114 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1118 if (s->deserialized_state == SOCKET_START_POST ||
1119 s->deserialized_state == SOCKET_LISTENING ||
1120 s->deserialized_state == SOCKET_RUNNING ||
1121 s->deserialized_state == SOCKET_STOP_PRE ||
1122 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1123 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1124 if ((r = socket_open_fds(s)) < 0)
1127 if (s->deserialized_state == SOCKET_LISTENING)
1128 if ((r = socket_watch_fds(s)) < 0)
1131 socket_set_state(s, s->deserialized_state);
1137 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1146 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1149 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1158 UNIT(s)->manager->environment,
1162 UNIT(s)->manager->confirm_spawn,
1163 UNIT(s)->cgroup_bondings,
1164 UNIT(s)->cgroup_attributes,
1174 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1175 /* FIXME: we need to do something here */
1183 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1188 static void socket_enter_dead(Socket *s, SocketResult f) {
1191 if (f != SOCKET_SUCCESS)
1194 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1197 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1199 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1203 if (f != SOCKET_SUCCESS)
1206 socket_unwatch_control_pid(s);
1208 s->control_command_id = SOCKET_EXEC_STOP_POST;
1210 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1211 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1214 socket_set_state(s, SOCKET_STOP_POST);
1216 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1221 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1222 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1225 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1227 Set *pid_set = NULL;
1228 bool wait_for_exit = false;
1232 if (f != SOCKET_SUCCESS)
1235 if (s->kill_context.kill_mode != KILL_NONE) {
1236 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
1238 if (s->control_pid > 0) {
1239 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1241 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1243 wait_for_exit = true;
1246 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
1248 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1253 /* Exclude the control pid from being killed via the cgroup */
1254 if (s->control_pid > 0)
1255 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1258 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1260 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1261 log_warning("Failed to kill control group: %s", strerror(-r));
1263 wait_for_exit = true;
1270 if (wait_for_exit) {
1271 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1274 socket_set_state(s, state);
1275 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1276 socket_enter_stop_post(s, SOCKET_SUCCESS);
1278 socket_enter_dead(s, SOCKET_SUCCESS);
1283 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1285 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1286 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1288 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1294 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1298 if (f != SOCKET_SUCCESS)
1301 socket_unwatch_control_pid(s);
1303 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1305 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1306 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1309 socket_set_state(s, SOCKET_STOP_PRE);
1311 socket_enter_stop_post(s, SOCKET_SUCCESS);
1316 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1317 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1320 static void socket_enter_listening(Socket *s) {
1324 r = socket_watch_fds(s);
1326 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1330 socket_set_state(s, SOCKET_LISTENING);
1334 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1337 static void socket_enter_start_post(Socket *s) {
1341 r = socket_open_fds(s);
1343 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1347 socket_unwatch_control_pid(s);
1349 s->control_command_id = SOCKET_EXEC_START_POST;
1351 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1352 r = socket_spawn(s, s->control_command, &s->control_pid);
1354 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1358 socket_set_state(s, SOCKET_START_POST);
1360 socket_enter_listening(s);
1365 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1368 static void socket_enter_start_pre(Socket *s) {
1372 socket_unwatch_control_pid(s);
1374 s->control_command_id = SOCKET_EXEC_START_PRE;
1376 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1377 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1380 socket_set_state(s, SOCKET_START_PRE);
1382 socket_enter_start_post(s);
1387 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1388 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1391 static void socket_enter_running(Socket *s, int cfd) {
1396 dbus_error_init(&error);
1398 /* We don't take connections anymore if we are supposed to
1399 * shut down anyway */
1400 if (unit_pending_inactive(UNIT(s))) {
1401 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1404 close_nointr_nofail(cfd);
1406 /* Flush all sockets by closing and reopening them */
1407 socket_close_fds(s);
1409 r = socket_watch_fds(s);
1411 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1412 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1422 bool pending = false;
1424 /* If there's already a start pending don't bother to
1426 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1427 if (unit_pending_active(u)) {
1433 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1438 socket_set_state(s, SOCKET_RUNNING);
1440 char *prefix, *instance = NULL, *name;
1443 if (s->n_connections >= s->max_connections) {
1444 log_warning("Too many incoming connections (%u)", s->n_connections);
1445 close_nointr_nofail(cfd);
1449 r = socket_instantiate_service(s);
1453 r = instance_from_socket(cfd, s->n_accepted, &instance);
1458 /* ENOTCONN is legitimate if TCP RST was received.
1459 * This connection is over, but the socket unit lives on. */
1460 close_nointr_nofail(cfd);
1464 prefix = unit_name_to_prefix(UNIT(s)->id);
1471 name = unit_name_build(prefix, instance, ".service");
1480 r = unit_add_name(UNIT_DEREF(s->service), name);
1486 service = SERVICE(UNIT_DEREF(s->service));
1487 unit_ref_unset(&s->service);
1490 UNIT(service)->no_gc = false;
1492 unit_choose_id(UNIT(service), name);
1495 r = service_set_socket_fd(service, cfd, s);
1500 s->n_connections ++;
1502 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1506 /* Notify clients about changed counters */
1507 unit_add_to_dbus_queue(UNIT(s));
1513 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1514 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1517 close_nointr_nofail(cfd);
1519 dbus_error_free(&error);
1522 static void socket_run_next(Socket *s) {
1526 assert(s->control_command);
1527 assert(s->control_command->command_next);
1529 socket_unwatch_control_pid(s);
1531 s->control_command = s->control_command->command_next;
1533 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1539 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1541 if (s->state == SOCKET_START_POST)
1542 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1543 else if (s->state == SOCKET_STOP_POST)
1544 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1546 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1549 static int socket_start(Unit *u) {
1550 Socket *s = SOCKET(u);
1554 /* We cannot fulfill this request right now, try again later
1556 if (s->state == SOCKET_STOP_PRE ||
1557 s->state == SOCKET_STOP_PRE_SIGKILL ||
1558 s->state == SOCKET_STOP_PRE_SIGTERM ||
1559 s->state == SOCKET_STOP_POST ||
1560 s->state == SOCKET_FINAL_SIGTERM ||
1561 s->state == SOCKET_FINAL_SIGKILL)
1564 if (s->state == SOCKET_START_PRE ||
1565 s->state == SOCKET_START_POST)
1568 /* Cannot run this without the service being around */
1569 if (UNIT_DEREF(s->service)) {
1572 service = SERVICE(UNIT_DEREF(s->service));
1574 if (UNIT(service)->load_state != UNIT_LOADED) {
1575 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1579 /* If the service is already active we cannot start the
1581 if (service->state != SERVICE_DEAD &&
1582 service->state != SERVICE_FAILED &&
1583 service->state != SERVICE_AUTO_RESTART) {
1584 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1588 #ifdef HAVE_SYSV_COMPAT
1589 if (service->is_sysv) {
1590 log_error("Using SysV services for socket activation is not supported. Refusing.");
1596 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1598 s->result = SOCKET_SUCCESS;
1599 socket_enter_start_pre(s);
1603 static int socket_stop(Unit *u) {
1604 Socket *s = SOCKET(u);
1609 if (s->state == SOCKET_STOP_PRE ||
1610 s->state == SOCKET_STOP_PRE_SIGTERM ||
1611 s->state == SOCKET_STOP_PRE_SIGKILL ||
1612 s->state == SOCKET_STOP_POST ||
1613 s->state == SOCKET_FINAL_SIGTERM ||
1614 s->state == SOCKET_FINAL_SIGKILL)
1617 /* If there's already something running we go directly into
1619 if (s->state == SOCKET_START_PRE ||
1620 s->state == SOCKET_START_POST) {
1621 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1625 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1627 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1631 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1632 Socket *s = SOCKET(u);
1640 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1641 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1642 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1644 if (s->control_pid > 0)
1645 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1647 if (s->control_command_id >= 0)
1648 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1650 LIST_FOREACH(port, p, s->ports) {
1656 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1659 if (p->type == SOCKET_SOCKET) {
1662 if ((r = socket_address_print(&p->address, &t)) < 0)
1665 if (socket_address_family(&p->address) == AF_NETLINK)
1666 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1668 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1670 } else if (p->type == SOCKET_SPECIAL)
1671 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1673 assert(p->type == SOCKET_FIFO);
1674 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1681 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1682 Socket *s = SOCKET(u);
1689 if (streq(key, "state")) {
1692 if ((state = socket_state_from_string(value)) < 0)
1693 log_debug("Failed to parse state value %s", value);
1695 s->deserialized_state = state;
1696 } else if (streq(key, "result")) {
1699 f = socket_result_from_string(value);
1701 log_debug("Failed to parse result value %s", value);
1702 else if (f != SOCKET_SUCCESS)
1705 } else if (streq(key, "n-accepted")) {
1708 if (safe_atou(value, &k) < 0)
1709 log_debug("Failed to parse n-accepted value %s", value);
1712 } else if (streq(key, "control-pid")) {
1715 if (parse_pid(value, &pid) < 0)
1716 log_debug("Failed to parse control-pid value %s", value);
1718 s->control_pid = pid;
1719 } else if (streq(key, "control-command")) {
1720 SocketExecCommand id;
1722 if ((id = socket_exec_command_from_string(value)) < 0)
1723 log_debug("Failed to parse exec-command value %s", value);
1725 s->control_command_id = id;
1726 s->control_command = s->exec_command[id];
1728 } else if (streq(key, "fifo")) {
1732 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1733 log_debug("Failed to parse fifo value %s", value);
1736 LIST_FOREACH(port, p, s->ports)
1737 if (p->type == SOCKET_FIFO &&
1738 streq_ptr(p->path, value+skip))
1743 close_nointr_nofail(p->fd);
1744 p->fd = fdset_remove(fds, fd);
1748 } else if (streq(key, "special")) {
1752 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1753 log_debug("Failed to parse special value %s", value);
1756 LIST_FOREACH(port, p, s->ports)
1757 if (p->type == SOCKET_SPECIAL &&
1758 streq_ptr(p->path, value+skip))
1763 close_nointr_nofail(p->fd);
1764 p->fd = fdset_remove(fds, fd);
1768 } else if (streq(key, "socket")) {
1769 int fd, type, skip = 0;
1772 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1773 log_debug("Failed to parse socket value %s", value);
1776 LIST_FOREACH(port, p, s->ports)
1777 if (socket_address_is(&p->address, value+skip, type))
1782 close_nointr_nofail(p->fd);
1783 p->fd = fdset_remove(fds, fd);
1787 } else if (streq(key, "netlink")) {
1791 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1792 log_debug("Failed to parse socket value %s", value);
1795 LIST_FOREACH(port, p, s->ports)
1796 if (socket_address_is_netlink(&p->address, value+skip))
1801 close_nointr_nofail(p->fd);
1802 p->fd = fdset_remove(fds, fd);
1807 log_debug("Unknown serialization key '%s'", key);
1812 static UnitActiveState socket_active_state(Unit *u) {
1815 return state_translation_table[SOCKET(u)->state];
1818 static const char *socket_sub_state_to_string(Unit *u) {
1821 return socket_state_to_string(SOCKET(u)->state);
1824 static bool socket_check_gc(Unit *u) {
1825 Socket *s = SOCKET(u);
1829 return s->n_connections > 0;
1832 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1833 Socket *s = SOCKET(u);
1839 if (s->state != SOCKET_LISTENING)
1842 log_debug("Incoming traffic on %s", u->id);
1844 if (events != EPOLLIN) {
1846 if (events & EPOLLHUP)
1847 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1849 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1854 if (w->socket_accept) {
1857 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1863 log_error("Failed to accept socket: %m");
1870 socket_apply_socket_options(s, cfd);
1873 socket_enter_running(s, cfd);
1877 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1880 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1881 Socket *s = SOCKET(u);
1887 if (pid != s->control_pid)
1892 if (is_clean_exit(code, status, NULL))
1894 else if (code == CLD_EXITED)
1895 f = SOCKET_FAILURE_EXIT_CODE;
1896 else if (code == CLD_KILLED)
1897 f = SOCKET_FAILURE_SIGNAL;
1898 else if (code == CLD_DUMPED)
1899 f = SOCKET_FAILURE_CORE_DUMP;
1901 assert_not_reached("Unknown code");
1903 if (s->control_command) {
1904 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1906 if (s->control_command->ignore)
1910 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1911 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1913 if (f != SOCKET_SUCCESS)
1916 if (s->control_command &&
1917 s->control_command->command_next &&
1918 f == SOCKET_SUCCESS) {
1920 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1923 s->control_command = NULL;
1924 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1926 /* No further commands for this step, so let's figure
1927 * out what to do next */
1929 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1933 case SOCKET_START_PRE:
1934 if (f == SOCKET_SUCCESS)
1935 socket_enter_start_post(s);
1937 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1940 case SOCKET_START_POST:
1941 if (f == SOCKET_SUCCESS)
1942 socket_enter_listening(s);
1944 socket_enter_stop_pre(s, f);
1947 case SOCKET_STOP_PRE:
1948 case SOCKET_STOP_PRE_SIGTERM:
1949 case SOCKET_STOP_PRE_SIGKILL:
1950 socket_enter_stop_post(s, f);
1953 case SOCKET_STOP_POST:
1954 case SOCKET_FINAL_SIGTERM:
1955 case SOCKET_FINAL_SIGKILL:
1956 socket_enter_dead(s, f);
1960 assert_not_reached("Uh, control process died at wrong time.");
1964 /* Notify clients about changed exit status */
1965 unit_add_to_dbus_queue(u);
1968 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1969 Socket *s = SOCKET(u);
1972 assert(elapsed == 1);
1973 assert(w == &s->timer_watch);
1977 case SOCKET_START_PRE:
1978 log_warning("%s starting timed out. Terminating.", u->id);
1979 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1982 case SOCKET_START_POST:
1983 log_warning("%s starting timed out. Stopping.", u->id);
1984 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1987 case SOCKET_STOP_PRE:
1988 log_warning("%s stopping timed out. Terminating.", u->id);
1989 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1992 case SOCKET_STOP_PRE_SIGTERM:
1993 if (s->kill_context.send_sigkill) {
1994 log_warning("%s stopping timed out. Killing.", u->id);
1995 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1997 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1998 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2002 case SOCKET_STOP_PRE_SIGKILL:
2003 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2004 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2007 case SOCKET_STOP_POST:
2008 log_warning("%s stopping timed out (2). Terminating.", u->id);
2009 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2012 case SOCKET_FINAL_SIGTERM:
2013 if (s->kill_context.send_sigkill) {
2014 log_warning("%s stopping timed out (2). Killing.", u->id);
2015 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2017 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2018 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2022 case SOCKET_FINAL_SIGKILL:
2023 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2024 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2028 assert_not_reached("Timeout at wrong time.");
2032 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2041 /* Called from the service code for requesting our fds */
2044 LIST_FOREACH(port, p, s->ports)
2054 if (!(rfds = new(int, rn_fds)))
2058 LIST_FOREACH(port, p, s->ports)
2062 assert(k == rn_fds);
2070 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2073 /* The service is dead. Dang!
2075 * This is strictly for one-instance-for-all-connections
2078 if (s->state == SOCKET_RUNNING) {
2079 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2080 if (failed_permanent)
2081 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2083 socket_enter_listening(s);
2087 void socket_connection_unref(Socket *s) {
2090 /* The service is dead. Yay!
2092 * This is strictly for one-instance-per-connection
2095 assert(s->n_connections > 0);
2098 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2101 static void socket_reset_failed(Unit *u) {
2102 Socket *s = SOCKET(u);
2106 if (s->state == SOCKET_FAILED)
2107 socket_set_state(s, SOCKET_DEAD);
2109 s->result = SOCKET_SUCCESS;
2112 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2113 Socket *s = SOCKET(u);
2115 Set *pid_set = NULL;
2119 if (who == KILL_MAIN) {
2120 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2124 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2125 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2129 if (who == KILL_CONTROL || who == KILL_ALL)
2130 if (s->control_pid > 0)
2131 if (kill(s->control_pid, signo) < 0)
2134 if (who == KILL_ALL) {
2137 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2141 /* Exclude the control pid from being killed via the cgroup */
2142 if (s->control_pid > 0) {
2143 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2150 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2151 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2162 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2163 [SOCKET_DEAD] = "dead",
2164 [SOCKET_START_PRE] = "start-pre",
2165 [SOCKET_START_POST] = "start-post",
2166 [SOCKET_LISTENING] = "listening",
2167 [SOCKET_RUNNING] = "running",
2168 [SOCKET_STOP_PRE] = "stop-pre",
2169 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2170 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2171 [SOCKET_STOP_POST] = "stop-post",
2172 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2173 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2174 [SOCKET_FAILED] = "failed"
2177 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2179 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2180 [SOCKET_EXEC_START_PRE] = "StartPre",
2181 [SOCKET_EXEC_START_POST] = "StartPost",
2182 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2183 [SOCKET_EXEC_STOP_POST] = "StopPost"
2186 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2188 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2189 [SOCKET_SUCCESS] = "success",
2190 [SOCKET_FAILURE_RESOURCES] = "resources",
2191 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2192 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2193 [SOCKET_FAILURE_SIGNAL] = "signal",
2194 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2195 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2198 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2200 const UnitVTable socket_vtable = {
2201 .object_size = sizeof(Socket),
2202 .exec_context_offset = offsetof(Socket, exec_context),
2209 .init = socket_init,
2210 .done = socket_done,
2211 .load = socket_load,
2213 .kill = socket_kill,
2215 .coldplug = socket_coldplug,
2217 .dump = socket_dump,
2219 .start = socket_start,
2220 .stop = socket_stop,
2222 .serialize = socket_serialize,
2223 .deserialize_item = socket_deserialize_item,
2225 .active_state = socket_active_state,
2226 .sub_state_to_string = socket_sub_state_to_string,
2228 .check_gc = socket_check_gc,
2230 .fd_event = socket_fd_event,
2231 .sigchld_event = socket_sigchld_event,
2232 .timer_event = socket_timer_event,
2234 .reset_failed = socket_reset_failed,
2236 .bus_interface = "org.freedesktop.systemd1.Socket",
2237 .bus_message_handler = bus_socket_message_handler,
2238 .bus_invalidating_properties = bus_socket_invalidating_properties,
2240 .status_message_formats = {
2241 /*.starting_stopping = {
2242 [0] = "Starting socket %s...",
2243 [1] = "Stopping socket %s...",
2245 .finished_start_job = {
2246 [JOB_DONE] = "Listening on %s.",
2247 [JOB_FAILED] = "Failed to listen on %s.",
2248 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2249 [JOB_TIMEOUT] = "Timed out starting %s.",
2251 .finished_stop_job = {
2252 [JOB_DONE] = "Closed %s.",
2253 [JOB_FAILED] = "Failed stopping %s.",
2254 [JOB_TIMEOUT] = "Timed out stopping %s.",