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,
1514 (void) unit_realize_cgroup(UNIT(s
));
1515 if (s
->reset_cpu_usage
) {
1516 (void) unit_reset_cpu_usage(UNIT(s
));
1517 s
->reset_cpu_usage
= false;
1520 r
= unit_setup_exec_runtime(UNIT(s
));
1524 r
= socket_arm_timer(s
);
1528 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1532 exec_params
.argv
= argv
;
1533 exec_params
.environment
= UNIT(s
)->manager
->environment
;
1534 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1535 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1536 exec_params
.cgroup_path
= UNIT(s
)->cgroup_path
;
1537 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1538 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1540 r
= exec_spawn(UNIT(s
),
1549 r
= unit_watch_pid(UNIT(s
), pid
);
1551 /* FIXME: we need to do something here */
1558 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1562 static int socket_chown(Socket
*s
, pid_t
*_pid
) {
1566 r
= socket_arm_timer(s
);
1570 /* We have to resolve the user names out-of-process, hence
1571 * let's fork here. It's messy, but well, what can we do? */
1579 uid_t uid
= UID_INVALID
;
1580 gid_t gid
= GID_INVALID
;
1583 (void) default_signals(SIGNALS_CRASH_HANDLER
, SIGNALS_IGNORE
, -1);
1584 (void) ignore_signals(SIGPIPE
, -1);
1587 if (!isempty(s
->user
)) {
1588 const char *user
= s
->user
;
1590 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
);
1597 if (!isempty(s
->group
)) {
1598 const char *group
= s
->group
;
1600 r
= get_group_creds(&group
, &gid
);
1607 LIST_FOREACH(port
, p
, s
->ports
) {
1608 const char *path
= NULL
;
1610 if (p
->type
== SOCKET_SOCKET
)
1611 path
= socket_address_get_path(&p
->address
);
1612 else if (p
->type
== SOCKET_FIFO
)
1618 if (chown(path
, uid
, gid
) < 0) {
1629 log_error_errno(r
, "Failed to chown socket at step %s: %m", exit_status_to_string(ret
, EXIT_STATUS_SYSTEMD
));
1634 r
= unit_watch_pid(UNIT(s
), pid
);
1642 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1646 static void socket_enter_dead(Socket
*s
, SocketResult f
) {
1649 if (f
!= SOCKET_SUCCESS
)
1652 exec_runtime_destroy(s
->exec_runtime
);
1653 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1655 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1657 socket_set_state(s
, s
->result
!= SOCKET_SUCCESS
? SOCKET_FAILED
: SOCKET_DEAD
);
1660 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
);
1662 static void socket_enter_stop_post(Socket
*s
, SocketResult f
) {
1666 if (f
!= SOCKET_SUCCESS
)
1669 socket_unwatch_control_pid(s
);
1670 s
->control_command_id
= SOCKET_EXEC_STOP_POST
;
1671 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_POST
];
1673 if (s
->control_command
) {
1674 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1678 socket_set_state(s
, SOCKET_STOP_POST
);
1680 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_SUCCESS
);
1685 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1686 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
1689 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
) {
1694 if (f
!= SOCKET_SUCCESS
)
1697 r
= unit_kill_context(
1700 (state
!= SOCKET_STOP_PRE_SIGTERM
&& state
!= SOCKET_FINAL_SIGTERM
) ?
1701 KILL_KILL
: KILL_TERMINATE
,
1709 r
= socket_arm_timer(s
);
1713 socket_set_state(s
, state
);
1714 } else if (state
== SOCKET_STOP_PRE_SIGTERM
)
1715 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_SUCCESS
);
1716 else if (state
== SOCKET_STOP_PRE_SIGKILL
)
1717 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1718 else if (state
== SOCKET_FINAL_SIGTERM
)
1719 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_SUCCESS
);
1721 socket_enter_dead(s
, SOCKET_SUCCESS
);
1726 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1728 if (state
== SOCKET_STOP_PRE_SIGTERM
|| state
== SOCKET_STOP_PRE_SIGKILL
)
1729 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1731 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1734 static void socket_enter_stop_pre(Socket
*s
, SocketResult f
) {
1738 if (f
!= SOCKET_SUCCESS
)
1741 socket_unwatch_control_pid(s
);
1742 s
->control_command_id
= SOCKET_EXEC_STOP_PRE
;
1743 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_PRE
];
1745 if (s
->control_command
) {
1746 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1750 socket_set_state(s
, SOCKET_STOP_PRE
);
1752 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1757 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-pre' task: %m");
1758 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1761 static void socket_enter_listening(Socket
*s
) {
1765 r
= socket_watch_fds(s
);
1767 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1771 socket_set_state(s
, SOCKET_LISTENING
);
1775 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1778 static void socket_enter_start_post(Socket
*s
) {
1782 socket_unwatch_control_pid(s
);
1783 s
->control_command_id
= SOCKET_EXEC_START_POST
;
1784 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_POST
];
1786 if (s
->control_command
) {
1787 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1789 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1793 socket_set_state(s
, SOCKET_START_POST
);
1795 socket_enter_listening(s
);
1800 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1803 static void socket_enter_start_chown(Socket
*s
) {
1808 r
= socket_open_fds(s
);
1810 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1814 if (!isempty(s
->user
) || !isempty(s
->group
)) {
1816 socket_unwatch_control_pid(s
);
1817 s
->control_command_id
= SOCKET_EXEC_START_CHOWN
;
1818 s
->control_command
= NULL
;
1820 r
= socket_chown(s
, &s
->control_pid
);
1822 log_unit_warning_errno(UNIT(s
), r
, "Failed to fork 'start-chown' task: %m");
1826 socket_set_state(s
, SOCKET_START_CHOWN
);
1828 socket_enter_start_post(s
);
1833 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1836 static void socket_enter_start_pre(Socket
*s
) {
1840 socket_unwatch_control_pid(s
);
1841 s
->control_command_id
= SOCKET_EXEC_START_PRE
;
1842 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_PRE
];
1844 if (s
->control_command
) {
1845 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1847 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1851 socket_set_state(s
, SOCKET_START_PRE
);
1853 socket_enter_start_chown(s
);
1858 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1861 static void socket_enter_running(Socket
*s
, int cfd
) {
1862 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1867 /* We don't take connections anymore if we are supposed to
1868 * shut down anyway */
1869 if (unit_stop_pending(UNIT(s
))) {
1871 log_unit_debug(UNIT(s
), "Suppressing connection request since unit stop is scheduled.");
1876 /* Flush all sockets by closing and reopening them */
1877 socket_close_fds(s
);
1879 r
= socket_open_fds(s
);
1881 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1882 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1886 r
= socket_watch_fds(s
);
1888 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1889 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1899 bool pending
= false;
1901 /* If there's already a start pending don't bother to
1903 SET_FOREACH(other
, UNIT(s
)->dependencies
[UNIT_TRIGGERS
], i
)
1904 if (unit_active_or_pending(other
)) {
1910 if (!UNIT_ISSET(s
->service
)) {
1911 log_unit_error(UNIT(s
), "Service to activate vanished, refusing activation.");
1916 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT_DEREF(s
->service
), JOB_REPLACE
, true, &error
, NULL
);
1921 socket_set_state(s
, SOCKET_RUNNING
);
1923 _cleanup_free_
char *prefix
= NULL
, *instance
= NULL
, *name
= NULL
;
1926 if (s
->n_connections
>= s
->max_connections
) {
1927 log_unit_warning(UNIT(s
), "Too many incoming connections (%u)", s
->n_connections
);
1932 r
= socket_instantiate_service(s
);
1936 r
= instance_from_socket(cfd
, s
->n_accepted
, &instance
);
1941 /* ENOTCONN is legitimate if TCP RST was received.
1942 * This connection is over, but the socket unit lives on. */
1947 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
1951 r
= unit_name_build(prefix
, instance
, ".service", &name
);
1955 r
= unit_add_name(UNIT_DEREF(s
->service
), name
);
1959 service
= SERVICE(UNIT_DEREF(s
->service
));
1960 unit_ref_unset(&s
->service
);
1963 UNIT(service
)->no_gc
= false;
1965 unit_choose_id(UNIT(service
), name
);
1967 r
= service_set_socket_fd(service
, cfd
, s
, s
->selinux_context_from_net
);
1972 s
->n_connections
++;
1974 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT(service
), JOB_REPLACE
, true, &error
, NULL
);
1978 /* Notify clients about changed counters */
1979 unit_add_to_dbus_queue(UNIT(s
));
1985 log_unit_warning(UNIT(s
), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1986 cfd
>= 0 ? "template" : "non-template",
1987 bus_error_message(&error
, r
));
1989 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1993 static void socket_run_next(Socket
*s
) {
1997 assert(s
->control_command
);
1998 assert(s
->control_command
->command_next
);
2000 socket_unwatch_control_pid(s
);
2002 s
->control_command
= s
->control_command
->command_next
;
2004 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
2011 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next task: %m");
2013 if (s
->state
== SOCKET_START_POST
)
2014 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
2015 else if (s
->state
== SOCKET_STOP_POST
)
2016 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
2018 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
2021 static int socket_start(Unit
*u
) {
2022 Socket
*s
= SOCKET(u
);
2026 /* We cannot fulfill this request right now, try again later
2028 if (IN_SET(s
->state
,
2030 SOCKET_STOP_PRE_SIGKILL
,
2031 SOCKET_STOP_PRE_SIGTERM
,
2033 SOCKET_FINAL_SIGTERM
,
2034 SOCKET_FINAL_SIGKILL
))
2037 /* Already on it! */
2038 if (IN_SET(s
->state
,
2044 /* Cannot run this without the service being around */
2045 if (UNIT_ISSET(s
->service
)) {
2048 service
= SERVICE(UNIT_DEREF(s
->service
));
2050 if (UNIT(service
)->load_state
!= UNIT_LOADED
) {
2051 log_unit_error(u
, "Socket service %s not loaded, refusing.", UNIT(service
)->id
);
2055 /* If the service is already active we cannot start the
2057 if (service
->state
!= SERVICE_DEAD
&&
2058 service
->state
!= SERVICE_FAILED
&&
2059 service
->state
!= SERVICE_AUTO_RESTART
) {
2060 log_unit_error(u
, "Socket service %s already active, refusing.", UNIT(service
)->id
);
2065 assert(s
->state
== SOCKET_DEAD
|| s
->state
== SOCKET_FAILED
);
2067 s
->result
= SOCKET_SUCCESS
;
2068 s
->reset_cpu_usage
= true;
2070 socket_enter_start_pre(s
);
2075 static int socket_stop(Unit
*u
) {
2076 Socket
*s
= SOCKET(u
);
2081 if (IN_SET(s
->state
,
2083 SOCKET_STOP_PRE_SIGTERM
,
2084 SOCKET_STOP_PRE_SIGKILL
,
2086 SOCKET_FINAL_SIGTERM
,
2087 SOCKET_FINAL_SIGKILL
))
2090 /* If there's already something running we go directly into
2092 if (IN_SET(s
->state
,
2095 SOCKET_START_POST
)) {
2096 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_SUCCESS
);
2100 assert(s
->state
== SOCKET_LISTENING
|| s
->state
== SOCKET_RUNNING
);
2102 socket_enter_stop_pre(s
, SOCKET_SUCCESS
);
2106 static int socket_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2107 Socket
*s
= SOCKET(u
);
2115 unit_serialize_item(u
, f
, "state", socket_state_to_string(s
->state
));
2116 unit_serialize_item(u
, f
, "result", socket_result_to_string(s
->result
));
2117 unit_serialize_item_format(u
, f
, "n-accepted", "%u", s
->n_accepted
);
2119 if (s
->control_pid
> 0)
2120 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2122 if (s
->control_command_id
>= 0)
2123 unit_serialize_item(u
, f
, "control-command", socket_exec_command_to_string(s
->control_command_id
));
2125 LIST_FOREACH(port
, p
, s
->ports
) {
2131 copy
= fdset_put_dup(fds
, p
->fd
);
2135 if (p
->type
== SOCKET_SOCKET
) {
2136 _cleanup_free_
char *t
= NULL
;
2138 r
= socket_address_print(&p
->address
, &t
);
2142 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2143 unit_serialize_item_format(u
, f
, "netlink", "%i %s", copy
, t
);
2145 unit_serialize_item_format(u
, f
, "socket", "%i %i %s", copy
, p
->address
.type
, t
);
2147 } else if (p
->type
== SOCKET_SPECIAL
)
2148 unit_serialize_item_format(u
, f
, "special", "%i %s", copy
, p
->path
);
2149 else if (p
->type
== SOCKET_MQUEUE
)
2150 unit_serialize_item_format(u
, f
, "mqueue", "%i %s", copy
, p
->path
);
2151 else if (p
->type
== SOCKET_USB_FUNCTION
)
2152 unit_serialize_item_format(u
, f
, "ffs", "%i %s", copy
, p
->path
);
2154 assert(p
->type
== SOCKET_FIFO
);
2155 unit_serialize_item_format(u
, f
, "fifo", "%i %s", copy
, p
->path
);
2162 static int socket_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2163 Socket
*s
= SOCKET(u
);
2169 if (streq(key
, "state")) {
2172 state
= socket_state_from_string(value
);
2174 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2176 s
->deserialized_state
= state
;
2177 } else if (streq(key
, "result")) {
2180 f
= socket_result_from_string(value
);
2182 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2183 else if (f
!= SOCKET_SUCCESS
)
2186 } else if (streq(key
, "n-accepted")) {
2189 if (safe_atou(value
, &k
) < 0)
2190 log_unit_debug(u
, "Failed to parse n-accepted value: %s", value
);
2193 } else if (streq(key
, "control-pid")) {
2196 if (parse_pid(value
, &pid
) < 0)
2197 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2199 s
->control_pid
= pid
;
2200 } else if (streq(key
, "control-command")) {
2201 SocketExecCommand id
;
2203 id
= socket_exec_command_from_string(value
);
2205 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2207 s
->control_command_id
= id
;
2208 s
->control_command
= s
->exec_command
[id
];
2210 } else if (streq(key
, "fifo")) {
2214 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2215 log_unit_debug(u
, "Failed to parse fifo value: %s", value
);
2218 LIST_FOREACH(port
, p
, s
->ports
)
2219 if (p
->type
== SOCKET_FIFO
&&
2220 path_equal_or_files_same(p
->path
, value
+skip
))
2225 p
->fd
= fdset_remove(fds
, fd
);
2229 } else if (streq(key
, "special")) {
2233 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2234 log_unit_debug(u
, "Failed to parse special value: %s", value
);
2237 LIST_FOREACH(port
, p
, s
->ports
)
2238 if (p
->type
== SOCKET_SPECIAL
&&
2239 path_equal_or_files_same(p
->path
, value
+skip
))
2244 p
->fd
= fdset_remove(fds
, fd
);
2248 } else if (streq(key
, "mqueue")) {
2252 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2253 log_unit_debug(u
, "Failed to parse mqueue value: %s", value
);
2256 LIST_FOREACH(port
, p
, s
->ports
)
2257 if (p
->type
== SOCKET_MQUEUE
&&
2258 streq(p
->path
, value
+skip
))
2263 p
->fd
= fdset_remove(fds
, fd
);
2267 } else if (streq(key
, "socket")) {
2268 int fd
, type
, skip
= 0;
2271 if (sscanf(value
, "%i %i %n", &fd
, &type
, &skip
) < 2 || fd
< 0 || type
< 0 || !fdset_contains(fds
, fd
))
2272 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2275 LIST_FOREACH(port
, p
, s
->ports
)
2276 if (socket_address_is(&p
->address
, value
+skip
, type
))
2281 p
->fd
= fdset_remove(fds
, fd
);
2285 } else if (streq(key
, "netlink")) {
2289 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2290 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2293 LIST_FOREACH(port
, p
, s
->ports
)
2294 if (socket_address_is_netlink(&p
->address
, value
+skip
))
2299 p
->fd
= fdset_remove(fds
, fd
);
2303 } else if (streq(key
, "ffs")) {
2307 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2308 log_unit_debug(u
, "Failed to parse ffs value: %s", value
);
2311 LIST_FOREACH(port
, p
, s
->ports
)
2312 if (p
->type
== SOCKET_USB_FUNCTION
&&
2313 path_equal_or_files_same(p
->path
, value
+skip
))
2318 p
->fd
= fdset_remove(fds
, fd
);
2323 log_unit_debug(UNIT(s
), "Unknown serialization key: %s", key
);
2328 static int socket_distribute_fds(Unit
*u
, FDSet
*fds
) {
2329 Socket
*s
= SOCKET(u
);
2334 LIST_FOREACH(port
, p
, s
->ports
) {
2338 if (p
->type
!= SOCKET_SOCKET
)
2344 FDSET_FOREACH(fd
, fds
, i
) {
2345 if (socket_address_matches_fd(&p
->address
, fd
)) {
2346 p
->fd
= fdset_remove(fds
, fd
);
2347 s
->deserialized_state
= SOCKET_LISTENING
;
2356 _pure_
static UnitActiveState
socket_active_state(Unit
*u
) {
2359 return state_translation_table
[SOCKET(u
)->state
];
2362 _pure_
static const char *socket_sub_state_to_string(Unit
*u
) {
2365 return socket_state_to_string(SOCKET(u
)->state
);
2368 const char* socket_port_type_to_string(SocketPort
*p
) {
2376 switch (p
->address
.type
) {
2384 case SOCK_SEQPACKET
:
2385 return "SequentialPacket";
2388 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2395 case SOCKET_SPECIAL
:
2399 return "MessageQueue";
2404 case SOCKET_USB_FUNCTION
:
2405 return "USBFunction";
2412 _pure_
static bool socket_check_gc(Unit
*u
) {
2413 Socket
*s
= SOCKET(u
);
2417 return s
->n_connections
> 0;
2420 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
2421 SocketPort
*p
= userdata
;
2427 if (p
->socket
->state
!= SOCKET_LISTENING
)
2430 log_unit_debug(UNIT(p
->socket
), "Incoming traffic");
2432 if (revents
!= EPOLLIN
) {
2434 if (revents
& EPOLLHUP
)
2435 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.");
2437 log_unit_error(UNIT(p
->socket
), "Got unexpected poll event (0x%x) on socket.", revents
);
2441 if (p
->socket
->accept
&&
2442 p
->type
== SOCKET_SOCKET
&&
2443 socket_address_can_accept(&p
->address
)) {
2447 cfd
= accept4(fd
, NULL
, NULL
, SOCK_NONBLOCK
);
2453 log_unit_error_errno(UNIT(p
->socket
), errno
, "Failed to accept socket: %m");
2460 socket_apply_socket_options(p
->socket
, cfd
);
2463 socket_enter_running(p
->socket
, cfd
);
2467 socket_enter_stop_pre(p
->socket
, SOCKET_FAILURE_RESOURCES
);
2471 static void socket_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2472 Socket
*s
= SOCKET(u
);
2478 if (pid
!= s
->control_pid
)
2483 if (is_clean_exit(code
, status
, NULL
))
2485 else if (code
== CLD_EXITED
)
2486 f
= SOCKET_FAILURE_EXIT_CODE
;
2487 else if (code
== CLD_KILLED
)
2488 f
= SOCKET_FAILURE_SIGNAL
;
2489 else if (code
== CLD_DUMPED
)
2490 f
= SOCKET_FAILURE_CORE_DUMP
;
2492 assert_not_reached("Unknown sigchld code");
2494 if (s
->control_command
) {
2495 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2497 if (s
->control_command
->ignore
)
2501 log_unit_full(u
, f
== SOCKET_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2502 "Control process exited, code=%s status=%i",
2503 sigchld_code_to_string(code
), status
);
2505 if (f
!= SOCKET_SUCCESS
)
2508 if (s
->control_command
&&
2509 s
->control_command
->command_next
&&
2510 f
== SOCKET_SUCCESS
) {
2512 log_unit_debug(u
, "Running next command for state %s", socket_state_to_string(s
->state
));
2515 s
->control_command
= NULL
;
2516 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
2518 /* No further commands for this step, so let's figure
2519 * out what to do next */
2521 log_unit_debug(u
, "Got final SIGCHLD for state %s", socket_state_to_string(s
->state
));
2525 case SOCKET_START_PRE
:
2526 if (f
== SOCKET_SUCCESS
)
2527 socket_enter_start_chown(s
);
2529 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, f
);
2532 case SOCKET_START_CHOWN
:
2533 if (f
== SOCKET_SUCCESS
)
2534 socket_enter_start_post(s
);
2536 socket_enter_stop_pre(s
, f
);
2539 case SOCKET_START_POST
:
2540 if (f
== SOCKET_SUCCESS
)
2541 socket_enter_listening(s
);
2543 socket_enter_stop_pre(s
, f
);
2546 case SOCKET_STOP_PRE
:
2547 case SOCKET_STOP_PRE_SIGTERM
:
2548 case SOCKET_STOP_PRE_SIGKILL
:
2549 socket_enter_stop_post(s
, f
);
2552 case SOCKET_STOP_POST
:
2553 case SOCKET_FINAL_SIGTERM
:
2554 case SOCKET_FINAL_SIGKILL
:
2555 socket_enter_dead(s
, f
);
2559 assert_not_reached("Uh, control process died at wrong time.");
2563 /* Notify clients about changed exit status */
2564 unit_add_to_dbus_queue(u
);
2567 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2568 Socket
*s
= SOCKET(userdata
);
2571 assert(s
->timer_event_source
== source
);
2575 case SOCKET_START_PRE
:
2576 log_unit_warning(UNIT(s
), "Starting timed out. Terminating.");
2577 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2580 case SOCKET_START_CHOWN
:
2581 case SOCKET_START_POST
:
2582 log_unit_warning(UNIT(s
), "Starting timed out. Stopping.");
2583 socket_enter_stop_pre(s
, SOCKET_FAILURE_TIMEOUT
);
2586 case SOCKET_STOP_PRE
:
2587 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2588 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2591 case SOCKET_STOP_PRE_SIGTERM
:
2592 if (s
->kill_context
.send_sigkill
) {
2593 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
2594 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2596 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL. Ignoring.");
2597 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2601 case SOCKET_STOP_PRE_SIGKILL
:
2602 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2603 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2606 case SOCKET_STOP_POST
:
2607 log_unit_warning(UNIT(s
), "Stopping timed out (2). Terminating.");
2608 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2611 case SOCKET_FINAL_SIGTERM
:
2612 if (s
->kill_context
.send_sigkill
) {
2613 log_unit_warning(UNIT(s
), "Stopping timed out (2). Killing.");
2614 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2616 log_unit_warning(UNIT(s
), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
2617 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2621 case SOCKET_FINAL_SIGKILL
:
2622 log_unit_warning(UNIT(s
), "Still around after SIGKILL (2). Entering failed mode.");
2623 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2627 assert_not_reached("Timeout at wrong time.");
2633 int socket_collect_fds(Socket
*s
, int **fds
) {
2634 int *rfds
, k
= 0, n
= 0;
2640 /* Called from the service code for requesting our fds */
2642 LIST_FOREACH(port
, p
, s
->ports
) {
2645 n
+= p
->n_auxiliary_fds
;
2657 LIST_FOREACH(port
, p
, s
->ports
) {
2662 for (i
= 0; i
< p
->n_auxiliary_fds
; ++i
)
2663 rfds
[k
++] = p
->auxiliary_fds
[i
];
2672 static void socket_reset_failed(Unit
*u
) {
2673 Socket
*s
= SOCKET(u
);
2677 if (s
->state
== SOCKET_FAILED
)
2678 socket_set_state(s
, SOCKET_DEAD
);
2680 s
->result
= SOCKET_SUCCESS
;
2683 static void socket_notify_service_dead(Socket
*s
, bool failed_permanent
) {
2686 /* The service is dead. Dang!
2688 * This is strictly for one-instance-for-all-connections
2691 if (s
->state
== SOCKET_RUNNING
) {
2692 log_unit_debug(UNIT(s
), "Got notified about service death (failed permanently: %s)", yes_no(failed_permanent
));
2693 if (failed_permanent
)
2694 socket_enter_stop_pre(s
, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
);
2696 socket_enter_listening(s
);
2700 void socket_connection_unref(Socket
*s
) {
2703 /* The service is dead. Yay!
2705 * This is strictly for one-instance-per-connection
2708 assert(s
->n_connections
> 0);
2711 log_unit_debug(UNIT(s
), "One connection closed, %u left.", s
->n_connections
);
2714 static void socket_trigger_notify(Unit
*u
, Unit
*other
) {
2715 Socket
*s
= SOCKET(u
);
2721 /* Don't propagate state changes from the service if we are
2722 already down or accepting connections */
2723 if ((s
->state
!= SOCKET_RUNNING
&&
2724 s
->state
!= SOCKET_LISTENING
) ||
2728 if (other
->load_state
!= UNIT_LOADED
||
2729 other
->type
!= UNIT_SERVICE
)
2732 se
= SERVICE(other
);
2734 if (se
->state
== SERVICE_FAILED
)
2735 socket_notify_service_dead(s
, se
->result
== SERVICE_FAILURE_START_LIMIT
);
2737 if (se
->state
== SERVICE_DEAD
||
2738 se
->state
== SERVICE_FINAL_SIGTERM
||
2739 se
->state
== SERVICE_FINAL_SIGKILL
||
2740 se
->state
== SERVICE_AUTO_RESTART
)
2741 socket_notify_service_dead(s
, false);
2743 if (se
->state
== SERVICE_RUNNING
)
2744 socket_set_state(s
, SOCKET_RUNNING
);
2747 static int socket_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
2748 return unit_kill_common(u
, who
, signo
, -1, SOCKET(u
)->control_pid
, error
);
2751 static int socket_get_timeout(Unit
*u
, uint64_t *timeout
) {
2752 Socket
*s
= SOCKET(u
);
2755 if (!s
->timer_event_source
)
2758 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
2765 char *socket_fdname(Socket
*s
) {
2768 /* Returns the name to use for $LISTEN_NAMES. If the user
2769 * didn't specify anything specifically, use the socket unit's
2770 * name as fallback. */
2778 static const char* const socket_exec_command_table
[_SOCKET_EXEC_COMMAND_MAX
] = {
2779 [SOCKET_EXEC_START_PRE
] = "StartPre",
2780 [SOCKET_EXEC_START_CHOWN
] = "StartChown",
2781 [SOCKET_EXEC_START_POST
] = "StartPost",
2782 [SOCKET_EXEC_STOP_PRE
] = "StopPre",
2783 [SOCKET_EXEC_STOP_POST
] = "StopPost"
2786 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command
, SocketExecCommand
);
2788 static const char* const socket_result_table
[_SOCKET_RESULT_MAX
] = {
2789 [SOCKET_SUCCESS
] = "success",
2790 [SOCKET_FAILURE_RESOURCES
] = "resources",
2791 [SOCKET_FAILURE_TIMEOUT
] = "timeout",
2792 [SOCKET_FAILURE_EXIT_CODE
] = "exit-code",
2793 [SOCKET_FAILURE_SIGNAL
] = "signal",
2794 [SOCKET_FAILURE_CORE_DUMP
] = "core-dump",
2795 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
] = "service-failed-permanent"
2798 DEFINE_STRING_TABLE_LOOKUP(socket_result
, SocketResult
);
2800 const UnitVTable socket_vtable
= {
2801 .object_size
= sizeof(Socket
),
2802 .exec_context_offset
= offsetof(Socket
, exec_context
),
2803 .cgroup_context_offset
= offsetof(Socket
, cgroup_context
),
2804 .kill_context_offset
= offsetof(Socket
, kill_context
),
2805 .exec_runtime_offset
= offsetof(Socket
, exec_runtime
),
2811 .private_section
= "Socket",
2813 .init
= socket_init
,
2814 .done
= socket_done
,
2815 .load
= socket_load
,
2817 .coldplug
= socket_coldplug
,
2819 .dump
= socket_dump
,
2821 .start
= socket_start
,
2822 .stop
= socket_stop
,
2824 .kill
= socket_kill
,
2826 .get_timeout
= socket_get_timeout
,
2828 .serialize
= socket_serialize
,
2829 .deserialize_item
= socket_deserialize_item
,
2830 .distribute_fds
= socket_distribute_fds
,
2832 .active_state
= socket_active_state
,
2833 .sub_state_to_string
= socket_sub_state_to_string
,
2835 .check_gc
= socket_check_gc
,
2837 .sigchld_event
= socket_sigchld_event
,
2839 .trigger_notify
= socket_trigger_notify
,
2841 .reset_failed
= socket_reset_failed
,
2843 .bus_vtable
= bus_socket_vtable
,
2844 .bus_set_property
= bus_socket_set_property
,
2845 .bus_commit_properties
= bus_socket_commit_properties
,
2847 .status_message_formats
= {
2848 /*.starting_stopping = {
2849 [0] = "Starting socket %s...",
2850 [1] = "Stopping socket %s...",
2852 .finished_start_job
= {
2853 [JOB_DONE
] = "Listening on %s.",
2854 [JOB_FAILED
] = "Failed to listen on %s.",
2855 [JOB_TIMEOUT
] = "Timed out starting %s.",
2857 .finished_stop_job
= {
2858 [JOB_DONE
] = "Closed %s.",
2859 [JOB_FAILED
] = "Failed stopping %s.",
2860 [JOB_TIMEOUT
] = "Timed out stopping %s.",