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 "dbus-socket.h"
45 #include "bus-errors.h"
47 #include "exit-status.h"
50 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
51 [SOCKET_DEAD] = UNIT_INACTIVE,
52 [SOCKET_START_PRE] = UNIT_ACTIVATING,
53 [SOCKET_START_POST] = UNIT_ACTIVATING,
54 [SOCKET_LISTENING] = UNIT_ACTIVE,
55 [SOCKET_RUNNING] = UNIT_ACTIVE,
56 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
57 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
58 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
59 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
60 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
61 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
62 [SOCKET_FAILED] = UNIT_FAILED
65 static void socket_init(Unit *u) {
66 Socket *s = SOCKET(u);
69 assert(u->load_state == UNIT_STUB);
71 s->backlog = SOMAXCONN;
72 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
73 s->directory_mode = 0755;
74 s->socket_mode = 0666;
76 s->max_connections = 64;
83 exec_context_init(&s->exec_context);
84 s->exec_context.std_output = u->manager->default_std_output;
85 s->exec_context.std_error = u->manager->default_std_error;
87 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
90 static void socket_unwatch_control_pid(Socket *s) {
93 if (s->control_pid <= 0)
96 unit_unwatch_pid(UNIT(s), s->control_pid);
100 static void socket_done(Unit *u) {
101 Socket *s = SOCKET(u);
106 while ((p = s->ports)) {
107 LIST_REMOVE(SocketPort, port, s->ports, p);
110 unit_unwatch_fd(UNIT(s), &p->fd_watch);
111 close_nointr_nofail(p->fd);
118 exec_context_done(&s->exec_context);
119 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
120 s->control_command = NULL;
122 socket_unwatch_control_pid(s);
124 unit_ref_unset(&s->service);
126 free(s->tcp_congestion);
127 s->tcp_congestion = NULL;
129 free(s->bind_to_device);
130 s->bind_to_device = NULL;
132 unit_unwatch_timer(u, &s->timer_watch);
135 static int socket_instantiate_service(Socket *s) {
142 /* This fills in s->service if it isn't filled in yet. For
143 * Accept=yes sockets we create the next connection service
144 * here. For Accept=no this is mostly a NOP since the service
145 * is figured out at load time anyway. */
147 if (UNIT_DEREF(s->service))
152 if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
155 r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
161 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
167 #ifdef HAVE_SYSV_COMPAT
168 if (SERVICE(u)->is_sysv) {
169 log_error("Using SysV services for socket activation is not supported. Refusing.");
175 unit_ref_set(&s->service, u);
177 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
180 static bool have_non_accept_socket(Socket *s) {
188 LIST_FOREACH(port, p, s->ports) {
190 if (p->type != SOCKET_SOCKET)
193 if (!socket_address_can_accept(&p->address))
200 static int socket_verify(Socket *s) {
203 if (UNIT(s)->load_state != UNIT_LOADED)
207 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
211 if (s->accept && have_non_accept_socket(s)) {
212 log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
216 if (s->accept && s->max_connections <= 0) {
217 log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
221 if (s->accept && UNIT_DEREF(s->service)) {
222 log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
226 if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
227 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
234 static bool socket_needs_mount(Socket *s, const char *prefix) {
239 LIST_FOREACH(port, p, s->ports) {
241 if (p->type == SOCKET_SOCKET) {
242 if (socket_address_needs_mount(&p->address, prefix))
244 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
245 if (path_startswith(p->path, prefix))
253 int socket_add_one_mount_link(Socket *s, Mount *m) {
259 if (UNIT(s)->load_state != UNIT_LOADED ||
260 UNIT(m)->load_state != UNIT_LOADED)
263 if (!socket_needs_mount(s, m->where))
266 if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
272 static int socket_add_mount_links(Socket *s) {
278 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
279 if ((r = socket_add_one_mount_link(s, MOUNT(other))) < 0)
285 static int socket_add_device_link(Socket *s) {
291 if (!s->bind_to_device)
294 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
297 r = unit_add_node_link(UNIT(s), t, false);
303 static int socket_add_default_dependencies(Socket *s) {
307 if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
308 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
311 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
315 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
318 static bool socket_has_exec(Socket *s) {
322 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
323 if (s->exec_command[i])
329 static int socket_load(Unit *u) {
330 Socket *s = SOCKET(u);
334 assert(u->load_state == UNIT_STUB);
336 if ((r = unit_load_fragment_and_dropin(u)) < 0)
339 /* This is a new unit? Then let's add in some extras */
340 if (u->load_state == UNIT_LOADED) {
342 if (have_non_accept_socket(s)) {
344 if (!UNIT_DEREF(s->service)) {
347 r = unit_load_related_unit(u, ".service", &x);
351 unit_ref_set(&s->service, x);
354 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
359 if ((r = socket_add_mount_links(s)) < 0)
362 if ((r = socket_add_device_link(s)) < 0)
365 if (socket_has_exec(s))
366 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
369 if ((r = unit_add_default_cgroups(u)) < 0)
372 if (UNIT(s)->default_dependencies)
373 if ((r = socket_add_default_dependencies(s)) < 0)
377 return socket_verify(s);
380 static const char* listen_lookup(int family, int type) {
382 if (family == AF_NETLINK)
383 return "ListenNetlink";
385 if (type == SOCK_STREAM)
386 return "ListenStream";
387 else if (type == SOCK_DGRAM)
388 return "ListenDatagram";
389 else if (type == SOCK_SEQPACKET)
390 return "ListenSequentialPacket";
392 assert_not_reached("Unknown socket type");
396 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
399 Socket *s = SOCKET(u);
407 p2 = strappend(prefix, "\t");
408 prefix2 = p2 ? p2 : prefix;
411 "%sSocket State: %s\n"
413 "%sBindIPv6Only: %s\n"
415 "%sSocketMode: %04o\n"
416 "%sDirectoryMode: %04o\n"
419 "%sTransparent: %s\n"
421 "%sPassCredentials: %s\n"
422 "%sPassSecurity: %s\n"
423 "%sTCPCongestion: %s\n",
424 prefix, socket_state_to_string(s->state),
425 prefix, socket_result_to_string(s->result),
426 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
428 prefix, s->socket_mode,
429 prefix, s->directory_mode,
430 prefix, yes_no(s->keep_alive),
431 prefix, yes_no(s->free_bind),
432 prefix, yes_no(s->transparent),
433 prefix, yes_no(s->broadcast),
434 prefix, yes_no(s->pass_cred),
435 prefix, yes_no(s->pass_sec),
436 prefix, strna(s->tcp_congestion));
438 if (s->control_pid > 0)
440 "%sControl PID: %lu\n",
441 prefix, (unsigned long) s->control_pid);
443 if (s->bind_to_device)
445 "%sBindToDevice: %s\n",
446 prefix, s->bind_to_device);
451 "%sNConnections: %u\n"
452 "%sMaxConnections: %u\n",
453 prefix, s->n_accepted,
454 prefix, s->n_connections,
455 prefix, s->max_connections);
457 if (s->priority >= 0)
460 prefix, s->priority);
462 if (s->receive_buffer > 0)
464 "%sReceiveBuffer: %zu\n",
465 prefix, s->receive_buffer);
467 if (s->send_buffer > 0)
469 "%sSendBuffer: %zu\n",
470 prefix, s->send_buffer);
482 if (s->pipe_size > 0)
485 prefix, s->pipe_size);
492 if (s->mq_maxmsg > 0)
494 "%sMessageQueueMaxMessages: %li\n",
495 prefix, s->mq_maxmsg);
497 if (s->mq_msgsize > 0)
499 "%sMessageQueueMessageSize: %li\n",
500 prefix, s->mq_msgsize);
502 LIST_FOREACH(port, p, s->ports) {
504 if (p->type == SOCKET_SOCKET) {
509 if ((r = socket_address_print(&p->address, &k)) < 0)
514 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
516 } else if (p->type == SOCKET_SPECIAL)
517 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
518 else if (p->type == SOCKET_MQUEUE)
519 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
521 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
524 exec_context_dump(&s->exec_context, f, prefix);
526 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
527 if (!s->exec_command[c])
530 fprintf(f, "%s-> %s:\n",
531 prefix, socket_exec_command_to_string(c));
533 exec_command_dump_list(s->exec_command[c], f, prefix2);
539 static int instance_from_socket(int fd, unsigned nr, char **instance) {
544 struct sockaddr_un un;
545 struct sockaddr_in in;
546 struct sockaddr_in6 in6;
547 struct sockaddr_storage storage;
554 if (getsockname(fd, &local.sa, &l) < 0)
558 if (getpeername(fd, &remote.sa, &l) < 0)
561 switch (local.sa.sa_family) {
565 a = ntohl(local.in.sin_addr.s_addr),
566 b = ntohl(remote.in.sin_addr.s_addr);
569 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
571 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
572 ntohs(local.in.sin_port),
573 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
574 ntohs(remote.in.sin_port)) < 0)
581 static const char ipv4_prefix[] = {
582 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
585 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
586 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
588 *a = local.in6.sin6_addr.s6_addr+12,
589 *b = remote.in6.sin6_addr.s6_addr+12;
592 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
594 a[0], a[1], a[2], a[3],
595 ntohs(local.in6.sin6_port),
596 b[0], b[1], b[2], b[3],
597 ntohs(remote.in6.sin6_port)) < 0)
600 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
605 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
606 ntohs(local.in6.sin6_port),
607 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
608 ntohs(remote.in6.sin6_port)) < 0)
619 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
625 (unsigned long) ucred.pid,
626 (unsigned long) ucred.uid) < 0)
633 assert_not_reached("Unhandled socket type.");
640 static void socket_close_fds(Socket *s) {
645 LIST_FOREACH(port, p, s->ports) {
649 unit_unwatch_fd(UNIT(s), &p->fd_watch);
650 close_nointr_nofail(p->fd);
652 /* One little note: we should never delete any sockets
653 * in the file system here! After all some other
654 * process we spawned might still have a reference of
655 * this fd and wants to continue to use it. Therefore
656 * we delete sockets in the file system before we
657 * create a new one, not after we stopped using
664 static void socket_apply_socket_options(Socket *s, int fd) {
669 int b = s->keep_alive;
670 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
671 log_warning("SO_KEEPALIVE failed: %m");
676 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
677 log_warning("SO_BROADCAST failed: %m");
682 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
683 log_warning("SO_PASSCRED failed: %m");
688 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
689 log_warning("SO_PASSSEC failed: %m");
692 if (s->priority >= 0)
693 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
694 log_warning("SO_PRIORITY failed: %m");
696 if (s->receive_buffer > 0) {
697 int value = (int) s->receive_buffer;
699 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
701 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
702 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
703 log_warning("SO_RCVBUF failed: %m");
706 if (s->send_buffer > 0) {
707 int value = (int) s->send_buffer;
708 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
709 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
710 log_warning("SO_SNDBUF failed: %m");
714 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
715 log_warning("SO_MARK failed: %m");
718 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
719 log_warning("IP_TOS failed: %m");
721 if (s->ip_ttl >= 0) {
724 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
726 if (socket_ipv6_is_supported())
727 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
730 errno = EAFNOSUPPORT;
734 log_warning("IP_TTL/IPV6_UNICAST_HOPS failed: %m");
737 if (s->tcp_congestion)
738 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
739 log_warning("TCP_CONGESTION failed: %m");
742 static void socket_apply_fifo_options(Socket *s, int fd) {
746 if (s->pipe_size > 0)
747 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
748 log_warning("F_SETPIPE_SZ: %m");
751 static int fifo_address_create(
753 mode_t directory_mode,
764 mkdir_parents_label(path, directory_mode);
766 r = label_context_set(path, S_IFIFO);
770 /* Enforce the right access mode for the fifo */
771 old_mask = umask(~ socket_mode);
773 /* Include the original umask in our mask */
774 umask(~socket_mode | old_mask);
776 r = mkfifo(path, socket_mode);
779 if (r < 0 && errno != EEXIST) {
784 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
789 label_context_clear();
791 if (fstat(fd, &st) < 0) {
796 if (!S_ISFIFO(st.st_mode) ||
797 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
798 st.st_uid != getuid() ||
799 st.st_gid != getgid()) {
809 label_context_clear();
812 close_nointr_nofail(fd);
817 static int special_address_create(
827 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
832 if (fstat(fd, &st) < 0) {
837 /* Check whether this is a /proc, /sys or /dev file or char device */
838 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
848 close_nointr_nofail(fd);
853 static int mq_address_create(
863 struct mq_attr _attr, *attr = NULL;
868 if (maxmsg > 0 && msgsize > 0) {
870 _attr.mq_flags = O_NONBLOCK;
871 _attr.mq_maxmsg = maxmsg;
872 _attr.mq_msgsize = msgsize;
876 /* Enforce the right access mode for the mq */
877 old_mask = umask(~ mq_mode);
879 /* Include the original umask in our mask */
880 umask(~mq_mode | old_mask);
882 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
890 if (fstat(fd, &st) < 0) {
895 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
896 st.st_uid != getuid() ||
897 st.st_gid != getgid()) {
908 close_nointr_nofail(fd);
913 static int socket_open_fds(Socket *s) {
917 bool know_label = false;
921 LIST_FOREACH(port, p, s->ports) {
926 if (p->type == SOCKET_SOCKET) {
930 if ((r = socket_instantiate_service(s)) < 0)
933 if (UNIT_DEREF(s->service) &&
934 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
935 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
946 if ((r = socket_address_listen(
959 socket_apply_socket_options(s, p->fd);
961 } else if (p->type == SOCKET_SPECIAL) {
963 if ((r = special_address_create(
968 } else if (p->type == SOCKET_FIFO) {
970 if ((r = fifo_address_create(
977 socket_apply_fifo_options(s, p->fd);
978 } else if (p->type == SOCKET_MQUEUE) {
980 if ((r = mq_address_create(
988 assert_not_reached("Unknown port type");
1000 static void socket_unwatch_fds(Socket *s) {
1005 LIST_FOREACH(port, p, s->ports) {
1009 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1013 static int socket_watch_fds(Socket *s) {
1019 LIST_FOREACH(port, p, s->ports) {
1023 p->fd_watch.socket_accept =
1025 p->type == SOCKET_SOCKET &&
1026 socket_address_can_accept(&p->address);
1028 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1035 socket_unwatch_fds(s);
1039 static void socket_set_state(Socket *s, SocketState state) {
1040 SocketState old_state;
1043 old_state = s->state;
1046 if (state != SOCKET_START_PRE &&
1047 state != SOCKET_START_POST &&
1048 state != SOCKET_STOP_PRE &&
1049 state != SOCKET_STOP_PRE_SIGTERM &&
1050 state != SOCKET_STOP_PRE_SIGKILL &&
1051 state != SOCKET_STOP_POST &&
1052 state != SOCKET_FINAL_SIGTERM &&
1053 state != SOCKET_FINAL_SIGKILL) {
1054 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1055 socket_unwatch_control_pid(s);
1056 s->control_command = NULL;
1057 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1060 if (state != SOCKET_LISTENING)
1061 socket_unwatch_fds(s);
1063 if (state != SOCKET_START_POST &&
1064 state != SOCKET_LISTENING &&
1065 state != SOCKET_RUNNING &&
1066 state != SOCKET_STOP_PRE &&
1067 state != SOCKET_STOP_PRE_SIGTERM &&
1068 state != SOCKET_STOP_PRE_SIGKILL)
1069 socket_close_fds(s);
1071 if (state != old_state)
1072 log_debug("%s changed %s -> %s",
1074 socket_state_to_string(old_state),
1075 socket_state_to_string(state));
1077 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1080 static int socket_coldplug(Unit *u) {
1081 Socket *s = SOCKET(u);
1085 assert(s->state == SOCKET_DEAD);
1087 if (s->deserialized_state != s->state) {
1089 if (s->deserialized_state == SOCKET_START_PRE ||
1090 s->deserialized_state == SOCKET_START_POST ||
1091 s->deserialized_state == SOCKET_STOP_PRE ||
1092 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1093 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1094 s->deserialized_state == SOCKET_STOP_POST ||
1095 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1096 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1098 if (s->control_pid <= 0)
1101 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1104 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1108 if (s->deserialized_state == SOCKET_START_POST ||
1109 s->deserialized_state == SOCKET_LISTENING ||
1110 s->deserialized_state == SOCKET_RUNNING ||
1111 s->deserialized_state == SOCKET_STOP_PRE ||
1112 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1113 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1114 if ((r = socket_open_fds(s)) < 0)
1117 if (s->deserialized_state == SOCKET_LISTENING)
1118 if ((r = socket_watch_fds(s)) < 0)
1121 socket_set_state(s, s->deserialized_state);
1127 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1136 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1139 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1148 UNIT(s)->manager->environment,
1152 UNIT(s)->manager->confirm_spawn,
1153 UNIT(s)->cgroup_bondings,
1154 UNIT(s)->cgroup_attributes,
1164 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1165 /* FIXME: we need to do something here */
1173 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1178 static void socket_enter_dead(Socket *s, SocketResult f) {
1181 if (f != SOCKET_SUCCESS)
1184 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1187 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1189 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1193 if (f != SOCKET_SUCCESS)
1196 socket_unwatch_control_pid(s);
1198 s->control_command_id = SOCKET_EXEC_STOP_POST;
1200 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1201 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1204 socket_set_state(s, SOCKET_STOP_POST);
1206 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1211 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1212 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1215 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1217 Set *pid_set = NULL;
1218 bool wait_for_exit = false;
1222 if (f != SOCKET_SUCCESS)
1225 if (s->exec_context.kill_mode != KILL_NONE) {
1226 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1228 if (s->control_pid > 0) {
1229 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1231 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1233 wait_for_exit = true;
1236 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1238 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1243 /* Exclude the control pid from being killed via the cgroup */
1244 if (s->control_pid > 0)
1245 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1248 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1250 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1251 log_warning("Failed to kill control group: %s", strerror(-r));
1253 wait_for_exit = true;
1260 if (wait_for_exit) {
1261 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1264 socket_set_state(s, state);
1265 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1266 socket_enter_stop_post(s, SOCKET_SUCCESS);
1268 socket_enter_dead(s, SOCKET_SUCCESS);
1273 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1275 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1276 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1278 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1284 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1288 if (f != SOCKET_SUCCESS)
1291 socket_unwatch_control_pid(s);
1293 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1295 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1296 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1299 socket_set_state(s, SOCKET_STOP_PRE);
1301 socket_enter_stop_post(s, SOCKET_SUCCESS);
1306 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1307 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1310 static void socket_enter_listening(Socket *s) {
1314 r = socket_watch_fds(s);
1316 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1320 socket_set_state(s, SOCKET_LISTENING);
1324 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1327 static void socket_enter_start_post(Socket *s) {
1331 r = socket_open_fds(s);
1333 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1337 socket_unwatch_control_pid(s);
1339 s->control_command_id = SOCKET_EXEC_START_POST;
1341 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1342 r = socket_spawn(s, s->control_command, &s->control_pid);
1344 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1348 socket_set_state(s, SOCKET_START_POST);
1350 socket_enter_listening(s);
1355 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1358 static void socket_enter_start_pre(Socket *s) {
1362 socket_unwatch_control_pid(s);
1364 s->control_command_id = SOCKET_EXEC_START_PRE;
1366 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1367 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1370 socket_set_state(s, SOCKET_START_PRE);
1372 socket_enter_start_post(s);
1377 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1378 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1381 static void socket_enter_running(Socket *s, int cfd) {
1386 dbus_error_init(&error);
1388 /* We don't take connections anymore if we are supposed to
1389 * shut down anyway */
1390 if (unit_pending_inactive(UNIT(s))) {
1391 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1394 close_nointr_nofail(cfd);
1396 /* Flush all sockets by closing and reopening them */
1397 socket_close_fds(s);
1399 r = socket_watch_fds(s);
1401 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1402 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1412 bool pending = false;
1414 /* If there's already a start pending don't bother to
1416 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1417 if (unit_pending_active(u)) {
1423 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1428 socket_set_state(s, SOCKET_RUNNING);
1430 char *prefix, *instance = NULL, *name;
1433 if (s->n_connections >= s->max_connections) {
1434 log_warning("Too many incoming connections (%u)", s->n_connections);
1435 close_nointr_nofail(cfd);
1439 r = socket_instantiate_service(s);
1443 r = instance_from_socket(cfd, s->n_accepted, &instance);
1448 /* ENOTCONN is legitimate if TCP RST was received.
1449 * This connection is over, but the socket unit lives on. */
1450 close_nointr_nofail(cfd);
1454 prefix = unit_name_to_prefix(UNIT(s)->id);
1461 name = unit_name_build(prefix, instance, ".service");
1470 r = unit_add_name(UNIT_DEREF(s->service), name);
1476 service = SERVICE(UNIT_DEREF(s->service));
1477 unit_ref_unset(&s->service);
1480 UNIT(service)->no_gc = false;
1482 unit_choose_id(UNIT(service), name);
1485 r = service_set_socket_fd(service, cfd, s);
1490 s->n_connections ++;
1492 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1496 /* Notify clients about changed counters */
1497 unit_add_to_dbus_queue(UNIT(s));
1503 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1504 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1507 close_nointr_nofail(cfd);
1509 dbus_error_free(&error);
1512 static void socket_run_next(Socket *s) {
1516 assert(s->control_command);
1517 assert(s->control_command->command_next);
1519 socket_unwatch_control_pid(s);
1521 s->control_command = s->control_command->command_next;
1523 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1529 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1531 if (s->state == SOCKET_START_POST)
1532 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1533 else if (s->state == SOCKET_STOP_POST)
1534 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1536 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1539 static int socket_start(Unit *u) {
1540 Socket *s = SOCKET(u);
1544 /* We cannot fulfill this request right now, try again later
1546 if (s->state == SOCKET_STOP_PRE ||
1547 s->state == SOCKET_STOP_PRE_SIGKILL ||
1548 s->state == SOCKET_STOP_PRE_SIGTERM ||
1549 s->state == SOCKET_STOP_POST ||
1550 s->state == SOCKET_FINAL_SIGTERM ||
1551 s->state == SOCKET_FINAL_SIGKILL)
1554 if (s->state == SOCKET_START_PRE ||
1555 s->state == SOCKET_START_POST)
1558 /* Cannot run this without the service being around */
1559 if (UNIT_DEREF(s->service)) {
1562 service = SERVICE(UNIT_DEREF(s->service));
1564 if (UNIT(service)->load_state != UNIT_LOADED) {
1565 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1569 /* If the service is already active we cannot start the
1571 if (service->state != SERVICE_DEAD &&
1572 service->state != SERVICE_FAILED &&
1573 service->state != SERVICE_AUTO_RESTART) {
1574 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1578 #ifdef HAVE_SYSV_COMPAT
1579 if (service->is_sysv) {
1580 log_error("Using SysV services for socket activation is not supported. Refusing.");
1586 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1588 s->result = SOCKET_SUCCESS;
1589 socket_enter_start_pre(s);
1593 static int socket_stop(Unit *u) {
1594 Socket *s = SOCKET(u);
1599 if (s->state == SOCKET_STOP_PRE ||
1600 s->state == SOCKET_STOP_PRE_SIGTERM ||
1601 s->state == SOCKET_STOP_PRE_SIGKILL ||
1602 s->state == SOCKET_STOP_POST ||
1603 s->state == SOCKET_FINAL_SIGTERM ||
1604 s->state == SOCKET_FINAL_SIGKILL)
1607 /* If there's already something running we go directly into
1609 if (s->state == SOCKET_START_PRE ||
1610 s->state == SOCKET_START_POST) {
1611 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1615 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1617 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1621 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1622 Socket *s = SOCKET(u);
1630 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1631 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1632 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1634 if (s->control_pid > 0)
1635 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1637 if (s->control_command_id >= 0)
1638 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1640 LIST_FOREACH(port, p, s->ports) {
1646 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1649 if (p->type == SOCKET_SOCKET) {
1652 if ((r = socket_address_print(&p->address, &t)) < 0)
1655 if (socket_address_family(&p->address) == AF_NETLINK)
1656 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1658 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1660 } else if (p->type == SOCKET_SPECIAL)
1661 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1663 assert(p->type == SOCKET_FIFO);
1664 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1671 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1672 Socket *s = SOCKET(u);
1679 if (streq(key, "state")) {
1682 if ((state = socket_state_from_string(value)) < 0)
1683 log_debug("Failed to parse state value %s", value);
1685 s->deserialized_state = state;
1686 } else if (streq(key, "result")) {
1689 f = socket_result_from_string(value);
1691 log_debug("Failed to parse result value %s", value);
1692 else if (f != SOCKET_SUCCESS)
1695 } else if (streq(key, "n-accepted")) {
1698 if (safe_atou(value, &k) < 0)
1699 log_debug("Failed to parse n-accepted value %s", value);
1702 } else if (streq(key, "control-pid")) {
1705 if (parse_pid(value, &pid) < 0)
1706 log_debug("Failed to parse control-pid value %s", value);
1708 s->control_pid = pid;
1709 } else if (streq(key, "control-command")) {
1710 SocketExecCommand id;
1712 if ((id = socket_exec_command_from_string(value)) < 0)
1713 log_debug("Failed to parse exec-command value %s", value);
1715 s->control_command_id = id;
1716 s->control_command = s->exec_command[id];
1718 } else if (streq(key, "fifo")) {
1722 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1723 log_debug("Failed to parse fifo value %s", value);
1726 LIST_FOREACH(port, p, s->ports)
1727 if (p->type == SOCKET_FIFO &&
1728 streq_ptr(p->path, value+skip))
1733 close_nointr_nofail(p->fd);
1734 p->fd = fdset_remove(fds, fd);
1738 } else if (streq(key, "special")) {
1742 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1743 log_debug("Failed to parse special value %s", value);
1746 LIST_FOREACH(port, p, s->ports)
1747 if (p->type == SOCKET_SPECIAL &&
1748 streq_ptr(p->path, value+skip))
1753 close_nointr_nofail(p->fd);
1754 p->fd = fdset_remove(fds, fd);
1758 } else if (streq(key, "socket")) {
1759 int fd, type, skip = 0;
1762 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1763 log_debug("Failed to parse socket value %s", value);
1766 LIST_FOREACH(port, p, s->ports)
1767 if (socket_address_is(&p->address, value+skip, type))
1772 close_nointr_nofail(p->fd);
1773 p->fd = fdset_remove(fds, fd);
1777 } else if (streq(key, "netlink")) {
1781 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1782 log_debug("Failed to parse socket value %s", value);
1785 LIST_FOREACH(port, p, s->ports)
1786 if (socket_address_is_netlink(&p->address, value+skip))
1791 close_nointr_nofail(p->fd);
1792 p->fd = fdset_remove(fds, fd);
1797 log_debug("Unknown serialization key '%s'", key);
1802 static UnitActiveState socket_active_state(Unit *u) {
1805 return state_translation_table[SOCKET(u)->state];
1808 static const char *socket_sub_state_to_string(Unit *u) {
1811 return socket_state_to_string(SOCKET(u)->state);
1814 static bool socket_check_gc(Unit *u) {
1815 Socket *s = SOCKET(u);
1819 return s->n_connections > 0;
1822 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1823 Socket *s = SOCKET(u);
1829 if (s->state != SOCKET_LISTENING)
1832 log_debug("Incoming traffic on %s", u->id);
1834 if (events != EPOLLIN) {
1836 if (events & EPOLLHUP)
1837 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1839 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1844 if (w->socket_accept) {
1847 if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1852 log_error("Failed to accept socket: %m");
1859 socket_apply_socket_options(s, cfd);
1862 socket_enter_running(s, cfd);
1866 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1869 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1870 Socket *s = SOCKET(u);
1876 if (pid != s->control_pid)
1881 if (is_clean_exit(code, status))
1883 else if (code == CLD_EXITED)
1884 f = SOCKET_FAILURE_EXIT_CODE;
1885 else if (code == CLD_KILLED)
1886 f = SOCKET_FAILURE_SIGNAL;
1887 else if (code == CLD_DUMPED)
1888 f = SOCKET_FAILURE_CORE_DUMP;
1890 assert_not_reached("Unknown code");
1892 if (s->control_command) {
1893 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1895 if (s->control_command->ignore)
1899 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1900 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1902 if (f != SOCKET_SUCCESS)
1905 if (s->control_command &&
1906 s->control_command->command_next &&
1907 f == SOCKET_SUCCESS) {
1909 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1912 s->control_command = NULL;
1913 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1915 /* No further commands for this step, so let's figure
1916 * out what to do next */
1918 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1922 case SOCKET_START_PRE:
1923 if (f == SOCKET_SUCCESS)
1924 socket_enter_start_post(s);
1926 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1929 case SOCKET_START_POST:
1930 if (f == SOCKET_SUCCESS)
1931 socket_enter_listening(s);
1933 socket_enter_stop_pre(s, f);
1936 case SOCKET_STOP_PRE:
1937 case SOCKET_STOP_PRE_SIGTERM:
1938 case SOCKET_STOP_PRE_SIGKILL:
1939 socket_enter_stop_post(s, f);
1942 case SOCKET_STOP_POST:
1943 case SOCKET_FINAL_SIGTERM:
1944 case SOCKET_FINAL_SIGKILL:
1945 socket_enter_dead(s, f);
1949 assert_not_reached("Uh, control process died at wrong time.");
1953 /* Notify clients about changed exit status */
1954 unit_add_to_dbus_queue(u);
1957 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1958 Socket *s = SOCKET(u);
1961 assert(elapsed == 1);
1962 assert(w == &s->timer_watch);
1966 case SOCKET_START_PRE:
1967 log_warning("%s starting timed out. Terminating.", u->id);
1968 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1971 case SOCKET_START_POST:
1972 log_warning("%s starting timed out. Stopping.", u->id);
1973 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1976 case SOCKET_STOP_PRE:
1977 log_warning("%s stopping timed out. Terminating.", u->id);
1978 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1981 case SOCKET_STOP_PRE_SIGTERM:
1982 if (s->exec_context.send_sigkill) {
1983 log_warning("%s stopping timed out. Killing.", u->id);
1984 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1986 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1987 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1991 case SOCKET_STOP_PRE_SIGKILL:
1992 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
1993 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1996 case SOCKET_STOP_POST:
1997 log_warning("%s stopping timed out (2). Terminating.", u->id);
1998 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2001 case SOCKET_FINAL_SIGTERM:
2002 if (s->exec_context.send_sigkill) {
2003 log_warning("%s stopping timed out (2). Killing.", u->id);
2004 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2006 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2007 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2011 case SOCKET_FINAL_SIGKILL:
2012 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2013 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2017 assert_not_reached("Timeout at wrong time.");
2021 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2030 /* Called from the service code for requesting our fds */
2033 LIST_FOREACH(port, p, s->ports)
2043 if (!(rfds = new(int, rn_fds)))
2047 LIST_FOREACH(port, p, s->ports)
2051 assert(k == rn_fds);
2059 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2062 /* The service is dead. Dang!
2064 * This is strictly for one-instance-for-all-connections
2067 if (s->state == SOCKET_RUNNING) {
2068 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2069 if (failed_permanent)
2070 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2072 socket_enter_listening(s);
2076 void socket_connection_unref(Socket *s) {
2079 /* The service is dead. Yay!
2081 * This is strictly for one-instance-per-connection
2084 assert(s->n_connections > 0);
2087 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2090 static void socket_reset_failed(Unit *u) {
2091 Socket *s = SOCKET(u);
2095 if (s->state == SOCKET_FAILED)
2096 socket_set_state(s, SOCKET_DEAD);
2098 s->result = SOCKET_SUCCESS;
2101 static int socket_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
2102 Socket *s = SOCKET(u);
2104 Set *pid_set = NULL;
2108 if (who == KILL_MAIN) {
2109 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2113 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2114 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2118 if (who == KILL_CONTROL || who == KILL_ALL)
2119 if (s->control_pid > 0)
2120 if (kill(s->control_pid, signo) < 0)
2123 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
2126 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
2129 /* Exclude the control pid from being killed via the cgroup */
2130 if (s->control_pid > 0)
2131 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
2136 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2138 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2149 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2150 [SOCKET_DEAD] = "dead",
2151 [SOCKET_START_PRE] = "start-pre",
2152 [SOCKET_START_POST] = "start-post",
2153 [SOCKET_LISTENING] = "listening",
2154 [SOCKET_RUNNING] = "running",
2155 [SOCKET_STOP_PRE] = "stop-pre",
2156 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2157 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2158 [SOCKET_STOP_POST] = "stop-post",
2159 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2160 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2161 [SOCKET_FAILED] = "failed"
2164 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2166 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2167 [SOCKET_EXEC_START_PRE] = "StartPre",
2168 [SOCKET_EXEC_START_POST] = "StartPost",
2169 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2170 [SOCKET_EXEC_STOP_POST] = "StopPost"
2173 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2175 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2176 [SOCKET_SUCCESS] = "success",
2177 [SOCKET_FAILURE_RESOURCES] = "resources",
2178 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2179 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2180 [SOCKET_FAILURE_SIGNAL] = "signal",
2181 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2182 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2185 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2187 const UnitVTable socket_vtable = {
2188 .suffix = ".socket",
2189 .object_size = sizeof(Socket),
2195 .init = socket_init,
2196 .done = socket_done,
2197 .load = socket_load,
2199 .kill = socket_kill,
2201 .coldplug = socket_coldplug,
2203 .dump = socket_dump,
2205 .start = socket_start,
2206 .stop = socket_stop,
2208 .serialize = socket_serialize,
2209 .deserialize_item = socket_deserialize_item,
2211 .active_state = socket_active_state,
2212 .sub_state_to_string = socket_sub_state_to_string,
2214 .check_gc = socket_check_gc,
2216 .fd_event = socket_fd_event,
2217 .sigchld_event = socket_sigchld_event,
2218 .timer_event = socket_timer_event,
2220 .reset_failed = socket_reset_failed,
2222 .bus_interface = "org.freedesktop.systemd1.Socket",
2223 .bus_message_handler = bus_socket_message_handler,
2224 .bus_invalidating_properties = bus_socket_invalidating_properties,
2226 .status_message_formats = {
2227 /*.starting_stopping = {
2228 [0] = "Starting socket %s...",
2229 [1] = "Stopping socket %s...",
2231 .finished_start_job = {
2232 [JOB_DONE] = "Listening on %s.",
2233 [JOB_FAILED] = "Failed to listen on %s.",
2234 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2235 [JOB_TIMEOUT] = "Timed out starting %s.",
2237 .finished_stop_job = {
2238 [JOB_DONE] = "Closed %s.",
2239 [JOB_FAILED] = "Failed stopping %s.",
2240 [JOB_TIMEOUT] = "Timed out stopping %s.",