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 <arpa/inet.h>
26 #include <netinet/tcp.h>
28 #include <sys/epoll.h>
34 #include "bus-error.h"
37 #include "dbus-socket.h"
39 #include "exit-status.h"
40 #include "formats-util.h"
45 #include "path-util.h"
46 #include "selinux-util.h"
47 #include "signal-util.h"
48 #include "smack-util.h"
52 #include "unit-name.h"
53 #include "unit-printf.h"
56 static const UnitActiveState state_translation_table
[_SOCKET_STATE_MAX
] = {
57 [SOCKET_DEAD
] = UNIT_INACTIVE
,
58 [SOCKET_START_PRE
] = UNIT_ACTIVATING
,
59 [SOCKET_START_CHOWN
] = UNIT_ACTIVATING
,
60 [SOCKET_START_POST
] = UNIT_ACTIVATING
,
61 [SOCKET_LISTENING
] = UNIT_ACTIVE
,
62 [SOCKET_RUNNING
] = UNIT_ACTIVE
,
63 [SOCKET_STOP_PRE
] = UNIT_DEACTIVATING
,
64 [SOCKET_STOP_PRE_SIGTERM
] = UNIT_DEACTIVATING
,
65 [SOCKET_STOP_PRE_SIGKILL
] = UNIT_DEACTIVATING
,
66 [SOCKET_STOP_POST
] = UNIT_DEACTIVATING
,
67 [SOCKET_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
68 [SOCKET_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
69 [SOCKET_FAILED
] = UNIT_FAILED
72 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
73 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
75 static void socket_init(Unit
*u
) {
76 Socket
*s
= SOCKET(u
);
79 assert(u
->load_state
== UNIT_STUB
);
81 s
->backlog
= SOMAXCONN
;
82 s
->timeout_usec
= u
->manager
->default_timeout_start_usec
;
83 s
->directory_mode
= 0755;
84 s
->socket_mode
= 0666;
86 s
->max_connections
= 64;
93 s
->exec_context
.std_output
= u
->manager
->default_std_output
;
94 s
->exec_context
.std_error
= u
->manager
->default_std_error
;
96 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
99 static void socket_unwatch_control_pid(Socket
*s
) {
102 if (s
->control_pid
<= 0)
105 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
109 static void socket_cleanup_fd_list(SocketPort
*p
) {
110 int k
= p
->n_auxiliary_fds
;
113 safe_close(p
->auxiliary_fds
[k
]);
115 p
->auxiliary_fds
= mfree(p
->auxiliary_fds
);
116 p
->n_auxiliary_fds
= 0;
119 void socket_free_ports(Socket
*s
) {
124 while ((p
= s
->ports
)) {
125 LIST_REMOVE(port
, s
->ports
, p
);
127 sd_event_source_unref(p
->event_source
);
129 socket_cleanup_fd_list(p
);
136 static void socket_done(Unit
*u
) {
137 Socket
*s
= SOCKET(u
);
141 socket_free_ports(s
);
143 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
144 exec_command_free_array(s
->exec_command
, _SOCKET_EXEC_COMMAND_MAX
);
145 s
->control_command
= NULL
;
147 socket_unwatch_control_pid(s
);
149 unit_ref_unset(&s
->service
);
151 s
->tcp_congestion
= mfree(s
->tcp_congestion
);
152 s
->bind_to_device
= mfree(s
->bind_to_device
);
155 free(s
->smack_ip_in
);
156 free(s
->smack_ip_out
);
158 strv_free(s
->symlinks
);
163 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
166 static int socket_arm_timer(Socket
*s
) {
171 if (s
->timeout_usec
<= 0) {
172 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
176 if (s
->timer_event_source
) {
177 r
= sd_event_source_set_time(s
->timer_event_source
, now(CLOCK_MONOTONIC
) + s
->timeout_usec
);
181 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
184 r
= sd_event_add_time(
185 UNIT(s
)->manager
->event
,
186 &s
->timer_event_source
,
188 now(CLOCK_MONOTONIC
) + s
->timeout_usec
, 0,
189 socket_dispatch_timer
, s
);
193 (void) sd_event_source_set_description(s
->timer_event_source
, "socket-timer");
198 int socket_instantiate_service(Socket
*s
) {
199 _cleanup_free_
char *prefix
= NULL
, *name
= NULL
;
205 /* This fills in s->service if it isn't filled in yet. For
206 * Accept=yes sockets we create the next connection service
207 * here. For Accept=no this is mostly a NOP since the service
208 * is figured out at load time anyway. */
210 if (UNIT_DEREF(s
->service
))
216 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
220 if (asprintf(&name
, "%s@%u.service", prefix
, s
->n_accepted
) < 0)
223 r
= manager_load_unit(UNIT(s
)->manager
, name
, NULL
, NULL
, &u
);
228 unit_ref_set(&s
->service
, u
);
230 return unit_add_two_dependencies(UNIT(s
), UNIT_BEFORE
, UNIT_TRIGGERS
, u
, false);
233 static bool have_non_accept_socket(Socket
*s
) {
241 LIST_FOREACH(port
, p
, s
->ports
) {
243 if (p
->type
!= SOCKET_SOCKET
)
246 if (!socket_address_can_accept(&p
->address
))
253 static int socket_add_mount_links(Socket
*s
) {
259 LIST_FOREACH(port
, p
, s
->ports
) {
260 const char *path
= NULL
;
262 if (p
->type
== SOCKET_SOCKET
)
263 path
= socket_address_get_path(&p
->address
);
264 else if (IN_SET(p
->type
, SOCKET_FIFO
, SOCKET_SPECIAL
, SOCKET_USB_FUNCTION
))
270 r
= unit_require_mounts_for(UNIT(s
), path
);
278 static int socket_add_device_link(Socket
*s
) {
283 if (!s
->bind_to_device
|| streq(s
->bind_to_device
, "lo"))
286 t
= strjoina("/sys/subsystem/net/devices/", s
->bind_to_device
);
287 return unit_add_node_link(UNIT(s
), t
, false);
290 static int socket_add_default_dependencies(Socket
*s
) {
294 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_BEFORE
, SPECIAL_SOCKETS_TARGET
, NULL
, true);
298 if (UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
) {
299 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true);
304 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
307 _pure_
static bool socket_has_exec(Socket
*s
) {
311 for (i
= 0; i
< _SOCKET_EXEC_COMMAND_MAX
; i
++)
312 if (s
->exec_command
[i
])
318 static int socket_add_extras(Socket
*s
) {
324 if (have_non_accept_socket(s
)) {
326 if (!UNIT_DEREF(s
->service
)) {
329 r
= unit_load_related_unit(u
, ".service", &x
);
333 unit_ref_set(&s
->service
, x
);
336 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT_DEREF(s
->service
), true);
341 r
= socket_add_mount_links(s
);
345 r
= socket_add_device_link(s
);
349 r
= unit_patch_contexts(u
);
353 if (socket_has_exec(s
)) {
354 r
= unit_add_exec_dependencies(u
, &s
->exec_context
);
358 r
= unit_set_default_slice(u
);
363 if (u
->default_dependencies
) {
364 r
= socket_add_default_dependencies(s
);
372 static const char *socket_find_symlink_target(Socket
*s
) {
373 const char *found
= NULL
;
376 LIST_FOREACH(port
, p
, s
->ports
) {
377 const char *f
= NULL
;
386 if (p
->address
.sockaddr
.un
.sun_path
[0] != 0)
387 f
= p
->address
.sockaddr
.un
.sun_path
;
405 static int socket_verify(Socket
*s
) {
408 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
412 log_unit_error(UNIT(s
), "Unit lacks Listen setting. Refusing.");
416 if (s
->accept
&& have_non_accept_socket(s
)) {
417 log_unit_error(UNIT(s
), "Unit configured for accepting sockets, but sockets are non-accepting. Refusing.");
421 if (s
->accept
&& s
->max_connections
<= 0) {
422 log_unit_error(UNIT(s
), "MaxConnection= setting too small. Refusing.");
426 if (s
->accept
&& UNIT_DEREF(s
->service
)) {
427 log_unit_error(UNIT(s
), "Explicit service configuration for accepting socket units not supported. Refusing.");
431 if (s
->exec_context
.pam_name
&& s
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
432 log_unit_error(UNIT(s
), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing.");
436 if (!strv_isempty(s
->symlinks
) && !socket_find_symlink_target(s
)) {
437 log_unit_error(UNIT(s
), "Unit has symlinks set but none or more than one node in the file system. Refusing.");
444 static int socket_load(Unit
*u
) {
445 Socket
*s
= SOCKET(u
);
449 assert(u
->load_state
== UNIT_STUB
);
451 r
= unit_load_fragment_and_dropin(u
);
455 if (u
->load_state
== UNIT_LOADED
) {
456 /* This is a new unit? Then let's add in some extras */
457 r
= socket_add_extras(s
);
462 return socket_verify(s
);
465 _const_
static const char* listen_lookup(int family
, int type
) {
467 if (family
== AF_NETLINK
)
468 return "ListenNetlink";
470 if (type
== SOCK_STREAM
)
471 return "ListenStream";
472 else if (type
== SOCK_DGRAM
)
473 return "ListenDatagram";
474 else if (type
== SOCK_SEQPACKET
)
475 return "ListenSequentialPacket";
477 assert_not_reached("Unknown socket type");
481 static void socket_dump(Unit
*u
, FILE *f
, const char *prefix
) {
482 char time_string
[FORMAT_TIMESPAN_MAX
];
484 Socket
*s
= SOCKET(u
);
491 prefix
= strempty(prefix
);
492 prefix2
= strjoina(prefix
, "\t");
495 "%sSocket State: %s\n"
497 "%sBindIPv6Only: %s\n"
499 "%sSocketMode: %04o\n"
500 "%sDirectoryMode: %04o\n"
504 "%sTransparent: %s\n"
506 "%sPassCredentials: %s\n"
507 "%sPassSecurity: %s\n"
508 "%sTCPCongestion: %s\n"
509 "%sRemoveOnStop: %s\n"
512 "%sSELinuxContextFromNet: %s\n",
513 prefix
, socket_state_to_string(s
->state
),
514 prefix
, socket_result_to_string(s
->result
),
515 prefix
, socket_address_bind_ipv6_only_to_string(s
->bind_ipv6_only
),
517 prefix
, s
->socket_mode
,
518 prefix
, s
->directory_mode
,
519 prefix
, yes_no(s
->keep_alive
),
520 prefix
, yes_no(s
->no_delay
),
521 prefix
, yes_no(s
->free_bind
),
522 prefix
, yes_no(s
->transparent
),
523 prefix
, yes_no(s
->broadcast
),
524 prefix
, yes_no(s
->pass_cred
),
525 prefix
, yes_no(s
->pass_sec
),
526 prefix
, strna(s
->tcp_congestion
),
527 prefix
, yes_no(s
->remove_on_stop
),
528 prefix
, yes_no(s
->writable
),
529 prefix
, socket_fdname(s
),
530 prefix
, yes_no(s
->selinux_context_from_net
));
532 if (s
->control_pid
> 0)
534 "%sControl PID: "PID_FMT
"\n",
535 prefix
, s
->control_pid
);
537 if (s
->bind_to_device
)
539 "%sBindToDevice: %s\n",
540 prefix
, s
->bind_to_device
);
545 "%sNConnections: %u\n"
546 "%sMaxConnections: %u\n",
547 prefix
, s
->n_accepted
,
548 prefix
, s
->n_connections
,
549 prefix
, s
->max_connections
);
551 if (s
->priority
>= 0)
554 prefix
, s
->priority
);
556 if (s
->receive_buffer
> 0)
558 "%sReceiveBuffer: %zu\n",
559 prefix
, s
->receive_buffer
);
561 if (s
->send_buffer
> 0)
563 "%sSendBuffer: %zu\n",
564 prefix
, s
->send_buffer
);
576 if (s
->pipe_size
> 0)
579 prefix
, s
->pipe_size
);
586 if (s
->mq_maxmsg
> 0)
588 "%sMessageQueueMaxMessages: %li\n",
589 prefix
, s
->mq_maxmsg
);
591 if (s
->mq_msgsize
> 0)
593 "%sMessageQueueMessageSize: %li\n",
594 prefix
, s
->mq_msgsize
);
599 prefix
, yes_no(s
->reuse_port
));
603 "%sSmackLabel: %s\n",
608 "%sSmackLabelIPIn: %s\n",
609 prefix
, s
->smack_ip_in
);
613 "%sSmackLabelIPOut: %s\n",
614 prefix
, s
->smack_ip_out
);
616 if (!isempty(s
->user
) || !isempty(s
->group
))
619 "%sOwnerGroup: %s\n",
620 prefix
, strna(s
->user
),
621 prefix
, strna(s
->group
));
623 if (s
->keep_alive_time
> 0)
625 "%sKeepAliveTimeSec: %s\n",
626 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->keep_alive_time
, USEC_PER_SEC
));
628 if (s
->keep_alive_interval
)
630 "%sKeepAliveIntervalSec: %s\n",
631 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->keep_alive_interval
, USEC_PER_SEC
));
633 if (s
->keep_alive_cnt
)
635 "%sKeepAliveProbes: %u\n",
636 prefix
, s
->keep_alive_cnt
);
640 "%sDeferAcceptSec: %s\n",
641 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->defer_accept
, USEC_PER_SEC
));
643 LIST_FOREACH(port
, p
, s
->ports
) {
645 if (p
->type
== SOCKET_SOCKET
) {
650 r
= socket_address_print(&p
->address
, &k
);
656 fprintf(f
, "%s%s: %s\n", prefix
, listen_lookup(socket_address_family(&p
->address
), p
->address
.type
), t
);
658 } else if (p
->type
== SOCKET_SPECIAL
)
659 fprintf(f
, "%sListenSpecial: %s\n", prefix
, p
->path
);
660 else if (p
->type
== SOCKET_USB_FUNCTION
)
661 fprintf(f
, "%sListenUSBFunction: %s\n", prefix
, p
->path
);
662 else if (p
->type
== SOCKET_MQUEUE
)
663 fprintf(f
, "%sListenMessageQueue: %s\n", prefix
, p
->path
);
665 fprintf(f
, "%sListenFIFO: %s\n", prefix
, p
->path
);
668 exec_context_dump(&s
->exec_context
, f
, prefix
);
669 kill_context_dump(&s
->kill_context
, f
, prefix
);
671 for (c
= 0; c
< _SOCKET_EXEC_COMMAND_MAX
; c
++) {
672 if (!s
->exec_command
[c
])
675 fprintf(f
, "%s-> %s:\n",
676 prefix
, socket_exec_command_to_string(c
));
678 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
682 static int instance_from_socket(int fd
, unsigned nr
, char **instance
) {
685 union sockaddr_union local
, remote
;
691 if (getsockname(fd
, &local
.sa
, &l
) < 0)
695 if (getpeername(fd
, &remote
.sa
, &l
) < 0)
698 switch (local
.sa
.sa_family
) {
702 a
= ntohl(local
.in
.sin_addr
.s_addr
),
703 b
= ntohl(remote
.in
.sin_addr
.s_addr
);
706 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
708 a
>> 24, (a
>> 16) & 0xFF, (a
>> 8) & 0xFF, a
& 0xFF,
709 ntohs(local
.in
.sin_port
),
710 b
>> 24, (b
>> 16) & 0xFF, (b
>> 8) & 0xFF, b
& 0xFF,
711 ntohs(remote
.in
.sin_port
)) < 0)
718 static const unsigned char ipv4_prefix
[] = {
719 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
722 if (memcmp(&local
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0 &&
723 memcmp(&remote
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0) {
725 *a
= local
.in6
.sin6_addr
.s6_addr
+12,
726 *b
= remote
.in6
.sin6_addr
.s6_addr
+12;
729 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
731 a
[0], a
[1], a
[2], a
[3],
732 ntohs(local
.in6
.sin6_port
),
733 b
[0], b
[1], b
[2], b
[3],
734 ntohs(remote
.in6
.sin6_port
)) < 0)
737 char a
[INET6_ADDRSTRLEN
], b
[INET6_ADDRSTRLEN
];
742 inet_ntop(AF_INET6
, &local
.in6
.sin6_addr
, a
, sizeof(a
)),
743 ntohs(local
.in6
.sin6_port
),
744 inet_ntop(AF_INET6
, &remote
.in6
.sin6_addr
, b
, sizeof(b
)),
745 ntohs(remote
.in6
.sin6_port
)) < 0)
756 k
= getpeercred(fd
, &ucred
);
759 "%u-"PID_FMT
"-"UID_FMT
,
760 nr
, ucred
.pid
, ucred
.uid
) < 0)
762 } else if (k
== -ENODATA
) {
763 /* This handles the case where somebody is
764 * connecting from another pid/uid namespace
765 * (e.g. from outside of our container). */
777 assert_not_reached("Unhandled socket type.");
784 static void socket_close_fds(Socket
*s
) {
790 LIST_FOREACH(port
, p
, s
->ports
) {
792 p
->event_source
= sd_event_source_unref(p
->event_source
);
797 p
->fd
= safe_close(p
->fd
);
798 socket_cleanup_fd_list(p
);
800 /* One little note: we should normally not delete any
801 * sockets in the file system here! After all some
802 * other process we spawned might still have a
803 * reference of this fd and wants to continue to use
804 * it. Therefore we delete sockets in the file system
805 * before we create a new one, not after we stopped
808 if (s
->remove_on_stop
) {
820 socket_address_unlink(&p
->address
);
829 if (s
->remove_on_stop
)
830 STRV_FOREACH(i
, s
->symlinks
)
834 static void socket_apply_socket_options(Socket
*s
, int fd
) {
841 int b
= s
->keep_alive
;
842 if (setsockopt(fd
, SOL_SOCKET
, SO_KEEPALIVE
, &b
, sizeof(b
)) < 0)
843 log_unit_warning_errno(UNIT(s
), errno
, "SO_KEEPALIVE failed: %m");
846 if (s
->keep_alive_time
) {
847 int value
= s
->keep_alive_time
/ USEC_PER_SEC
;
848 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPIDLE
, &value
, sizeof(value
)) < 0)
849 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPIDLE failed: %m");
852 if (s
->keep_alive_interval
) {
853 int value
= s
->keep_alive_interval
/ USEC_PER_SEC
;
854 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPINTVL
, &value
, sizeof(value
)) < 0)
855 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPINTVL failed: %m");
858 if (s
->keep_alive_cnt
) {
859 int value
= s
->keep_alive_cnt
;
860 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPCNT
, &value
, sizeof(value
)) < 0)
861 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPCNT failed: %m");
864 if (s
->defer_accept
) {
865 int value
= s
->defer_accept
/ USEC_PER_SEC
;
866 if (setsockopt(fd
, SOL_TCP
, TCP_DEFER_ACCEPT
, &value
, sizeof(value
)) < 0)
867 log_unit_warning_errno(UNIT(s
), errno
, "TCP_DEFER_ACCEPT failed: %m");
872 if (setsockopt(fd
, SOL_TCP
, TCP_NODELAY
, &b
, sizeof(b
)) < 0)
873 log_unit_warning_errno(UNIT(s
), errno
, "TCP_NODELAY failed: %m");
878 if (setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
, &one
, sizeof(one
)) < 0)
879 log_unit_warning_errno(UNIT(s
), errno
, "SO_BROADCAST failed: %m");
884 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSCRED
, &one
, sizeof(one
)) < 0)
885 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSCRED failed: %m");
890 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSSEC
, &one
, sizeof(one
)) < 0)
891 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSSEC failed: %m");
894 if (s
->priority
>= 0)
895 if (setsockopt(fd
, SOL_SOCKET
, SO_PRIORITY
, &s
->priority
, sizeof(s
->priority
)) < 0)
896 log_unit_warning_errno(UNIT(s
), errno
, "SO_PRIORITY failed: %m");
898 if (s
->receive_buffer
> 0) {
899 int value
= (int) s
->receive_buffer
;
901 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
903 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUFFORCE
, &value
, sizeof(value
)) < 0)
904 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &value
, sizeof(value
)) < 0)
905 log_unit_warning_errno(UNIT(s
), errno
, "SO_RCVBUF failed: %m");
908 if (s
->send_buffer
> 0) {
909 int value
= (int) s
->send_buffer
;
910 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUFFORCE
, &value
, sizeof(value
)) < 0)
911 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, &value
, sizeof(value
)) < 0)
912 log_unit_warning_errno(UNIT(s
), errno
, "SO_SNDBUF failed: %m");
916 if (setsockopt(fd
, SOL_SOCKET
, SO_MARK
, &s
->mark
, sizeof(s
->mark
)) < 0)
917 log_unit_warning_errno(UNIT(s
), errno
, "SO_MARK failed: %m");
920 if (setsockopt(fd
, IPPROTO_IP
, IP_TOS
, &s
->ip_tos
, sizeof(s
->ip_tos
)) < 0)
921 log_unit_warning_errno(UNIT(s
), errno
, "IP_TOS failed: %m");
923 if (s
->ip_ttl
>= 0) {
926 r
= setsockopt(fd
, IPPROTO_IP
, IP_TTL
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
928 if (socket_ipv6_is_supported())
929 x
= setsockopt(fd
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
932 errno
= EAFNOSUPPORT
;
936 log_unit_warning_errno(UNIT(s
), errno
, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
939 if (s
->tcp_congestion
)
940 if (setsockopt(fd
, SOL_TCP
, TCP_CONGESTION
, s
->tcp_congestion
, strlen(s
->tcp_congestion
)+1) < 0)
941 log_unit_warning_errno(UNIT(s
), errno
, "TCP_CONGESTION failed: %m");
943 if (s
->smack_ip_in
) {
944 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPIN
, s
->smack_ip_in
);
946 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_in_fd: %m");
949 if (s
->smack_ip_out
) {
950 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPOUT
, s
->smack_ip_out
);
952 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_out_fd: %m");
956 static void socket_apply_fifo_options(Socket
*s
, int fd
) {
962 if (s
->pipe_size
> 0)
963 if (fcntl(fd
, F_SETPIPE_SZ
, s
->pipe_size
) < 0)
964 log_unit_warning_errno(UNIT(s
), errno
, "Setting pipe size failed, ignoring: %m");
967 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_ACCESS
, s
->smack
);
969 log_unit_error_errno(UNIT(s
), r
, "SMACK relabelling failed, ignoring: %m");
973 static int fifo_address_create(
975 mode_t directory_mode
,
976 mode_t socket_mode
) {
978 _cleanup_close_
int fd
= -1;
985 mkdir_parents_label(path
, directory_mode
);
987 r
= mac_selinux_create_file_prepare(path
, S_IFIFO
);
991 /* Enforce the right access mode for the fifo */
992 old_mask
= umask(~ socket_mode
);
994 /* Include the original umask in our mask */
995 (void) umask(~socket_mode
| old_mask
);
997 r
= mkfifo(path
, socket_mode
);
998 (void) umask(old_mask
);
1000 if (r
< 0 && errno
!= EEXIST
) {
1005 fd
= open(path
, O_RDWR
| O_CLOEXEC
| O_NOCTTY
| O_NONBLOCK
| O_NOFOLLOW
);
1011 mac_selinux_create_file_clear();
1013 if (fstat(fd
, &st
) < 0) {
1018 if (!S_ISFIFO(st
.st_mode
) ||
1019 (st
.st_mode
& 0777) != (socket_mode
& ~old_mask
) ||
1020 st
.st_uid
!= getuid() ||
1021 st
.st_gid
!= getgid()) {
1032 mac_selinux_create_file_clear();
1036 static int special_address_create(const char *path
, bool writable
) {
1037 _cleanup_close_
int fd
= -1;
1043 fd
= open(path
, (writable
? O_RDWR
: O_RDONLY
)|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1047 if (fstat(fd
, &st
) < 0)
1050 /* Check whether this is a /proc, /sys or /dev file or char device */
1051 if (!S_ISREG(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
1060 static int usbffs_address_create(const char *path
) {
1061 _cleanup_close_
int fd
= -1;
1067 fd
= open(path
, O_RDWR
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1071 if (fstat(fd
, &st
) < 0)
1074 /* Check whether this is a regular file (ffs endpoint)*/
1075 if (!S_ISREG(st
.st_mode
))
1084 static int mq_address_create(
1090 _cleanup_close_
int fd
= -1;
1093 struct mq_attr _attr
, *attr
= NULL
;
1098 if (maxmsg
> 0 && msgsize
> 0) {
1099 _attr
= (struct mq_attr
) {
1100 .mq_flags
= O_NONBLOCK
,
1101 .mq_maxmsg
= maxmsg
,
1102 .mq_msgsize
= msgsize
,
1107 /* Enforce the right access mode for the mq */
1108 old_mask
= umask(~ mq_mode
);
1110 /* Include the original umask in our mask */
1111 (void) umask(~mq_mode
| old_mask
);
1112 fd
= mq_open(path
, O_RDONLY
|O_CLOEXEC
|O_NONBLOCK
|O_CREAT
, mq_mode
, attr
);
1113 (void) umask(old_mask
);
1118 if (fstat(fd
, &st
) < 0)
1121 if ((st
.st_mode
& 0777) != (mq_mode
& ~old_mask
) ||
1122 st
.st_uid
!= getuid() ||
1123 st
.st_gid
!= getgid())
1132 static int socket_symlink(Socket
*s
) {
1138 p
= socket_find_symlink_target(s
);
1142 STRV_FOREACH(i
, s
->symlinks
)
1143 symlink_label(p
, *i
);
1148 static int usbffs_write_descs(int fd
, Service
*s
) {
1151 if (!s
->usb_function_descriptors
|| !s
->usb_function_strings
)
1154 r
= copy_file_fd(s
->usb_function_descriptors
, fd
, false);
1158 return copy_file_fd(s
->usb_function_strings
, fd
, false);
1161 static int usbffs_select_ep(const struct dirent
*d
) {
1162 return d
->d_name
[0] != '.' && !streq(d
->d_name
, "ep0");
1165 static int usbffs_dispatch_eps(SocketPort
*p
) {
1166 _cleanup_free_
struct dirent
**ent
= NULL
;
1167 _cleanup_free_
char *path
= NULL
;
1170 r
= path_get_parent(p
->path
, &path
);
1174 r
= scandir(path
, &ent
, usbffs_select_ep
, alphasort
);
1179 p
->auxiliary_fds
= new(int, n
);
1180 if (!p
->auxiliary_fds
)
1183 p
->n_auxiliary_fds
= n
;
1186 for (i
= 0; i
< n
; ++i
) {
1187 _cleanup_free_
char *ep
= NULL
;
1189 ep
= path_make_absolute(ent
[i
]->d_name
, path
);
1193 path_kill_slashes(ep
);
1195 r
= usbffs_address_create(ep
);
1199 p
->auxiliary_fds
[k
] = r
;
1208 close_many(p
->auxiliary_fds
, k
);
1209 p
->auxiliary_fds
= mfree(p
->auxiliary_fds
);
1210 p
->n_auxiliary_fds
= 0;
1215 static int socket_open_fds(Socket
*s
) {
1216 _cleanup_(mac_selinux_freep
) char *label
= NULL
;
1217 bool know_label
= false;
1223 LIST_FOREACH(port
, p
, s
->ports
) {
1233 /* Figure out label, if we don't it know
1234 * yet. We do it once, for the first
1235 * socket where we need this and
1236 * remember it for the rest. */
1238 if (s
->selinux_context_from_net
) {
1239 /* Get it from the network label */
1241 r
= mac_selinux_get_our_label(&label
);
1242 if (r
< 0 && r
!= -EOPNOTSUPP
)
1246 /* Get it from the executable we are about to start */
1248 r
= socket_instantiate_service(s
);
1252 if (UNIT_ISSET(s
->service
) &&
1253 SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]) {
1254 r
= mac_selinux_get_create_label_from_exe(SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]->path
, &label
);
1255 if (r
< 0 && r
!= -EPERM
&& r
!= -EOPNOTSUPP
)
1263 r
= socket_address_listen(
1265 SOCK_CLOEXEC
|SOCK_NONBLOCK
,
1279 socket_apply_socket_options(s
, p
->fd
);
1283 case SOCKET_SPECIAL
:
1285 p
->fd
= special_address_create(p
->path
, s
->writable
);
1294 p
->fd
= fifo_address_create(
1303 socket_apply_fifo_options(s
, p
->fd
);
1309 p
->fd
= mq_address_create(
1320 case SOCKET_USB_FUNCTION
:
1322 p
->fd
= usbffs_address_create(p
->path
);
1328 r
= usbffs_write_descs(p
->fd
, SERVICE(UNIT_DEREF(s
->service
)));
1332 r
= usbffs_dispatch_eps(p
);
1339 assert_not_reached("Unknown port type");
1346 socket_close_fds(s
);
1350 static void socket_unwatch_fds(Socket
*s
) {
1356 LIST_FOREACH(port
, p
, s
->ports
) {
1360 if (!p
->event_source
)
1363 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_OFF
);
1365 log_unit_debug_errno(UNIT(s
), r
, "Failed to disable event source: %m");
1369 static int socket_watch_fds(Socket
*s
) {
1375 LIST_FOREACH(port
, p
, s
->ports
) {
1379 if (p
->event_source
) {
1380 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_ON
);
1384 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &p
->event_source
, p
->fd
, EPOLLIN
, socket_dispatch_io
, p
);
1388 (void) sd_event_source_set_description(p
->event_source
, "socket-port-io");
1395 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch listening fds: %m");
1396 socket_unwatch_fds(s
);
1400 static void socket_set_state(Socket
*s
, SocketState state
) {
1401 SocketState old_state
;
1404 old_state
= s
->state
;
1412 SOCKET_STOP_PRE_SIGTERM
,
1413 SOCKET_STOP_PRE_SIGKILL
,
1415 SOCKET_FINAL_SIGTERM
,
1416 SOCKET_FINAL_SIGKILL
)) {
1418 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1419 socket_unwatch_control_pid(s
);
1420 s
->control_command
= NULL
;
1421 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
1424 if (state
!= SOCKET_LISTENING
)
1425 socket_unwatch_fds(s
);
1433 SOCKET_STOP_PRE_SIGTERM
,
1434 SOCKET_STOP_PRE_SIGKILL
))
1435 socket_close_fds(s
);
1437 if (state
!= old_state
)
1438 log_unit_debug(UNIT(s
), "Changed %s -> %s", socket_state_to_string(old_state
), socket_state_to_string(state
));
1440 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
1443 static int socket_coldplug(Unit
*u
) {
1444 Socket
*s
= SOCKET(u
);
1448 assert(s
->state
== SOCKET_DEAD
);
1450 if (s
->deserialized_state
== s
->state
)
1453 if (IN_SET(s
->deserialized_state
,
1458 SOCKET_STOP_PRE_SIGTERM
,
1459 SOCKET_STOP_PRE_SIGKILL
,
1461 SOCKET_FINAL_SIGTERM
,
1462 SOCKET_FINAL_SIGKILL
)) {
1464 if (s
->control_pid
<= 0)
1467 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1471 r
= socket_arm_timer(s
);
1476 if (IN_SET(s
->deserialized_state
,
1482 SOCKET_STOP_PRE_SIGTERM
,
1483 SOCKET_STOP_PRE_SIGKILL
)) {
1484 r
= socket_open_fds(s
);
1489 if (s
->deserialized_state
== SOCKET_LISTENING
) {
1490 r
= socket_watch_fds(s
);
1495 socket_set_state(s
, s
->deserialized_state
);
1499 static int socket_spawn(Socket
*s
, ExecCommand
*c
, pid_t
*_pid
) {
1500 _cleanup_free_
char **argv
= NULL
;
1503 ExecParameters exec_params
= {
1504 .apply_permissions
= true,
1505 .apply_chroot
= true,
1506 .apply_tty_stdin
= true,
1507 .bus_endpoint_fd
= -1,
1517 (void) unit_realize_cgroup(UNIT(s
));
1518 if (s
->reset_cpu_usage
) {
1519 (void) unit_reset_cpu_usage(UNIT(s
));
1520 s
->reset_cpu_usage
= false;
1523 r
= unit_setup_exec_runtime(UNIT(s
));
1527 r
= socket_arm_timer(s
);
1531 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1535 exec_params
.argv
= argv
;
1536 exec_params
.environment
= UNIT(s
)->manager
->environment
;
1537 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1538 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1539 exec_params
.cgroup_path
= UNIT(s
)->cgroup_path
;
1540 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1541 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1543 r
= exec_spawn(UNIT(s
),
1552 r
= unit_watch_pid(UNIT(s
), pid
);
1554 /* FIXME: we need to do something here */
1561 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1565 static int socket_chown(Socket
*s
, pid_t
*_pid
) {
1569 r
= socket_arm_timer(s
);
1573 /* We have to resolve the user names out-of-process, hence
1574 * let's fork here. It's messy, but well, what can we do? */
1582 uid_t uid
= UID_INVALID
;
1583 gid_t gid
= GID_INVALID
;
1586 (void) default_signals(SIGNALS_CRASH_HANDLER
, SIGNALS_IGNORE
, -1);
1587 (void) ignore_signals(SIGPIPE
, -1);
1590 if (!isempty(s
->user
)) {
1591 const char *user
= s
->user
;
1593 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
);
1600 if (!isempty(s
->group
)) {
1601 const char *group
= s
->group
;
1603 r
= get_group_creds(&group
, &gid
);
1610 LIST_FOREACH(port
, p
, s
->ports
) {
1611 const char *path
= NULL
;
1613 if (p
->type
== SOCKET_SOCKET
)
1614 path
= socket_address_get_path(&p
->address
);
1615 else if (p
->type
== SOCKET_FIFO
)
1621 if (chown(path
, uid
, gid
) < 0) {
1632 log_error_errno(r
, "Failed to chown socket at step %s: %m", exit_status_to_string(ret
, EXIT_STATUS_SYSTEMD
));
1637 r
= unit_watch_pid(UNIT(s
), pid
);
1645 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1649 static void socket_enter_dead(Socket
*s
, SocketResult f
) {
1652 if (f
!= SOCKET_SUCCESS
)
1655 exec_runtime_destroy(s
->exec_runtime
);
1656 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1658 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1660 socket_set_state(s
, s
->result
!= SOCKET_SUCCESS
? SOCKET_FAILED
: SOCKET_DEAD
);
1663 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
);
1665 static void socket_enter_stop_post(Socket
*s
, SocketResult f
) {
1669 if (f
!= SOCKET_SUCCESS
)
1672 socket_unwatch_control_pid(s
);
1673 s
->control_command_id
= SOCKET_EXEC_STOP_POST
;
1674 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_POST
];
1676 if (s
->control_command
) {
1677 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1681 socket_set_state(s
, SOCKET_STOP_POST
);
1683 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_SUCCESS
);
1688 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1689 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
1692 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
) {
1697 if (f
!= SOCKET_SUCCESS
)
1700 r
= unit_kill_context(
1703 (state
!= SOCKET_STOP_PRE_SIGTERM
&& state
!= SOCKET_FINAL_SIGTERM
) ?
1704 KILL_KILL
: KILL_TERMINATE
,
1712 r
= socket_arm_timer(s
);
1716 socket_set_state(s
, state
);
1717 } else if (state
== SOCKET_STOP_PRE_SIGTERM
)
1718 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_SUCCESS
);
1719 else if (state
== SOCKET_STOP_PRE_SIGKILL
)
1720 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1721 else if (state
== SOCKET_FINAL_SIGTERM
)
1722 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_SUCCESS
);
1724 socket_enter_dead(s
, SOCKET_SUCCESS
);
1729 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1731 if (state
== SOCKET_STOP_PRE_SIGTERM
|| state
== SOCKET_STOP_PRE_SIGKILL
)
1732 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1734 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1737 static void socket_enter_stop_pre(Socket
*s
, SocketResult f
) {
1741 if (f
!= SOCKET_SUCCESS
)
1744 socket_unwatch_control_pid(s
);
1745 s
->control_command_id
= SOCKET_EXEC_STOP_PRE
;
1746 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_PRE
];
1748 if (s
->control_command
) {
1749 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1753 socket_set_state(s
, SOCKET_STOP_PRE
);
1755 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1760 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-pre' task: %m");
1761 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1764 static void socket_enter_listening(Socket
*s
) {
1768 r
= socket_watch_fds(s
);
1770 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1774 socket_set_state(s
, SOCKET_LISTENING
);
1778 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1781 static void socket_enter_start_post(Socket
*s
) {
1785 socket_unwatch_control_pid(s
);
1786 s
->control_command_id
= SOCKET_EXEC_START_POST
;
1787 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_POST
];
1789 if (s
->control_command
) {
1790 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1792 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1796 socket_set_state(s
, SOCKET_START_POST
);
1798 socket_enter_listening(s
);
1803 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1806 static void socket_enter_start_chown(Socket
*s
) {
1811 r
= socket_open_fds(s
);
1813 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1817 if (!isempty(s
->user
) || !isempty(s
->group
)) {
1819 socket_unwatch_control_pid(s
);
1820 s
->control_command_id
= SOCKET_EXEC_START_CHOWN
;
1821 s
->control_command
= NULL
;
1823 r
= socket_chown(s
, &s
->control_pid
);
1825 log_unit_warning_errno(UNIT(s
), r
, "Failed to fork 'start-chown' task: %m");
1829 socket_set_state(s
, SOCKET_START_CHOWN
);
1831 socket_enter_start_post(s
);
1836 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1839 static void socket_enter_start_pre(Socket
*s
) {
1843 socket_unwatch_control_pid(s
);
1844 s
->control_command_id
= SOCKET_EXEC_START_PRE
;
1845 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_PRE
];
1847 if (s
->control_command
) {
1848 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1850 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1854 socket_set_state(s
, SOCKET_START_PRE
);
1856 socket_enter_start_chown(s
);
1861 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1864 static void socket_enter_running(Socket
*s
, int cfd
) {
1865 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1870 /* We don't take connections anymore if we are supposed to
1871 * shut down anyway */
1872 if (unit_stop_pending(UNIT(s
))) {
1874 log_unit_debug(UNIT(s
), "Suppressing connection request since unit stop is scheduled.");
1879 /* Flush all sockets by closing and reopening them */
1880 socket_close_fds(s
);
1882 r
= socket_open_fds(s
);
1884 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1885 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1889 r
= socket_watch_fds(s
);
1891 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1892 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1902 bool pending
= false;
1904 /* If there's already a start pending don't bother to
1906 SET_FOREACH(other
, UNIT(s
)->dependencies
[UNIT_TRIGGERS
], i
)
1907 if (unit_active_or_pending(other
)) {
1913 if (!UNIT_ISSET(s
->service
)) {
1914 log_unit_error(UNIT(s
), "Service to activate vanished, refusing activation.");
1919 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT_DEREF(s
->service
), JOB_REPLACE
, true, &error
, NULL
);
1924 socket_set_state(s
, SOCKET_RUNNING
);
1926 _cleanup_free_
char *prefix
= NULL
, *instance
= NULL
, *name
= NULL
;
1929 if (s
->n_connections
>= s
->max_connections
) {
1930 log_unit_warning(UNIT(s
), "Too many incoming connections (%u)", s
->n_connections
);
1935 r
= socket_instantiate_service(s
);
1939 r
= instance_from_socket(cfd
, s
->n_accepted
, &instance
);
1944 /* ENOTCONN is legitimate if TCP RST was received.
1945 * This connection is over, but the socket unit lives on. */
1950 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
1954 r
= unit_name_build(prefix
, instance
, ".service", &name
);
1958 r
= unit_add_name(UNIT_DEREF(s
->service
), name
);
1962 service
= SERVICE(UNIT_DEREF(s
->service
));
1963 unit_ref_unset(&s
->service
);
1966 UNIT(service
)->no_gc
= false;
1968 unit_choose_id(UNIT(service
), name
);
1970 r
= service_set_socket_fd(service
, cfd
, s
, s
->selinux_context_from_net
);
1975 s
->n_connections
++;
1977 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT(service
), JOB_REPLACE
, true, &error
, NULL
);
1981 /* Notify clients about changed counters */
1982 unit_add_to_dbus_queue(UNIT(s
));
1988 log_unit_warning(UNIT(s
), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1989 cfd
>= 0 ? "template" : "non-template",
1990 bus_error_message(&error
, r
));
1992 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1996 static void socket_run_next(Socket
*s
) {
2000 assert(s
->control_command
);
2001 assert(s
->control_command
->command_next
);
2003 socket_unwatch_control_pid(s
);
2005 s
->control_command
= s
->control_command
->command_next
;
2007 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
2014 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next task: %m");
2016 if (s
->state
== SOCKET_START_POST
)
2017 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
2018 else if (s
->state
== SOCKET_STOP_POST
)
2019 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
2021 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
2024 static int socket_start(Unit
*u
) {
2025 Socket
*s
= SOCKET(u
);
2029 /* We cannot fulfill this request right now, try again later
2031 if (IN_SET(s
->state
,
2033 SOCKET_STOP_PRE_SIGKILL
,
2034 SOCKET_STOP_PRE_SIGTERM
,
2036 SOCKET_FINAL_SIGTERM
,
2037 SOCKET_FINAL_SIGKILL
))
2040 /* Already on it! */
2041 if (IN_SET(s
->state
,
2047 /* Cannot run this without the service being around */
2048 if (UNIT_ISSET(s
->service
)) {
2051 service
= SERVICE(UNIT_DEREF(s
->service
));
2053 if (UNIT(service
)->load_state
!= UNIT_LOADED
) {
2054 log_unit_error(u
, "Socket service %s not loaded, refusing.", UNIT(service
)->id
);
2058 /* If the service is already active we cannot start the
2060 if (service
->state
!= SERVICE_DEAD
&&
2061 service
->state
!= SERVICE_FAILED
&&
2062 service
->state
!= SERVICE_AUTO_RESTART
) {
2063 log_unit_error(u
, "Socket service %s already active, refusing.", UNIT(service
)->id
);
2068 assert(s
->state
== SOCKET_DEAD
|| s
->state
== SOCKET_FAILED
);
2070 s
->result
= SOCKET_SUCCESS
;
2071 s
->reset_cpu_usage
= true;
2073 socket_enter_start_pre(s
);
2078 static int socket_stop(Unit
*u
) {
2079 Socket
*s
= SOCKET(u
);
2084 if (IN_SET(s
->state
,
2086 SOCKET_STOP_PRE_SIGTERM
,
2087 SOCKET_STOP_PRE_SIGKILL
,
2089 SOCKET_FINAL_SIGTERM
,
2090 SOCKET_FINAL_SIGKILL
))
2093 /* If there's already something running we go directly into
2095 if (IN_SET(s
->state
,
2098 SOCKET_START_POST
)) {
2099 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_SUCCESS
);
2103 assert(s
->state
== SOCKET_LISTENING
|| s
->state
== SOCKET_RUNNING
);
2105 socket_enter_stop_pre(s
, SOCKET_SUCCESS
);
2109 static int socket_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2110 Socket
*s
= SOCKET(u
);
2118 unit_serialize_item(u
, f
, "state", socket_state_to_string(s
->state
));
2119 unit_serialize_item(u
, f
, "result", socket_result_to_string(s
->result
));
2120 unit_serialize_item_format(u
, f
, "n-accepted", "%u", s
->n_accepted
);
2122 if (s
->control_pid
> 0)
2123 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2125 if (s
->control_command_id
>= 0)
2126 unit_serialize_item(u
, f
, "control-command", socket_exec_command_to_string(s
->control_command_id
));
2128 LIST_FOREACH(port
, p
, s
->ports
) {
2134 copy
= fdset_put_dup(fds
, p
->fd
);
2138 if (p
->type
== SOCKET_SOCKET
) {
2139 _cleanup_free_
char *t
= NULL
;
2141 r
= socket_address_print(&p
->address
, &t
);
2145 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2146 unit_serialize_item_format(u
, f
, "netlink", "%i %s", copy
, t
);
2148 unit_serialize_item_format(u
, f
, "socket", "%i %i %s", copy
, p
->address
.type
, t
);
2150 } else if (p
->type
== SOCKET_SPECIAL
)
2151 unit_serialize_item_format(u
, f
, "special", "%i %s", copy
, p
->path
);
2152 else if (p
->type
== SOCKET_MQUEUE
)
2153 unit_serialize_item_format(u
, f
, "mqueue", "%i %s", copy
, p
->path
);
2154 else if (p
->type
== SOCKET_USB_FUNCTION
)
2155 unit_serialize_item_format(u
, f
, "ffs", "%i %s", copy
, p
->path
);
2157 assert(p
->type
== SOCKET_FIFO
);
2158 unit_serialize_item_format(u
, f
, "fifo", "%i %s", copy
, p
->path
);
2165 static int socket_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2166 Socket
*s
= SOCKET(u
);
2172 if (streq(key
, "state")) {
2175 state
= socket_state_from_string(value
);
2177 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2179 s
->deserialized_state
= state
;
2180 } else if (streq(key
, "result")) {
2183 f
= socket_result_from_string(value
);
2185 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2186 else if (f
!= SOCKET_SUCCESS
)
2189 } else if (streq(key
, "n-accepted")) {
2192 if (safe_atou(value
, &k
) < 0)
2193 log_unit_debug(u
, "Failed to parse n-accepted value: %s", value
);
2196 } else if (streq(key
, "control-pid")) {
2199 if (parse_pid(value
, &pid
) < 0)
2200 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2202 s
->control_pid
= pid
;
2203 } else if (streq(key
, "control-command")) {
2204 SocketExecCommand id
;
2206 id
= socket_exec_command_from_string(value
);
2208 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2210 s
->control_command_id
= id
;
2211 s
->control_command
= s
->exec_command
[id
];
2213 } else if (streq(key
, "fifo")) {
2217 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2218 log_unit_debug(u
, "Failed to parse fifo value: %s", value
);
2221 LIST_FOREACH(port
, p
, s
->ports
)
2222 if (p
->type
== SOCKET_FIFO
&&
2223 path_equal_or_files_same(p
->path
, value
+skip
))
2228 p
->fd
= fdset_remove(fds
, fd
);
2232 } else if (streq(key
, "special")) {
2236 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2237 log_unit_debug(u
, "Failed to parse special value: %s", value
);
2240 LIST_FOREACH(port
, p
, s
->ports
)
2241 if (p
->type
== SOCKET_SPECIAL
&&
2242 path_equal_or_files_same(p
->path
, value
+skip
))
2247 p
->fd
= fdset_remove(fds
, fd
);
2251 } else if (streq(key
, "mqueue")) {
2255 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2256 log_unit_debug(u
, "Failed to parse mqueue value: %s", value
);
2259 LIST_FOREACH(port
, p
, s
->ports
)
2260 if (p
->type
== SOCKET_MQUEUE
&&
2261 streq(p
->path
, value
+skip
))
2266 p
->fd
= fdset_remove(fds
, fd
);
2270 } else if (streq(key
, "socket")) {
2271 int fd
, type
, skip
= 0;
2274 if (sscanf(value
, "%i %i %n", &fd
, &type
, &skip
) < 2 || fd
< 0 || type
< 0 || !fdset_contains(fds
, fd
))
2275 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2278 LIST_FOREACH(port
, p
, s
->ports
)
2279 if (socket_address_is(&p
->address
, value
+skip
, type
))
2284 p
->fd
= fdset_remove(fds
, fd
);
2288 } else if (streq(key
, "netlink")) {
2292 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2293 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2296 LIST_FOREACH(port
, p
, s
->ports
)
2297 if (socket_address_is_netlink(&p
->address
, value
+skip
))
2302 p
->fd
= fdset_remove(fds
, fd
);
2306 } else if (streq(key
, "ffs")) {
2310 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2311 log_unit_debug(u
, "Failed to parse ffs value: %s", value
);
2314 LIST_FOREACH(port
, p
, s
->ports
)
2315 if (p
->type
== SOCKET_USB_FUNCTION
&&
2316 path_equal_or_files_same(p
->path
, value
+skip
))
2321 p
->fd
= fdset_remove(fds
, fd
);
2326 log_unit_debug(UNIT(s
), "Unknown serialization key: %s", key
);
2331 static int socket_distribute_fds(Unit
*u
, FDSet
*fds
) {
2332 Socket
*s
= SOCKET(u
);
2337 LIST_FOREACH(port
, p
, s
->ports
) {
2341 if (p
->type
!= SOCKET_SOCKET
)
2347 FDSET_FOREACH(fd
, fds
, i
) {
2348 if (socket_address_matches_fd(&p
->address
, fd
)) {
2349 p
->fd
= fdset_remove(fds
, fd
);
2350 s
->deserialized_state
= SOCKET_LISTENING
;
2359 _pure_
static UnitActiveState
socket_active_state(Unit
*u
) {
2362 return state_translation_table
[SOCKET(u
)->state
];
2365 _pure_
static const char *socket_sub_state_to_string(Unit
*u
) {
2368 return socket_state_to_string(SOCKET(u
)->state
);
2371 const char* socket_port_type_to_string(SocketPort
*p
) {
2379 switch (p
->address
.type
) {
2387 case SOCK_SEQPACKET
:
2388 return "SequentialPacket";
2391 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2398 case SOCKET_SPECIAL
:
2402 return "MessageQueue";
2407 case SOCKET_USB_FUNCTION
:
2408 return "USBFunction";
2415 _pure_
static bool socket_check_gc(Unit
*u
) {
2416 Socket
*s
= SOCKET(u
);
2420 return s
->n_connections
> 0;
2423 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
2424 SocketPort
*p
= userdata
;
2430 if (p
->socket
->state
!= SOCKET_LISTENING
)
2433 log_unit_debug(UNIT(p
->socket
), "Incoming traffic");
2435 if (revents
!= EPOLLIN
) {
2437 if (revents
& EPOLLHUP
)
2438 log_unit_error(UNIT(p
->socket
), "Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.");
2440 log_unit_error(UNIT(p
->socket
), "Got unexpected poll event (0x%x) on socket.", revents
);
2444 if (p
->socket
->accept
&&
2445 p
->type
== SOCKET_SOCKET
&&
2446 socket_address_can_accept(&p
->address
)) {
2450 cfd
= accept4(fd
, NULL
, NULL
, SOCK_NONBLOCK
);
2456 log_unit_error_errno(UNIT(p
->socket
), errno
, "Failed to accept socket: %m");
2463 socket_apply_socket_options(p
->socket
, cfd
);
2466 socket_enter_running(p
->socket
, cfd
);
2470 socket_enter_stop_pre(p
->socket
, SOCKET_FAILURE_RESOURCES
);
2474 static void socket_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2475 Socket
*s
= SOCKET(u
);
2481 if (pid
!= s
->control_pid
)
2486 if (is_clean_exit(code
, status
, NULL
))
2488 else if (code
== CLD_EXITED
)
2489 f
= SOCKET_FAILURE_EXIT_CODE
;
2490 else if (code
== CLD_KILLED
)
2491 f
= SOCKET_FAILURE_SIGNAL
;
2492 else if (code
== CLD_DUMPED
)
2493 f
= SOCKET_FAILURE_CORE_DUMP
;
2495 assert_not_reached("Unknown sigchld code");
2497 if (s
->control_command
) {
2498 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2500 if (s
->control_command
->ignore
)
2504 log_unit_full(u
, f
== SOCKET_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2505 "Control process exited, code=%s status=%i",
2506 sigchld_code_to_string(code
), status
);
2508 if (f
!= SOCKET_SUCCESS
)
2511 if (s
->control_command
&&
2512 s
->control_command
->command_next
&&
2513 f
== SOCKET_SUCCESS
) {
2515 log_unit_debug(u
, "Running next command for state %s", socket_state_to_string(s
->state
));
2518 s
->control_command
= NULL
;
2519 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
2521 /* No further commands for this step, so let's figure
2522 * out what to do next */
2524 log_unit_debug(u
, "Got final SIGCHLD for state %s", socket_state_to_string(s
->state
));
2528 case SOCKET_START_PRE
:
2529 if (f
== SOCKET_SUCCESS
)
2530 socket_enter_start_chown(s
);
2532 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, f
);
2535 case SOCKET_START_CHOWN
:
2536 if (f
== SOCKET_SUCCESS
)
2537 socket_enter_start_post(s
);
2539 socket_enter_stop_pre(s
, f
);
2542 case SOCKET_START_POST
:
2543 if (f
== SOCKET_SUCCESS
)
2544 socket_enter_listening(s
);
2546 socket_enter_stop_pre(s
, f
);
2549 case SOCKET_STOP_PRE
:
2550 case SOCKET_STOP_PRE_SIGTERM
:
2551 case SOCKET_STOP_PRE_SIGKILL
:
2552 socket_enter_stop_post(s
, f
);
2555 case SOCKET_STOP_POST
:
2556 case SOCKET_FINAL_SIGTERM
:
2557 case SOCKET_FINAL_SIGKILL
:
2558 socket_enter_dead(s
, f
);
2562 assert_not_reached("Uh, control process died at wrong time.");
2566 /* Notify clients about changed exit status */
2567 unit_add_to_dbus_queue(u
);
2570 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2571 Socket
*s
= SOCKET(userdata
);
2574 assert(s
->timer_event_source
== source
);
2578 case SOCKET_START_PRE
:
2579 log_unit_warning(UNIT(s
), "Starting timed out. Terminating.");
2580 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2583 case SOCKET_START_CHOWN
:
2584 case SOCKET_START_POST
:
2585 log_unit_warning(UNIT(s
), "Starting timed out. Stopping.");
2586 socket_enter_stop_pre(s
, SOCKET_FAILURE_TIMEOUT
);
2589 case SOCKET_STOP_PRE
:
2590 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2591 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2594 case SOCKET_STOP_PRE_SIGTERM
:
2595 if (s
->kill_context
.send_sigkill
) {
2596 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
2597 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2599 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL. Ignoring.");
2600 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2604 case SOCKET_STOP_PRE_SIGKILL
:
2605 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2606 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2609 case SOCKET_STOP_POST
:
2610 log_unit_warning(UNIT(s
), "Stopping timed out (2). Terminating.");
2611 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2614 case SOCKET_FINAL_SIGTERM
:
2615 if (s
->kill_context
.send_sigkill
) {
2616 log_unit_warning(UNIT(s
), "Stopping timed out (2). Killing.");
2617 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2619 log_unit_warning(UNIT(s
), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
2620 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2624 case SOCKET_FINAL_SIGKILL
:
2625 log_unit_warning(UNIT(s
), "Still around after SIGKILL (2). Entering failed mode.");
2626 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2630 assert_not_reached("Timeout at wrong time.");
2636 int socket_collect_fds(Socket
*s
, int **fds
) {
2637 int *rfds
, k
= 0, n
= 0;
2643 /* Called from the service code for requesting our fds */
2645 LIST_FOREACH(port
, p
, s
->ports
) {
2648 n
+= p
->n_auxiliary_fds
;
2660 LIST_FOREACH(port
, p
, s
->ports
) {
2665 for (i
= 0; i
< p
->n_auxiliary_fds
; ++i
)
2666 rfds
[k
++] = p
->auxiliary_fds
[i
];
2675 static void socket_reset_failed(Unit
*u
) {
2676 Socket
*s
= SOCKET(u
);
2680 if (s
->state
== SOCKET_FAILED
)
2681 socket_set_state(s
, SOCKET_DEAD
);
2683 s
->result
= SOCKET_SUCCESS
;
2686 static void socket_notify_service_dead(Socket
*s
, bool failed_permanent
) {
2689 /* The service is dead. Dang!
2691 * This is strictly for one-instance-for-all-connections
2694 if (s
->state
== SOCKET_RUNNING
) {
2695 log_unit_debug(UNIT(s
), "Got notified about service death (failed permanently: %s)", yes_no(failed_permanent
));
2696 if (failed_permanent
)
2697 socket_enter_stop_pre(s
, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
);
2699 socket_enter_listening(s
);
2703 void socket_connection_unref(Socket
*s
) {
2706 /* The service is dead. Yay!
2708 * This is strictly for one-instance-per-connection
2711 assert(s
->n_connections
> 0);
2714 log_unit_debug(UNIT(s
), "One connection closed, %u left.", s
->n_connections
);
2717 static void socket_trigger_notify(Unit
*u
, Unit
*other
) {
2718 Socket
*s
= SOCKET(u
);
2724 /* Don't propagate state changes from the service if we are
2725 already down or accepting connections */
2726 if ((s
->state
!= SOCKET_RUNNING
&&
2727 s
->state
!= SOCKET_LISTENING
) ||
2731 if (other
->load_state
!= UNIT_LOADED
||
2732 other
->type
!= UNIT_SERVICE
)
2735 se
= SERVICE(other
);
2737 if (se
->state
== SERVICE_FAILED
)
2738 socket_notify_service_dead(s
, se
->result
== SERVICE_FAILURE_START_LIMIT
);
2740 if (se
->state
== SERVICE_DEAD
||
2741 se
->state
== SERVICE_FINAL_SIGTERM
||
2742 se
->state
== SERVICE_FINAL_SIGKILL
||
2743 se
->state
== SERVICE_AUTO_RESTART
)
2744 socket_notify_service_dead(s
, false);
2746 if (se
->state
== SERVICE_RUNNING
)
2747 socket_set_state(s
, SOCKET_RUNNING
);
2750 static int socket_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
2751 return unit_kill_common(u
, who
, signo
, -1, SOCKET(u
)->control_pid
, error
);
2754 static int socket_get_timeout(Unit
*u
, uint64_t *timeout
) {
2755 Socket
*s
= SOCKET(u
);
2758 if (!s
->timer_event_source
)
2761 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
2768 char *socket_fdname(Socket
*s
) {
2771 /* Returns the name to use for $LISTEN_NAMES. If the user
2772 * didn't specify anything specifically, use the socket unit's
2773 * name as fallback. */
2781 static const char* const socket_exec_command_table
[_SOCKET_EXEC_COMMAND_MAX
] = {
2782 [SOCKET_EXEC_START_PRE
] = "StartPre",
2783 [SOCKET_EXEC_START_CHOWN
] = "StartChown",
2784 [SOCKET_EXEC_START_POST
] = "StartPost",
2785 [SOCKET_EXEC_STOP_PRE
] = "StopPre",
2786 [SOCKET_EXEC_STOP_POST
] = "StopPost"
2789 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command
, SocketExecCommand
);
2791 static const char* const socket_result_table
[_SOCKET_RESULT_MAX
] = {
2792 [SOCKET_SUCCESS
] = "success",
2793 [SOCKET_FAILURE_RESOURCES
] = "resources",
2794 [SOCKET_FAILURE_TIMEOUT
] = "timeout",
2795 [SOCKET_FAILURE_EXIT_CODE
] = "exit-code",
2796 [SOCKET_FAILURE_SIGNAL
] = "signal",
2797 [SOCKET_FAILURE_CORE_DUMP
] = "core-dump",
2798 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
] = "service-failed-permanent"
2801 DEFINE_STRING_TABLE_LOOKUP(socket_result
, SocketResult
);
2803 const UnitVTable socket_vtable
= {
2804 .object_size
= sizeof(Socket
),
2805 .exec_context_offset
= offsetof(Socket
, exec_context
),
2806 .cgroup_context_offset
= offsetof(Socket
, cgroup_context
),
2807 .kill_context_offset
= offsetof(Socket
, kill_context
),
2808 .exec_runtime_offset
= offsetof(Socket
, exec_runtime
),
2814 .private_section
= "Socket",
2816 .init
= socket_init
,
2817 .done
= socket_done
,
2818 .load
= socket_load
,
2820 .coldplug
= socket_coldplug
,
2822 .dump
= socket_dump
,
2824 .start
= socket_start
,
2825 .stop
= socket_stop
,
2827 .kill
= socket_kill
,
2829 .get_timeout
= socket_get_timeout
,
2831 .serialize
= socket_serialize
,
2832 .deserialize_item
= socket_deserialize_item
,
2833 .distribute_fds
= socket_distribute_fds
,
2835 .active_state
= socket_active_state
,
2836 .sub_state_to_string
= socket_sub_state_to_string
,
2838 .check_gc
= socket_check_gc
,
2840 .sigchld_event
= socket_sigchld_event
,
2842 .trigger_notify
= socket_trigger_notify
,
2844 .reset_failed
= socket_reset_failed
,
2846 .bus_vtable
= bus_socket_vtable
,
2847 .bus_set_property
= bus_socket_set_property
,
2848 .bus_commit_properties
= bus_socket_commit_properties
,
2850 .status_message_formats
= {
2851 /*.starting_stopping = {
2852 [0] = "Starting socket %s...",
2853 [1] = "Stopping socket %s...",
2855 .finished_start_job
= {
2856 [JOB_DONE
] = "Listening on %s.",
2857 [JOB_FAILED
] = "Failed to listen on %s.",
2858 [JOB_TIMEOUT
] = "Timed out starting %s.",
2860 .finished_stop_job
= {
2861 [JOB_DONE
] = "Closed %s.",
2862 [JOB_FAILED
] = "Failed stopping %s.",
2863 [JOB_TIMEOUT
] = "Timed out stopping %s.",