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)->sysv_path) {
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(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,
1163 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1164 /* FIXME: we need to do something here */
1172 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1177 static void socket_enter_dead(Socket *s, SocketResult f) {
1180 if (f != SOCKET_SUCCESS)
1183 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1186 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1188 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1192 if (f != SOCKET_SUCCESS)
1195 socket_unwatch_control_pid(s);
1197 s->control_command_id = SOCKET_EXEC_STOP_POST;
1199 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1200 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1203 socket_set_state(s, SOCKET_STOP_POST);
1205 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1210 log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1211 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1214 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1216 Set *pid_set = NULL;
1217 bool wait_for_exit = false;
1221 if (f != SOCKET_SUCCESS)
1224 if (s->exec_context.kill_mode != KILL_NONE) {
1225 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1227 if (s->control_pid > 0) {
1228 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1230 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1232 wait_for_exit = true;
1235 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1237 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1242 /* Exclude the control pid from being killed via the cgroup */
1243 if (s->control_pid > 0)
1244 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1247 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1249 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1250 log_warning("Failed to kill control group: %s", strerror(-r));
1252 wait_for_exit = true;
1259 if (wait_for_exit) {
1260 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1263 socket_set_state(s, state);
1264 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1265 socket_enter_stop_post(s, SOCKET_SUCCESS);
1267 socket_enter_dead(s, SOCKET_SUCCESS);
1272 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1274 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1275 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1277 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1283 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1287 if (f != SOCKET_SUCCESS)
1290 socket_unwatch_control_pid(s);
1292 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1294 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1295 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1298 socket_set_state(s, SOCKET_STOP_PRE);
1300 socket_enter_stop_post(s, SOCKET_SUCCESS);
1305 log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1306 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1309 static void socket_enter_listening(Socket *s) {
1313 r = socket_watch_fds(s);
1315 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1319 socket_set_state(s, SOCKET_LISTENING);
1323 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1326 static void socket_enter_start_post(Socket *s) {
1330 r = socket_open_fds(s);
1332 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1336 socket_unwatch_control_pid(s);
1338 s->control_command_id = SOCKET_EXEC_START_POST;
1340 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1341 r = socket_spawn(s, s->control_command, &s->control_pid);
1343 log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1347 socket_set_state(s, SOCKET_START_POST);
1349 socket_enter_listening(s);
1354 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1357 static void socket_enter_start_pre(Socket *s) {
1361 socket_unwatch_control_pid(s);
1363 s->control_command_id = SOCKET_EXEC_START_PRE;
1365 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1366 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1369 socket_set_state(s, SOCKET_START_PRE);
1371 socket_enter_start_post(s);
1376 log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1377 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1380 static void socket_enter_running(Socket *s, int cfd) {
1385 dbus_error_init(&error);
1387 /* We don't take connections anymore if we are supposed to
1388 * shut down anyway */
1389 if (unit_pending_inactive(UNIT(s))) {
1390 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1393 close_nointr_nofail(cfd);
1395 /* Flush all sockets by closing and reopening them */
1396 socket_close_fds(s);
1398 r = socket_watch_fds(s);
1400 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1401 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1411 bool pending = false;
1413 /* If there's already a start pending don't bother to
1415 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1416 if (unit_pending_active(u)) {
1422 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1427 socket_set_state(s, SOCKET_RUNNING);
1429 char *prefix, *instance = NULL, *name;
1432 if (s->n_connections >= s->max_connections) {
1433 log_warning("Too many incoming connections (%u)", s->n_connections);
1434 close_nointr_nofail(cfd);
1438 r = socket_instantiate_service(s);
1442 r = instance_from_socket(cfd, s->n_accepted, &instance);
1447 /* ENOTCONN is legitimate if TCP RST was received.
1448 * This connection is over, but the socket unit lives on. */
1449 close_nointr_nofail(cfd);
1453 prefix = unit_name_to_prefix(UNIT(s)->id);
1460 name = unit_name_build(prefix, instance, ".service");
1469 r = unit_add_name(UNIT_DEREF(s->service), name);
1475 service = SERVICE(UNIT_DEREF(s->service));
1476 unit_ref_unset(&s->service);
1479 UNIT(service)->no_gc = false;
1481 unit_choose_id(UNIT(service), name);
1484 r = service_set_socket_fd(service, cfd, s);
1489 s->n_connections ++;
1491 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1495 /* Notify clients about changed counters */
1496 unit_add_to_dbus_queue(UNIT(s));
1502 log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1503 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1506 close_nointr_nofail(cfd);
1508 dbus_error_free(&error);
1511 static void socket_run_next(Socket *s) {
1515 assert(s->control_command);
1516 assert(s->control_command->command_next);
1518 socket_unwatch_control_pid(s);
1520 s->control_command = s->control_command->command_next;
1522 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1528 log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1530 if (s->state == SOCKET_START_POST)
1531 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1532 else if (s->state == SOCKET_STOP_POST)
1533 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1535 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1538 static int socket_start(Unit *u) {
1539 Socket *s = SOCKET(u);
1543 /* We cannot fulfill this request right now, try again later
1545 if (s->state == SOCKET_STOP_PRE ||
1546 s->state == SOCKET_STOP_PRE_SIGKILL ||
1547 s->state == SOCKET_STOP_PRE_SIGTERM ||
1548 s->state == SOCKET_STOP_POST ||
1549 s->state == SOCKET_FINAL_SIGTERM ||
1550 s->state == SOCKET_FINAL_SIGKILL)
1553 if (s->state == SOCKET_START_PRE ||
1554 s->state == SOCKET_START_POST)
1557 /* Cannot run this without the service being around */
1558 if (UNIT_DEREF(s->service)) {
1561 service = SERVICE(UNIT_DEREF(s->service));
1563 if (UNIT(service)->load_state != UNIT_LOADED) {
1564 log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1568 /* If the service is already active we cannot start the
1570 if (service->state != SERVICE_DEAD &&
1571 service->state != SERVICE_FAILED &&
1572 service->state != SERVICE_AUTO_RESTART) {
1573 log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1577 #ifdef HAVE_SYSV_COMPAT
1578 if (service->sysv_path) {
1579 log_error("Using SysV services for socket activation is not supported. Refusing.");
1585 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1587 s->result = SOCKET_SUCCESS;
1588 socket_enter_start_pre(s);
1592 static int socket_stop(Unit *u) {
1593 Socket *s = SOCKET(u);
1598 if (s->state == SOCKET_STOP_PRE ||
1599 s->state == SOCKET_STOP_PRE_SIGTERM ||
1600 s->state == SOCKET_STOP_PRE_SIGKILL ||
1601 s->state == SOCKET_STOP_POST ||
1602 s->state == SOCKET_FINAL_SIGTERM ||
1603 s->state == SOCKET_FINAL_SIGKILL)
1606 /* If there's already something running we go directly into
1608 if (s->state == SOCKET_START_PRE ||
1609 s->state == SOCKET_START_POST) {
1610 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1614 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1616 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1620 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1621 Socket *s = SOCKET(u);
1629 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1630 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1631 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1633 if (s->control_pid > 0)
1634 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1636 if (s->control_command_id >= 0)
1637 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1639 LIST_FOREACH(port, p, s->ports) {
1645 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1648 if (p->type == SOCKET_SOCKET) {
1651 if ((r = socket_address_print(&p->address, &t)) < 0)
1654 if (socket_address_family(&p->address) == AF_NETLINK)
1655 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1657 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1659 } else if (p->type == SOCKET_SPECIAL)
1660 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1662 assert(p->type == SOCKET_FIFO);
1663 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1670 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1671 Socket *s = SOCKET(u);
1678 if (streq(key, "state")) {
1681 if ((state = socket_state_from_string(value)) < 0)
1682 log_debug("Failed to parse state value %s", value);
1684 s->deserialized_state = state;
1685 } else if (streq(key, "result")) {
1688 f = socket_result_from_string(value);
1690 log_debug("Failed to parse result value %s", value);
1691 else if (f != SOCKET_SUCCESS)
1694 } else if (streq(key, "n-accepted")) {
1697 if (safe_atou(value, &k) < 0)
1698 log_debug("Failed to parse n-accepted value %s", value);
1701 } else if (streq(key, "control-pid")) {
1704 if (parse_pid(value, &pid) < 0)
1705 log_debug("Failed to parse control-pid value %s", value);
1707 s->control_pid = pid;
1708 } else if (streq(key, "control-command")) {
1709 SocketExecCommand id;
1711 if ((id = socket_exec_command_from_string(value)) < 0)
1712 log_debug("Failed to parse exec-command value %s", value);
1714 s->control_command_id = id;
1715 s->control_command = s->exec_command[id];
1717 } else if (streq(key, "fifo")) {
1721 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1722 log_debug("Failed to parse fifo value %s", value);
1725 LIST_FOREACH(port, p, s->ports)
1726 if (p->type == SOCKET_FIFO &&
1727 streq_ptr(p->path, value+skip))
1732 close_nointr_nofail(p->fd);
1733 p->fd = fdset_remove(fds, fd);
1737 } else if (streq(key, "special")) {
1741 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1742 log_debug("Failed to parse special value %s", value);
1745 LIST_FOREACH(port, p, s->ports)
1746 if (p->type == SOCKET_SPECIAL &&
1747 streq_ptr(p->path, value+skip))
1752 close_nointr_nofail(p->fd);
1753 p->fd = fdset_remove(fds, fd);
1757 } else if (streq(key, "socket")) {
1758 int fd, type, skip = 0;
1761 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1762 log_debug("Failed to parse socket value %s", value);
1765 LIST_FOREACH(port, p, s->ports)
1766 if (socket_address_is(&p->address, value+skip, type))
1771 close_nointr_nofail(p->fd);
1772 p->fd = fdset_remove(fds, fd);
1776 } else if (streq(key, "netlink")) {
1780 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1781 log_debug("Failed to parse socket value %s", value);
1784 LIST_FOREACH(port, p, s->ports)
1785 if (socket_address_is_netlink(&p->address, value+skip))
1790 close_nointr_nofail(p->fd);
1791 p->fd = fdset_remove(fds, fd);
1796 log_debug("Unknown serialization key '%s'", key);
1801 static UnitActiveState socket_active_state(Unit *u) {
1804 return state_translation_table[SOCKET(u)->state];
1807 static const char *socket_sub_state_to_string(Unit *u) {
1810 return socket_state_to_string(SOCKET(u)->state);
1813 static bool socket_check_gc(Unit *u) {
1814 Socket *s = SOCKET(u);
1818 return s->n_connections > 0;
1821 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1822 Socket *s = SOCKET(u);
1828 if (s->state != SOCKET_LISTENING)
1831 log_debug("Incoming traffic on %s", u->id);
1833 if (events != EPOLLIN) {
1835 if (events & EPOLLHUP)
1836 log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1838 log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1843 if (w->socket_accept) {
1846 if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1851 log_error("Failed to accept socket: %m");
1858 socket_apply_socket_options(s, cfd);
1861 socket_enter_running(s, cfd);
1865 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1868 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1869 Socket *s = SOCKET(u);
1875 if (pid != s->control_pid)
1880 if (is_clean_exit(code, status))
1882 else if (code == CLD_EXITED)
1883 f = SOCKET_FAILURE_EXIT_CODE;
1884 else if (code == CLD_KILLED)
1885 f = SOCKET_FAILURE_SIGNAL;
1886 else if (code == CLD_DUMPED)
1887 f = SOCKET_FAILURE_CORE_DUMP;
1889 assert_not_reached("Unknown code");
1891 if (s->control_command) {
1892 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1894 if (s->control_command->ignore)
1898 log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1899 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1901 if (f != SOCKET_SUCCESS)
1904 if (s->control_command &&
1905 s->control_command->command_next &&
1906 f == SOCKET_SUCCESS) {
1908 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1911 s->control_command = NULL;
1912 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1914 /* No further commands for this step, so let's figure
1915 * out what to do next */
1917 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1921 case SOCKET_START_PRE:
1922 if (f == SOCKET_SUCCESS)
1923 socket_enter_start_post(s);
1925 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1928 case SOCKET_START_POST:
1929 if (f == SOCKET_SUCCESS)
1930 socket_enter_listening(s);
1932 socket_enter_stop_pre(s, f);
1935 case SOCKET_STOP_PRE:
1936 case SOCKET_STOP_PRE_SIGTERM:
1937 case SOCKET_STOP_PRE_SIGKILL:
1938 socket_enter_stop_post(s, f);
1941 case SOCKET_STOP_POST:
1942 case SOCKET_FINAL_SIGTERM:
1943 case SOCKET_FINAL_SIGKILL:
1944 socket_enter_dead(s, f);
1948 assert_not_reached("Uh, control process died at wrong time.");
1952 /* Notify clients about changed exit status */
1953 unit_add_to_dbus_queue(u);
1956 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1957 Socket *s = SOCKET(u);
1960 assert(elapsed == 1);
1961 assert(w == &s->timer_watch);
1965 case SOCKET_START_PRE:
1966 log_warning("%s starting timed out. Terminating.", u->id);
1967 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1970 case SOCKET_START_POST:
1971 log_warning("%s starting timed out. Stopping.", u->id);
1972 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1975 case SOCKET_STOP_PRE:
1976 log_warning("%s stopping timed out. Terminating.", u->id);
1977 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1980 case SOCKET_STOP_PRE_SIGTERM:
1981 if (s->exec_context.send_sigkill) {
1982 log_warning("%s stopping timed out. Killing.", u->id);
1983 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1985 log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1986 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1990 case SOCKET_STOP_PRE_SIGKILL:
1991 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
1992 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1995 case SOCKET_STOP_POST:
1996 log_warning("%s stopping timed out (2). Terminating.", u->id);
1997 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2000 case SOCKET_FINAL_SIGTERM:
2001 if (s->exec_context.send_sigkill) {
2002 log_warning("%s stopping timed out (2). Killing.", u->id);
2003 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2005 log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2006 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2010 case SOCKET_FINAL_SIGKILL:
2011 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2012 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2016 assert_not_reached("Timeout at wrong time.");
2020 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2029 /* Called from the service code for requesting our fds */
2032 LIST_FOREACH(port, p, s->ports)
2042 if (!(rfds = new(int, rn_fds)))
2046 LIST_FOREACH(port, p, s->ports)
2050 assert(k == rn_fds);
2058 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2061 /* The service is dead. Dang!
2063 * This is strictly for one-instance-for-all-connections
2066 if (s->state == SOCKET_RUNNING) {
2067 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2068 if (failed_permanent)
2069 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2071 socket_enter_listening(s);
2075 void socket_connection_unref(Socket *s) {
2078 /* The service is dead. Yay!
2080 * This is strictly for one-instance-per-connection
2083 assert(s->n_connections > 0);
2086 log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2089 static void socket_reset_failed(Unit *u) {
2090 Socket *s = SOCKET(u);
2094 if (s->state == SOCKET_FAILED)
2095 socket_set_state(s, SOCKET_DEAD);
2097 s->result = SOCKET_SUCCESS;
2100 static int socket_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
2101 Socket *s = SOCKET(u);
2103 Set *pid_set = NULL;
2107 if (who == KILL_MAIN) {
2108 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2112 if (s->control_pid <= 0 && who == KILL_CONTROL) {
2113 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2117 if (who == KILL_CONTROL || who == KILL_ALL)
2118 if (s->control_pid > 0)
2119 if (kill(s->control_pid, signo) < 0)
2122 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
2125 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
2128 /* Exclude the control pid from being killed via the cgroup */
2129 if (s->control_pid > 0)
2130 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
2135 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2137 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2148 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2149 [SOCKET_DEAD] = "dead",
2150 [SOCKET_START_PRE] = "start-pre",
2151 [SOCKET_START_POST] = "start-post",
2152 [SOCKET_LISTENING] = "listening",
2153 [SOCKET_RUNNING] = "running",
2154 [SOCKET_STOP_PRE] = "stop-pre",
2155 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2156 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2157 [SOCKET_STOP_POST] = "stop-post",
2158 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2159 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2160 [SOCKET_FAILED] = "failed"
2163 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2165 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2166 [SOCKET_EXEC_START_PRE] = "StartPre",
2167 [SOCKET_EXEC_START_POST] = "StartPost",
2168 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2169 [SOCKET_EXEC_STOP_POST] = "StopPost"
2172 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2174 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2175 [SOCKET_SUCCESS] = "success",
2176 [SOCKET_FAILURE_RESOURCES] = "resources",
2177 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2178 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2179 [SOCKET_FAILURE_SIGNAL] = "signal",
2180 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2181 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2184 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2186 const UnitVTable socket_vtable = {
2187 .suffix = ".socket",
2188 .object_size = sizeof(Socket),
2194 .init = socket_init,
2195 .done = socket_done,
2196 .load = socket_load,
2198 .kill = socket_kill,
2200 .coldplug = socket_coldplug,
2202 .dump = socket_dump,
2204 .start = socket_start,
2205 .stop = socket_stop,
2207 .serialize = socket_serialize,
2208 .deserialize_item = socket_deserialize_item,
2210 .active_state = socket_active_state,
2211 .sub_state_to_string = socket_sub_state_to_string,
2213 .check_gc = socket_check_gc,
2215 .fd_event = socket_fd_event,
2216 .sigchld_event = socket_sigchld_event,
2217 .timer_event = socket_timer_event,
2219 .reset_failed = socket_reset_failed,
2221 .bus_interface = "org.freedesktop.systemd1.Socket",
2222 .bus_message_handler = bus_socket_message_handler,
2223 .bus_invalidating_properties = bus_socket_invalidating_properties,
2225 .status_message_formats = {
2226 /*.starting_stopping = {
2227 [0] = "Starting socket %s...",
2228 [1] = "Stopping socket %s...",
2230 .finished_start_job = {
2231 [JOB_DONE] = "Listening on %s.",
2232 [JOB_FAILED] = "Failed to listen on %s.",
2233 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2234 [JOB_TIMEOUT] = "Timed out starting %s.",
2236 .finished_stop_job = {
2237 [JOB_DONE] = "Closed %s.",
2238 [JOB_FAILED] = "Failed stopping %s.",
2239 [JOB_TIMEOUT] = "Timed out stopping %s.",