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 "alloc-util.h"
35 #include "bus-error.h"
38 #include "dbus-socket.h"
40 #include "exit-status.h"
42 #include "formats-util.h"
47 #include "parse-util.h"
48 #include "path-util.h"
49 #include "process-util.h"
50 #include "selinux-util.h"
51 #include "signal-util.h"
52 #include "smack-util.h"
55 #include "string-table.h"
56 #include "string-util.h"
58 #include "unit-name.h"
59 #include "unit-printf.h"
61 #include "user-util.h"
63 static const UnitActiveState state_translation_table
[_SOCKET_STATE_MAX
] = {
64 [SOCKET_DEAD
] = UNIT_INACTIVE
,
65 [SOCKET_START_PRE
] = UNIT_ACTIVATING
,
66 [SOCKET_START_CHOWN
] = UNIT_ACTIVATING
,
67 [SOCKET_START_POST
] = UNIT_ACTIVATING
,
68 [SOCKET_LISTENING
] = UNIT_ACTIVE
,
69 [SOCKET_RUNNING
] = UNIT_ACTIVE
,
70 [SOCKET_STOP_PRE
] = UNIT_DEACTIVATING
,
71 [SOCKET_STOP_PRE_SIGTERM
] = UNIT_DEACTIVATING
,
72 [SOCKET_STOP_PRE_SIGKILL
] = UNIT_DEACTIVATING
,
73 [SOCKET_STOP_POST
] = UNIT_DEACTIVATING
,
74 [SOCKET_FINAL_SIGTERM
] = UNIT_DEACTIVATING
,
75 [SOCKET_FINAL_SIGKILL
] = UNIT_DEACTIVATING
,
76 [SOCKET_FAILED
] = UNIT_FAILED
79 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
80 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
82 static void socket_init(Unit
*u
) {
83 Socket
*s
= SOCKET(u
);
86 assert(u
->load_state
== UNIT_STUB
);
88 s
->backlog
= SOMAXCONN
;
89 s
->timeout_usec
= u
->manager
->default_timeout_start_usec
;
90 s
->directory_mode
= 0755;
91 s
->socket_mode
= 0666;
93 s
->max_connections
= 64;
100 s
->exec_context
.std_output
= u
->manager
->default_std_output
;
101 s
->exec_context
.std_error
= u
->manager
->default_std_error
;
103 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
106 static void socket_unwatch_control_pid(Socket
*s
) {
109 if (s
->control_pid
<= 0)
112 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
116 static void socket_cleanup_fd_list(SocketPort
*p
) {
119 close_many(p
->auxiliary_fds
, p
->n_auxiliary_fds
);
120 p
->auxiliary_fds
= mfree(p
->auxiliary_fds
);
121 p
->n_auxiliary_fds
= 0;
124 void socket_free_ports(Socket
*s
) {
129 while ((p
= s
->ports
)) {
130 LIST_REMOVE(port
, s
->ports
, p
);
132 sd_event_source_unref(p
->event_source
);
134 socket_cleanup_fd_list(p
);
141 static void socket_done(Unit
*u
) {
142 Socket
*s
= SOCKET(u
);
146 socket_free_ports(s
);
148 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
149 exec_command_free_array(s
->exec_command
, _SOCKET_EXEC_COMMAND_MAX
);
150 s
->control_command
= NULL
;
152 socket_unwatch_control_pid(s
);
154 unit_ref_unset(&s
->service
);
156 s
->tcp_congestion
= mfree(s
->tcp_congestion
);
157 s
->bind_to_device
= mfree(s
->bind_to_device
);
160 free(s
->smack_ip_in
);
161 free(s
->smack_ip_out
);
163 strv_free(s
->symlinks
);
168 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
171 static int socket_arm_timer(Socket
*s
) {
176 if (s
->timeout_usec
<= 0) {
177 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
181 if (s
->timer_event_source
) {
182 r
= sd_event_source_set_time(s
->timer_event_source
, now(CLOCK_MONOTONIC
) + s
->timeout_usec
);
186 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
189 r
= sd_event_add_time(
190 UNIT(s
)->manager
->event
,
191 &s
->timer_event_source
,
193 now(CLOCK_MONOTONIC
) + s
->timeout_usec
, 0,
194 socket_dispatch_timer
, s
);
198 (void) sd_event_source_set_description(s
->timer_event_source
, "socket-timer");
203 int socket_instantiate_service(Socket
*s
) {
204 _cleanup_free_
char *prefix
= NULL
, *name
= NULL
;
210 /* This fills in s->service if it isn't filled in yet. For
211 * Accept=yes sockets we create the next connection service
212 * here. For Accept=no this is mostly a NOP since the service
213 * is figured out at load time anyway. */
215 if (UNIT_DEREF(s
->service
))
221 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
225 if (asprintf(&name
, "%s@%u.service", prefix
, s
->n_accepted
) < 0)
228 r
= manager_load_unit(UNIT(s
)->manager
, name
, NULL
, NULL
, &u
);
233 unit_ref_set(&s
->service
, u
);
235 return unit_add_two_dependencies(UNIT(s
), UNIT_BEFORE
, UNIT_TRIGGERS
, u
, false);
238 static bool have_non_accept_socket(Socket
*s
) {
246 LIST_FOREACH(port
, p
, s
->ports
) {
248 if (p
->type
!= SOCKET_SOCKET
)
251 if (!socket_address_can_accept(&p
->address
))
258 static int socket_add_mount_links(Socket
*s
) {
264 LIST_FOREACH(port
, p
, s
->ports
) {
265 const char *path
= NULL
;
267 if (p
->type
== SOCKET_SOCKET
)
268 path
= socket_address_get_path(&p
->address
);
269 else if (IN_SET(p
->type
, SOCKET_FIFO
, SOCKET_SPECIAL
, SOCKET_USB_FUNCTION
))
275 r
= unit_require_mounts_for(UNIT(s
), path
);
283 static int socket_add_device_link(Socket
*s
) {
288 if (!s
->bind_to_device
|| streq(s
->bind_to_device
, "lo"))
291 t
= strjoina("/sys/subsystem/net/devices/", s
->bind_to_device
);
292 return unit_add_node_link(UNIT(s
), t
, false);
295 static int socket_add_default_dependencies(Socket
*s
) {
299 if (!UNIT(s
)->default_dependencies
)
302 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_BEFORE
, SPECIAL_SOCKETS_TARGET
, NULL
, true);
306 if (UNIT(s
)->manager
->running_as
== MANAGER_SYSTEM
) {
307 r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, SPECIAL_SYSINIT_TARGET
, NULL
, true);
312 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
315 _pure_
static bool socket_has_exec(Socket
*s
) {
319 for (i
= 0; i
< _SOCKET_EXEC_COMMAND_MAX
; i
++)
320 if (s
->exec_command
[i
])
326 static int socket_add_extras(Socket
*s
) {
332 if (have_non_accept_socket(s
)) {
334 if (!UNIT_DEREF(s
->service
)) {
337 r
= unit_load_related_unit(u
, ".service", &x
);
341 unit_ref_set(&s
->service
, x
);
344 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, UNIT_DEREF(s
->service
), true);
349 r
= socket_add_mount_links(s
);
353 r
= socket_add_device_link(s
);
357 r
= unit_patch_contexts(u
);
361 if (socket_has_exec(s
)) {
362 r
= unit_add_exec_dependencies(u
, &s
->exec_context
);
366 r
= unit_set_default_slice(u
);
371 r
= socket_add_default_dependencies(s
);
378 static const char *socket_find_symlink_target(Socket
*s
) {
379 const char *found
= NULL
;
382 LIST_FOREACH(port
, p
, s
->ports
) {
383 const char *f
= NULL
;
392 if (p
->address
.sockaddr
.un
.sun_path
[0] != 0)
393 f
= p
->address
.sockaddr
.un
.sun_path
;
411 static int socket_verify(Socket
*s
) {
414 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
418 log_unit_error(UNIT(s
), "Unit lacks Listen setting. Refusing.");
422 if (s
->accept
&& have_non_accept_socket(s
)) {
423 log_unit_error(UNIT(s
), "Unit configured for accepting sockets, but sockets are non-accepting. Refusing.");
427 if (s
->accept
&& s
->max_connections
<= 0) {
428 log_unit_error(UNIT(s
), "MaxConnection= setting too small. Refusing.");
432 if (s
->accept
&& UNIT_DEREF(s
->service
)) {
433 log_unit_error(UNIT(s
), "Explicit service configuration for accepting socket units not supported. Refusing.");
437 if (s
->exec_context
.pam_name
&& s
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
438 log_unit_error(UNIT(s
), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing.");
442 if (!strv_isempty(s
->symlinks
) && !socket_find_symlink_target(s
)) {
443 log_unit_error(UNIT(s
), "Unit has symlinks set but none or more than one node in the file system. Refusing.");
450 static int socket_load(Unit
*u
) {
451 Socket
*s
= SOCKET(u
);
455 assert(u
->load_state
== UNIT_STUB
);
457 r
= unit_load_fragment_and_dropin(u
);
461 if (u
->load_state
== UNIT_LOADED
) {
462 /* This is a new unit? Then let's add in some extras */
463 r
= socket_add_extras(s
);
468 return socket_verify(s
);
471 _const_
static const char* listen_lookup(int family
, int type
) {
473 if (family
== AF_NETLINK
)
474 return "ListenNetlink";
476 if (type
== SOCK_STREAM
)
477 return "ListenStream";
478 else if (type
== SOCK_DGRAM
)
479 return "ListenDatagram";
480 else if (type
== SOCK_SEQPACKET
)
481 return "ListenSequentialPacket";
483 assert_not_reached("Unknown socket type");
487 static void socket_dump(Unit
*u
, FILE *f
, const char *prefix
) {
488 char time_string
[FORMAT_TIMESPAN_MAX
];
490 Socket
*s
= SOCKET(u
);
497 prefix
= strempty(prefix
);
498 prefix2
= strjoina(prefix
, "\t");
501 "%sSocket State: %s\n"
503 "%sBindIPv6Only: %s\n"
505 "%sSocketMode: %04o\n"
506 "%sDirectoryMode: %04o\n"
510 "%sTransparent: %s\n"
512 "%sPassCredentials: %s\n"
513 "%sPassSecurity: %s\n"
514 "%sTCPCongestion: %s\n"
515 "%sRemoveOnStop: %s\n"
518 "%sSELinuxContextFromNet: %s\n",
519 prefix
, socket_state_to_string(s
->state
),
520 prefix
, socket_result_to_string(s
->result
),
521 prefix
, socket_address_bind_ipv6_only_to_string(s
->bind_ipv6_only
),
523 prefix
, s
->socket_mode
,
524 prefix
, s
->directory_mode
,
525 prefix
, yes_no(s
->keep_alive
),
526 prefix
, yes_no(s
->no_delay
),
527 prefix
, yes_no(s
->free_bind
),
528 prefix
, yes_no(s
->transparent
),
529 prefix
, yes_no(s
->broadcast
),
530 prefix
, yes_no(s
->pass_cred
),
531 prefix
, yes_no(s
->pass_sec
),
532 prefix
, strna(s
->tcp_congestion
),
533 prefix
, yes_no(s
->remove_on_stop
),
534 prefix
, yes_no(s
->writable
),
535 prefix
, socket_fdname(s
),
536 prefix
, yes_no(s
->selinux_context_from_net
));
538 if (s
->control_pid
> 0)
540 "%sControl PID: "PID_FMT
"\n",
541 prefix
, s
->control_pid
);
543 if (s
->bind_to_device
)
545 "%sBindToDevice: %s\n",
546 prefix
, s
->bind_to_device
);
551 "%sNConnections: %u\n"
552 "%sMaxConnections: %u\n",
553 prefix
, s
->n_accepted
,
554 prefix
, s
->n_connections
,
555 prefix
, s
->max_connections
);
557 if (s
->priority
>= 0)
560 prefix
, s
->priority
);
562 if (s
->receive_buffer
> 0)
564 "%sReceiveBuffer: %zu\n",
565 prefix
, s
->receive_buffer
);
567 if (s
->send_buffer
> 0)
569 "%sSendBuffer: %zu\n",
570 prefix
, s
->send_buffer
);
582 if (s
->pipe_size
> 0)
585 prefix
, s
->pipe_size
);
592 if (s
->mq_maxmsg
> 0)
594 "%sMessageQueueMaxMessages: %li\n",
595 prefix
, s
->mq_maxmsg
);
597 if (s
->mq_msgsize
> 0)
599 "%sMessageQueueMessageSize: %li\n",
600 prefix
, s
->mq_msgsize
);
605 prefix
, yes_no(s
->reuse_port
));
609 "%sSmackLabel: %s\n",
614 "%sSmackLabelIPIn: %s\n",
615 prefix
, s
->smack_ip_in
);
619 "%sSmackLabelIPOut: %s\n",
620 prefix
, s
->smack_ip_out
);
622 if (!isempty(s
->user
) || !isempty(s
->group
))
625 "%sOwnerGroup: %s\n",
626 prefix
, strna(s
->user
),
627 prefix
, strna(s
->group
));
629 if (s
->keep_alive_time
> 0)
631 "%sKeepAliveTimeSec: %s\n",
632 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->keep_alive_time
, USEC_PER_SEC
));
634 if (s
->keep_alive_interval
)
636 "%sKeepAliveIntervalSec: %s\n",
637 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->keep_alive_interval
, USEC_PER_SEC
));
639 if (s
->keep_alive_cnt
)
641 "%sKeepAliveProbes: %u\n",
642 prefix
, s
->keep_alive_cnt
);
646 "%sDeferAcceptSec: %s\n",
647 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->defer_accept
, USEC_PER_SEC
));
649 LIST_FOREACH(port
, p
, s
->ports
) {
651 if (p
->type
== SOCKET_SOCKET
) {
656 r
= socket_address_print(&p
->address
, &k
);
662 fprintf(f
, "%s%s: %s\n", prefix
, listen_lookup(socket_address_family(&p
->address
), p
->address
.type
), t
);
664 } else if (p
->type
== SOCKET_SPECIAL
)
665 fprintf(f
, "%sListenSpecial: %s\n", prefix
, p
->path
);
666 else if (p
->type
== SOCKET_USB_FUNCTION
)
667 fprintf(f
, "%sListenUSBFunction: %s\n", prefix
, p
->path
);
668 else if (p
->type
== SOCKET_MQUEUE
)
669 fprintf(f
, "%sListenMessageQueue: %s\n", prefix
, p
->path
);
671 fprintf(f
, "%sListenFIFO: %s\n", prefix
, p
->path
);
674 exec_context_dump(&s
->exec_context
, f
, prefix
);
675 kill_context_dump(&s
->kill_context
, f
, prefix
);
677 for (c
= 0; c
< _SOCKET_EXEC_COMMAND_MAX
; c
++) {
678 if (!s
->exec_command
[c
])
681 fprintf(f
, "%s-> %s:\n",
682 prefix
, socket_exec_command_to_string(c
));
684 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
688 static int instance_from_socket(int fd
, unsigned nr
, char **instance
) {
691 union sockaddr_union local
, remote
;
697 if (getsockname(fd
, &local
.sa
, &l
) < 0)
701 if (getpeername(fd
, &remote
.sa
, &l
) < 0)
704 switch (local
.sa
.sa_family
) {
708 a
= ntohl(local
.in
.sin_addr
.s_addr
),
709 b
= ntohl(remote
.in
.sin_addr
.s_addr
);
712 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
714 a
>> 24, (a
>> 16) & 0xFF, (a
>> 8) & 0xFF, a
& 0xFF,
715 ntohs(local
.in
.sin_port
),
716 b
>> 24, (b
>> 16) & 0xFF, (b
>> 8) & 0xFF, b
& 0xFF,
717 ntohs(remote
.in
.sin_port
)) < 0)
724 static const unsigned char ipv4_prefix
[] = {
725 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
728 if (memcmp(&local
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0 &&
729 memcmp(&remote
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0) {
731 *a
= local
.in6
.sin6_addr
.s6_addr
+12,
732 *b
= remote
.in6
.sin6_addr
.s6_addr
+12;
735 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
737 a
[0], a
[1], a
[2], a
[3],
738 ntohs(local
.in6
.sin6_port
),
739 b
[0], b
[1], b
[2], b
[3],
740 ntohs(remote
.in6
.sin6_port
)) < 0)
743 char a
[INET6_ADDRSTRLEN
], b
[INET6_ADDRSTRLEN
];
748 inet_ntop(AF_INET6
, &local
.in6
.sin6_addr
, a
, sizeof(a
)),
749 ntohs(local
.in6
.sin6_port
),
750 inet_ntop(AF_INET6
, &remote
.in6
.sin6_addr
, b
, sizeof(b
)),
751 ntohs(remote
.in6
.sin6_port
)) < 0)
762 k
= getpeercred(fd
, &ucred
);
765 "%u-"PID_FMT
"-"UID_FMT
,
766 nr
, ucred
.pid
, ucred
.uid
) < 0)
768 } else if (k
== -ENODATA
) {
769 /* This handles the case where somebody is
770 * connecting from another pid/uid namespace
771 * (e.g. from outside of our container). */
783 assert_not_reached("Unhandled socket type.");
790 static void socket_close_fds(Socket
*s
) {
796 LIST_FOREACH(port
, p
, s
->ports
) {
798 p
->event_source
= sd_event_source_unref(p
->event_source
);
803 p
->fd
= safe_close(p
->fd
);
804 socket_cleanup_fd_list(p
);
806 /* One little note: we should normally not delete any
807 * sockets in the file system here! After all some
808 * other process we spawned might still have a
809 * reference of this fd and wants to continue to use
810 * it. Therefore we delete sockets in the file system
811 * before we create a new one, not after we stopped
814 if (s
->remove_on_stop
) {
826 socket_address_unlink(&p
->address
);
835 if (s
->remove_on_stop
)
836 STRV_FOREACH(i
, s
->symlinks
)
840 static void socket_apply_socket_options(Socket
*s
, int fd
) {
847 int b
= s
->keep_alive
;
848 if (setsockopt(fd
, SOL_SOCKET
, SO_KEEPALIVE
, &b
, sizeof(b
)) < 0)
849 log_unit_warning_errno(UNIT(s
), errno
, "SO_KEEPALIVE failed: %m");
852 if (s
->keep_alive_time
) {
853 int value
= s
->keep_alive_time
/ USEC_PER_SEC
;
854 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPIDLE
, &value
, sizeof(value
)) < 0)
855 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPIDLE failed: %m");
858 if (s
->keep_alive_interval
) {
859 int value
= s
->keep_alive_interval
/ USEC_PER_SEC
;
860 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPINTVL
, &value
, sizeof(value
)) < 0)
861 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPINTVL failed: %m");
864 if (s
->keep_alive_cnt
) {
865 int value
= s
->keep_alive_cnt
;
866 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPCNT
, &value
, sizeof(value
)) < 0)
867 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPCNT failed: %m");
870 if (s
->defer_accept
) {
871 int value
= s
->defer_accept
/ USEC_PER_SEC
;
872 if (setsockopt(fd
, SOL_TCP
, TCP_DEFER_ACCEPT
, &value
, sizeof(value
)) < 0)
873 log_unit_warning_errno(UNIT(s
), errno
, "TCP_DEFER_ACCEPT failed: %m");
878 if (setsockopt(fd
, SOL_TCP
, TCP_NODELAY
, &b
, sizeof(b
)) < 0)
879 log_unit_warning_errno(UNIT(s
), errno
, "TCP_NODELAY failed: %m");
884 if (setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
, &one
, sizeof(one
)) < 0)
885 log_unit_warning_errno(UNIT(s
), errno
, "SO_BROADCAST failed: %m");
890 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSCRED
, &one
, sizeof(one
)) < 0)
891 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSCRED failed: %m");
896 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSSEC
, &one
, sizeof(one
)) < 0)
897 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSSEC failed: %m");
900 if (s
->priority
>= 0)
901 if (setsockopt(fd
, SOL_SOCKET
, SO_PRIORITY
, &s
->priority
, sizeof(s
->priority
)) < 0)
902 log_unit_warning_errno(UNIT(s
), errno
, "SO_PRIORITY failed: %m");
904 if (s
->receive_buffer
> 0) {
905 int value
= (int) s
->receive_buffer
;
907 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
909 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUFFORCE
, &value
, sizeof(value
)) < 0)
910 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &value
, sizeof(value
)) < 0)
911 log_unit_warning_errno(UNIT(s
), errno
, "SO_RCVBUF failed: %m");
914 if (s
->send_buffer
> 0) {
915 int value
= (int) s
->send_buffer
;
916 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUFFORCE
, &value
, sizeof(value
)) < 0)
917 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, &value
, sizeof(value
)) < 0)
918 log_unit_warning_errno(UNIT(s
), errno
, "SO_SNDBUF failed: %m");
922 if (setsockopt(fd
, SOL_SOCKET
, SO_MARK
, &s
->mark
, sizeof(s
->mark
)) < 0)
923 log_unit_warning_errno(UNIT(s
), errno
, "SO_MARK failed: %m");
926 if (setsockopt(fd
, IPPROTO_IP
, IP_TOS
, &s
->ip_tos
, sizeof(s
->ip_tos
)) < 0)
927 log_unit_warning_errno(UNIT(s
), errno
, "IP_TOS failed: %m");
929 if (s
->ip_ttl
>= 0) {
932 r
= setsockopt(fd
, IPPROTO_IP
, IP_TTL
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
934 if (socket_ipv6_is_supported())
935 x
= setsockopt(fd
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
938 errno
= EAFNOSUPPORT
;
942 log_unit_warning_errno(UNIT(s
), errno
, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
945 if (s
->tcp_congestion
)
946 if (setsockopt(fd
, SOL_TCP
, TCP_CONGESTION
, s
->tcp_congestion
, strlen(s
->tcp_congestion
)+1) < 0)
947 log_unit_warning_errno(UNIT(s
), errno
, "TCP_CONGESTION failed: %m");
949 if (s
->smack_ip_in
) {
950 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPIN
, s
->smack_ip_in
);
952 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_in_fd: %m");
955 if (s
->smack_ip_out
) {
956 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPOUT
, s
->smack_ip_out
);
958 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_out_fd: %m");
962 static void socket_apply_fifo_options(Socket
*s
, int fd
) {
968 if (s
->pipe_size
> 0)
969 if (fcntl(fd
, F_SETPIPE_SZ
, s
->pipe_size
) < 0)
970 log_unit_warning_errno(UNIT(s
), errno
, "Setting pipe size failed, ignoring: %m");
973 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_ACCESS
, s
->smack
);
975 log_unit_error_errno(UNIT(s
), r
, "SMACK relabelling failed, ignoring: %m");
979 static int fifo_address_create(
981 mode_t directory_mode
,
982 mode_t socket_mode
) {
984 _cleanup_close_
int fd
= -1;
991 mkdir_parents_label(path
, directory_mode
);
993 r
= mac_selinux_create_file_prepare(path
, S_IFIFO
);
997 /* Enforce the right access mode for the fifo */
998 old_mask
= umask(~ socket_mode
);
1000 /* Include the original umask in our mask */
1001 (void) umask(~socket_mode
| old_mask
);
1003 r
= mkfifo(path
, socket_mode
);
1004 (void) umask(old_mask
);
1006 if (r
< 0 && errno
!= EEXIST
) {
1011 fd
= open(path
, O_RDWR
| O_CLOEXEC
| O_NOCTTY
| O_NONBLOCK
| O_NOFOLLOW
);
1017 mac_selinux_create_file_clear();
1019 if (fstat(fd
, &st
) < 0) {
1024 if (!S_ISFIFO(st
.st_mode
) ||
1025 (st
.st_mode
& 0777) != (socket_mode
& ~old_mask
) ||
1026 st
.st_uid
!= getuid() ||
1027 st
.st_gid
!= getgid()) {
1038 mac_selinux_create_file_clear();
1042 static int special_address_create(const char *path
, bool writable
) {
1043 _cleanup_close_
int fd
= -1;
1049 fd
= open(path
, (writable
? O_RDWR
: O_RDONLY
)|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1053 if (fstat(fd
, &st
) < 0)
1056 /* Check whether this is a /proc, /sys or /dev file or char device */
1057 if (!S_ISREG(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
1066 static int usbffs_address_create(const char *path
) {
1067 _cleanup_close_
int fd
= -1;
1073 fd
= open(path
, O_RDWR
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1077 if (fstat(fd
, &st
) < 0)
1080 /* Check whether this is a regular file (ffs endpoint)*/
1081 if (!S_ISREG(st
.st_mode
))
1090 static int mq_address_create(
1096 _cleanup_close_
int fd
= -1;
1099 struct mq_attr _attr
, *attr
= NULL
;
1104 if (maxmsg
> 0 && msgsize
> 0) {
1105 _attr
= (struct mq_attr
) {
1106 .mq_flags
= O_NONBLOCK
,
1107 .mq_maxmsg
= maxmsg
,
1108 .mq_msgsize
= msgsize
,
1113 /* Enforce the right access mode for the mq */
1114 old_mask
= umask(~ mq_mode
);
1116 /* Include the original umask in our mask */
1117 (void) umask(~mq_mode
| old_mask
);
1118 fd
= mq_open(path
, O_RDONLY
|O_CLOEXEC
|O_NONBLOCK
|O_CREAT
, mq_mode
, attr
);
1119 (void) umask(old_mask
);
1124 if (fstat(fd
, &st
) < 0)
1127 if ((st
.st_mode
& 0777) != (mq_mode
& ~old_mask
) ||
1128 st
.st_uid
!= getuid() ||
1129 st
.st_gid
!= getgid())
1138 static int socket_symlink(Socket
*s
) {
1144 p
= socket_find_symlink_target(s
);
1148 STRV_FOREACH(i
, s
->symlinks
)
1149 symlink_label(p
, *i
);
1154 static int usbffs_write_descs(int fd
, Service
*s
) {
1157 if (!s
->usb_function_descriptors
|| !s
->usb_function_strings
)
1160 r
= copy_file_fd(s
->usb_function_descriptors
, fd
, false);
1164 return copy_file_fd(s
->usb_function_strings
, fd
, false);
1167 static int usbffs_select_ep(const struct dirent
*d
) {
1168 return d
->d_name
[0] != '.' && !streq(d
->d_name
, "ep0");
1171 static int usbffs_dispatch_eps(SocketPort
*p
) {
1172 _cleanup_free_
struct dirent
**ent
= NULL
;
1173 _cleanup_free_
char *path
= NULL
;
1176 path
= dirname_malloc(p
->path
);
1180 r
= scandir(path
, &ent
, usbffs_select_ep
, alphasort
);
1185 p
->auxiliary_fds
= new(int, n
);
1186 if (!p
->auxiliary_fds
)
1189 p
->n_auxiliary_fds
= n
;
1192 for (i
= 0; i
< n
; ++i
) {
1193 _cleanup_free_
char *ep
= NULL
;
1195 ep
= path_make_absolute(ent
[i
]->d_name
, path
);
1199 path_kill_slashes(ep
);
1201 r
= usbffs_address_create(ep
);
1205 p
->auxiliary_fds
[k
] = r
;
1214 close_many(p
->auxiliary_fds
, k
);
1215 p
->auxiliary_fds
= mfree(p
->auxiliary_fds
);
1216 p
->n_auxiliary_fds
= 0;
1221 static int socket_open_fds(Socket
*s
) {
1222 _cleanup_(mac_selinux_freep
) char *label
= NULL
;
1223 bool know_label
= false;
1229 LIST_FOREACH(port
, p
, s
->ports
) {
1239 /* Figure out label, if we don't it know
1240 * yet. We do it once, for the first
1241 * socket where we need this and
1242 * remember it for the rest. */
1244 if (s
->selinux_context_from_net
) {
1245 /* Get it from the network label */
1247 r
= mac_selinux_get_our_label(&label
);
1248 if (r
< 0 && r
!= -EOPNOTSUPP
)
1252 /* Get it from the executable we are about to start */
1254 r
= socket_instantiate_service(s
);
1258 if (UNIT_ISSET(s
->service
) &&
1259 SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]) {
1260 r
= mac_selinux_get_create_label_from_exe(SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]->path
, &label
);
1261 if (r
< 0 && r
!= -EPERM
&& r
!= -EOPNOTSUPP
)
1269 r
= socket_address_listen(
1271 SOCK_CLOEXEC
|SOCK_NONBLOCK
,
1285 socket_apply_socket_options(s
, p
->fd
);
1289 case SOCKET_SPECIAL
:
1291 p
->fd
= special_address_create(p
->path
, s
->writable
);
1300 p
->fd
= fifo_address_create(
1309 socket_apply_fifo_options(s
, p
->fd
);
1315 p
->fd
= mq_address_create(
1326 case SOCKET_USB_FUNCTION
:
1328 p
->fd
= usbffs_address_create(p
->path
);
1334 r
= usbffs_write_descs(p
->fd
, SERVICE(UNIT_DEREF(s
->service
)));
1338 r
= usbffs_dispatch_eps(p
);
1345 assert_not_reached("Unknown port type");
1352 socket_close_fds(s
);
1356 static void socket_unwatch_fds(Socket
*s
) {
1362 LIST_FOREACH(port
, p
, s
->ports
) {
1366 if (!p
->event_source
)
1369 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_OFF
);
1371 log_unit_debug_errno(UNIT(s
), r
, "Failed to disable event source: %m");
1375 static int socket_watch_fds(Socket
*s
) {
1381 LIST_FOREACH(port
, p
, s
->ports
) {
1385 if (p
->event_source
) {
1386 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_ON
);
1390 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &p
->event_source
, p
->fd
, EPOLLIN
, socket_dispatch_io
, p
);
1394 (void) sd_event_source_set_description(p
->event_source
, "socket-port-io");
1401 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch listening fds: %m");
1402 socket_unwatch_fds(s
);
1406 static void socket_set_state(Socket
*s
, SocketState state
) {
1407 SocketState old_state
;
1410 old_state
= s
->state
;
1418 SOCKET_STOP_PRE_SIGTERM
,
1419 SOCKET_STOP_PRE_SIGKILL
,
1421 SOCKET_FINAL_SIGTERM
,
1422 SOCKET_FINAL_SIGKILL
)) {
1424 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1425 socket_unwatch_control_pid(s
);
1426 s
->control_command
= NULL
;
1427 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
1430 if (state
!= SOCKET_LISTENING
)
1431 socket_unwatch_fds(s
);
1439 SOCKET_STOP_PRE_SIGTERM
,
1440 SOCKET_STOP_PRE_SIGKILL
))
1441 socket_close_fds(s
);
1443 if (state
!= old_state
)
1444 log_unit_debug(UNIT(s
), "Changed %s -> %s", socket_state_to_string(old_state
), socket_state_to_string(state
));
1446 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
1449 static int socket_coldplug(Unit
*u
) {
1450 Socket
*s
= SOCKET(u
);
1454 assert(s
->state
== SOCKET_DEAD
);
1456 if (s
->deserialized_state
== s
->state
)
1459 if (s
->control_pid
> 0 &&
1460 pid_is_unwaited(s
->control_pid
) &&
1461 IN_SET(s
->deserialized_state
,
1466 SOCKET_STOP_PRE_SIGTERM
,
1467 SOCKET_STOP_PRE_SIGKILL
,
1469 SOCKET_FINAL_SIGTERM
,
1470 SOCKET_FINAL_SIGKILL
)) {
1472 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1476 r
= socket_arm_timer(s
);
1481 if (IN_SET(s
->deserialized_state
,
1487 SOCKET_STOP_PRE_SIGTERM
,
1488 SOCKET_STOP_PRE_SIGKILL
)) {
1489 r
= socket_open_fds(s
);
1494 if (s
->deserialized_state
== SOCKET_LISTENING
) {
1495 r
= socket_watch_fds(s
);
1500 socket_set_state(s
, s
->deserialized_state
);
1504 static int socket_spawn(Socket
*s
, ExecCommand
*c
, pid_t
*_pid
) {
1505 _cleanup_free_
char **argv
= NULL
;
1508 ExecParameters exec_params
= {
1509 .apply_permissions
= true,
1510 .apply_chroot
= true,
1511 .apply_tty_stdin
= true,
1512 .bus_endpoint_fd
= -1,
1522 (void) unit_realize_cgroup(UNIT(s
));
1523 if (s
->reset_cpu_usage
) {
1524 (void) unit_reset_cpu_usage(UNIT(s
));
1525 s
->reset_cpu_usage
= false;
1528 r
= unit_setup_exec_runtime(UNIT(s
));
1532 r
= socket_arm_timer(s
);
1536 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1540 exec_params
.argv
= argv
;
1541 exec_params
.environment
= UNIT(s
)->manager
->environment
;
1542 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1543 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1544 exec_params
.cgroup_path
= UNIT(s
)->cgroup_path
;
1545 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1546 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1548 r
= exec_spawn(UNIT(s
),
1557 r
= unit_watch_pid(UNIT(s
), pid
);
1559 /* FIXME: we need to do something here */
1566 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1570 static int socket_chown(Socket
*s
, pid_t
*_pid
) {
1574 r
= socket_arm_timer(s
);
1578 /* We have to resolve the user names out-of-process, hence
1579 * let's fork here. It's messy, but well, what can we do? */
1587 uid_t uid
= UID_INVALID
;
1588 gid_t gid
= GID_INVALID
;
1591 (void) default_signals(SIGNALS_CRASH_HANDLER
, SIGNALS_IGNORE
, -1);
1592 (void) ignore_signals(SIGPIPE
, -1);
1595 if (!isempty(s
->user
)) {
1596 const char *user
= s
->user
;
1598 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
);
1605 if (!isempty(s
->group
)) {
1606 const char *group
= s
->group
;
1608 r
= get_group_creds(&group
, &gid
);
1615 LIST_FOREACH(port
, p
, s
->ports
) {
1616 const char *path
= NULL
;
1618 if (p
->type
== SOCKET_SOCKET
)
1619 path
= socket_address_get_path(&p
->address
);
1620 else if (p
->type
== SOCKET_FIFO
)
1626 if (chown(path
, uid
, gid
) < 0) {
1637 log_error_errno(r
, "Failed to chown socket at step %s: %m", exit_status_to_string(ret
, EXIT_STATUS_SYSTEMD
));
1642 r
= unit_watch_pid(UNIT(s
), pid
);
1650 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1654 static void socket_enter_dead(Socket
*s
, SocketResult f
) {
1657 if (f
!= SOCKET_SUCCESS
)
1660 exec_runtime_destroy(s
->exec_runtime
);
1661 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1663 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1665 socket_set_state(s
, s
->result
!= SOCKET_SUCCESS
? SOCKET_FAILED
: SOCKET_DEAD
);
1668 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
);
1670 static void socket_enter_stop_post(Socket
*s
, SocketResult f
) {
1674 if (f
!= SOCKET_SUCCESS
)
1677 socket_unwatch_control_pid(s
);
1678 s
->control_command_id
= SOCKET_EXEC_STOP_POST
;
1679 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_POST
];
1681 if (s
->control_command
) {
1682 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1686 socket_set_state(s
, SOCKET_STOP_POST
);
1688 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_SUCCESS
);
1693 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1694 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
1697 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
) {
1702 if (f
!= SOCKET_SUCCESS
)
1705 r
= unit_kill_context(
1708 (state
!= SOCKET_STOP_PRE_SIGTERM
&& state
!= SOCKET_FINAL_SIGTERM
) ?
1709 KILL_KILL
: KILL_TERMINATE
,
1717 r
= socket_arm_timer(s
);
1721 socket_set_state(s
, state
);
1722 } else if (state
== SOCKET_STOP_PRE_SIGTERM
)
1723 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_SUCCESS
);
1724 else if (state
== SOCKET_STOP_PRE_SIGKILL
)
1725 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1726 else if (state
== SOCKET_FINAL_SIGTERM
)
1727 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_SUCCESS
);
1729 socket_enter_dead(s
, SOCKET_SUCCESS
);
1734 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1736 if (state
== SOCKET_STOP_PRE_SIGTERM
|| state
== SOCKET_STOP_PRE_SIGKILL
)
1737 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1739 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1742 static void socket_enter_stop_pre(Socket
*s
, SocketResult f
) {
1746 if (f
!= SOCKET_SUCCESS
)
1749 socket_unwatch_control_pid(s
);
1750 s
->control_command_id
= SOCKET_EXEC_STOP_PRE
;
1751 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_PRE
];
1753 if (s
->control_command
) {
1754 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1758 socket_set_state(s
, SOCKET_STOP_PRE
);
1760 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1765 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-pre' task: %m");
1766 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1769 static void socket_enter_listening(Socket
*s
) {
1773 r
= socket_watch_fds(s
);
1775 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1779 socket_set_state(s
, SOCKET_LISTENING
);
1783 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1786 static void socket_enter_start_post(Socket
*s
) {
1790 socket_unwatch_control_pid(s
);
1791 s
->control_command_id
= SOCKET_EXEC_START_POST
;
1792 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_POST
];
1794 if (s
->control_command
) {
1795 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1797 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1801 socket_set_state(s
, SOCKET_START_POST
);
1803 socket_enter_listening(s
);
1808 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1811 static void socket_enter_start_chown(Socket
*s
) {
1816 r
= socket_open_fds(s
);
1818 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1822 if (!isempty(s
->user
) || !isempty(s
->group
)) {
1824 socket_unwatch_control_pid(s
);
1825 s
->control_command_id
= SOCKET_EXEC_START_CHOWN
;
1826 s
->control_command
= NULL
;
1828 r
= socket_chown(s
, &s
->control_pid
);
1830 log_unit_warning_errno(UNIT(s
), r
, "Failed to fork 'start-chown' task: %m");
1834 socket_set_state(s
, SOCKET_START_CHOWN
);
1836 socket_enter_start_post(s
);
1841 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1844 static void socket_enter_start_pre(Socket
*s
) {
1848 socket_unwatch_control_pid(s
);
1849 s
->control_command_id
= SOCKET_EXEC_START_PRE
;
1850 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_PRE
];
1852 if (s
->control_command
) {
1853 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1855 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1859 socket_set_state(s
, SOCKET_START_PRE
);
1861 socket_enter_start_chown(s
);
1866 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1869 static void socket_enter_running(Socket
*s
, int cfd
) {
1870 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1875 /* We don't take connections anymore if we are supposed to
1876 * shut down anyway */
1877 if (unit_stop_pending(UNIT(s
))) {
1879 log_unit_debug(UNIT(s
), "Suppressing connection request since unit stop is scheduled.");
1884 /* Flush all sockets by closing and reopening them */
1885 socket_close_fds(s
);
1887 r
= socket_open_fds(s
);
1889 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1890 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1894 r
= socket_watch_fds(s
);
1896 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1897 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1907 bool pending
= false;
1909 /* If there's already a start pending don't bother to
1911 SET_FOREACH(other
, UNIT(s
)->dependencies
[UNIT_TRIGGERS
], i
)
1912 if (unit_active_or_pending(other
)) {
1918 if (!UNIT_ISSET(s
->service
)) {
1919 log_unit_error(UNIT(s
), "Service to activate vanished, refusing activation.");
1924 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT_DEREF(s
->service
), JOB_REPLACE
, &error
, NULL
);
1929 socket_set_state(s
, SOCKET_RUNNING
);
1931 _cleanup_free_
char *prefix
= NULL
, *instance
= NULL
, *name
= NULL
;
1934 if (s
->n_connections
>= s
->max_connections
) {
1935 log_unit_warning(UNIT(s
), "Too many incoming connections (%u)", s
->n_connections
);
1940 r
= socket_instantiate_service(s
);
1944 r
= instance_from_socket(cfd
, s
->n_accepted
, &instance
);
1949 /* ENOTCONN is legitimate if TCP RST was received.
1950 * This connection is over, but the socket unit lives on. */
1955 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
1959 r
= unit_name_build(prefix
, instance
, ".service", &name
);
1963 r
= unit_add_name(UNIT_DEREF(s
->service
), name
);
1967 service
= SERVICE(UNIT_DEREF(s
->service
));
1968 unit_ref_unset(&s
->service
);
1971 UNIT(service
)->no_gc
= false;
1973 unit_choose_id(UNIT(service
), name
);
1975 r
= service_set_socket_fd(service
, cfd
, s
, s
->selinux_context_from_net
);
1980 s
->n_connections
++;
1982 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT(service
), JOB_REPLACE
, &error
, NULL
);
1986 /* Notify clients about changed counters */
1987 unit_add_to_dbus_queue(UNIT(s
));
1993 log_unit_warning(UNIT(s
), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1994 cfd
>= 0 ? "template" : "non-template",
1995 bus_error_message(&error
, r
));
1997 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
2001 static void socket_run_next(Socket
*s
) {
2005 assert(s
->control_command
);
2006 assert(s
->control_command
->command_next
);
2008 socket_unwatch_control_pid(s
);
2010 s
->control_command
= s
->control_command
->command_next
;
2012 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
2019 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next task: %m");
2021 if (s
->state
== SOCKET_START_POST
)
2022 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
2023 else if (s
->state
== SOCKET_STOP_POST
)
2024 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
2026 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
2029 static int socket_start(Unit
*u
) {
2030 Socket
*s
= SOCKET(u
);
2034 /* We cannot fulfill this request right now, try again later
2036 if (IN_SET(s
->state
,
2038 SOCKET_STOP_PRE_SIGKILL
,
2039 SOCKET_STOP_PRE_SIGTERM
,
2041 SOCKET_FINAL_SIGTERM
,
2042 SOCKET_FINAL_SIGKILL
))
2045 /* Already on it! */
2046 if (IN_SET(s
->state
,
2052 /* Cannot run this without the service being around */
2053 if (UNIT_ISSET(s
->service
)) {
2056 service
= SERVICE(UNIT_DEREF(s
->service
));
2058 if (UNIT(service
)->load_state
!= UNIT_LOADED
) {
2059 log_unit_error(u
, "Socket service %s not loaded, refusing.", UNIT(service
)->id
);
2063 /* If the service is already active we cannot start the
2065 if (service
->state
!= SERVICE_DEAD
&&
2066 service
->state
!= SERVICE_FAILED
&&
2067 service
->state
!= SERVICE_AUTO_RESTART
) {
2068 log_unit_error(u
, "Socket service %s already active, refusing.", UNIT(service
)->id
);
2073 assert(s
->state
== SOCKET_DEAD
|| s
->state
== SOCKET_FAILED
);
2075 s
->result
= SOCKET_SUCCESS
;
2076 s
->reset_cpu_usage
= true;
2078 socket_enter_start_pre(s
);
2083 static int socket_stop(Unit
*u
) {
2084 Socket
*s
= SOCKET(u
);
2089 if (IN_SET(s
->state
,
2091 SOCKET_STOP_PRE_SIGTERM
,
2092 SOCKET_STOP_PRE_SIGKILL
,
2094 SOCKET_FINAL_SIGTERM
,
2095 SOCKET_FINAL_SIGKILL
))
2098 /* If there's already something running we go directly into
2100 if (IN_SET(s
->state
,
2103 SOCKET_START_POST
)) {
2104 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_SUCCESS
);
2108 assert(s
->state
== SOCKET_LISTENING
|| s
->state
== SOCKET_RUNNING
);
2110 socket_enter_stop_pre(s
, SOCKET_SUCCESS
);
2114 static int socket_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2115 Socket
*s
= SOCKET(u
);
2123 unit_serialize_item(u
, f
, "state", socket_state_to_string(s
->state
));
2124 unit_serialize_item(u
, f
, "result", socket_result_to_string(s
->result
));
2125 unit_serialize_item_format(u
, f
, "n-accepted", "%u", s
->n_accepted
);
2127 if (s
->control_pid
> 0)
2128 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2130 if (s
->control_command_id
>= 0)
2131 unit_serialize_item(u
, f
, "control-command", socket_exec_command_to_string(s
->control_command_id
));
2133 LIST_FOREACH(port
, p
, s
->ports
) {
2139 copy
= fdset_put_dup(fds
, p
->fd
);
2143 if (p
->type
== SOCKET_SOCKET
) {
2144 _cleanup_free_
char *t
= NULL
;
2146 r
= socket_address_print(&p
->address
, &t
);
2150 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2151 unit_serialize_item_format(u
, f
, "netlink", "%i %s", copy
, t
);
2153 unit_serialize_item_format(u
, f
, "socket", "%i %i %s", copy
, p
->address
.type
, t
);
2155 } else if (p
->type
== SOCKET_SPECIAL
)
2156 unit_serialize_item_format(u
, f
, "special", "%i %s", copy
, p
->path
);
2157 else if (p
->type
== SOCKET_MQUEUE
)
2158 unit_serialize_item_format(u
, f
, "mqueue", "%i %s", copy
, p
->path
);
2159 else if (p
->type
== SOCKET_USB_FUNCTION
)
2160 unit_serialize_item_format(u
, f
, "ffs", "%i %s", copy
, p
->path
);
2162 assert(p
->type
== SOCKET_FIFO
);
2163 unit_serialize_item_format(u
, f
, "fifo", "%i %s", copy
, p
->path
);
2170 static int socket_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2171 Socket
*s
= SOCKET(u
);
2177 if (streq(key
, "state")) {
2180 state
= socket_state_from_string(value
);
2182 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2184 s
->deserialized_state
= state
;
2185 } else if (streq(key
, "result")) {
2188 f
= socket_result_from_string(value
);
2190 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2191 else if (f
!= SOCKET_SUCCESS
)
2194 } else if (streq(key
, "n-accepted")) {
2197 if (safe_atou(value
, &k
) < 0)
2198 log_unit_debug(u
, "Failed to parse n-accepted value: %s", value
);
2201 } else if (streq(key
, "control-pid")) {
2204 if (parse_pid(value
, &pid
) < 0)
2205 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2207 s
->control_pid
= pid
;
2208 } else if (streq(key
, "control-command")) {
2209 SocketExecCommand id
;
2211 id
= socket_exec_command_from_string(value
);
2213 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2215 s
->control_command_id
= id
;
2216 s
->control_command
= s
->exec_command
[id
];
2218 } else if (streq(key
, "fifo")) {
2222 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2223 log_unit_debug(u
, "Failed to parse fifo value: %s", value
);
2226 LIST_FOREACH(port
, p
, s
->ports
)
2227 if (p
->type
== SOCKET_FIFO
&&
2228 path_equal_or_files_same(p
->path
, value
+skip
))
2233 p
->fd
= fdset_remove(fds
, fd
);
2237 } else if (streq(key
, "special")) {
2241 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2242 log_unit_debug(u
, "Failed to parse special value: %s", value
);
2245 LIST_FOREACH(port
, p
, s
->ports
)
2246 if (p
->type
== SOCKET_SPECIAL
&&
2247 path_equal_or_files_same(p
->path
, value
+skip
))
2252 p
->fd
= fdset_remove(fds
, fd
);
2256 } else if (streq(key
, "mqueue")) {
2260 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2261 log_unit_debug(u
, "Failed to parse mqueue value: %s", value
);
2264 LIST_FOREACH(port
, p
, s
->ports
)
2265 if (p
->type
== SOCKET_MQUEUE
&&
2266 streq(p
->path
, value
+skip
))
2271 p
->fd
= fdset_remove(fds
, fd
);
2275 } else if (streq(key
, "socket")) {
2276 int fd
, type
, skip
= 0;
2279 if (sscanf(value
, "%i %i %n", &fd
, &type
, &skip
) < 2 || fd
< 0 || type
< 0 || !fdset_contains(fds
, fd
))
2280 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2283 LIST_FOREACH(port
, p
, s
->ports
)
2284 if (socket_address_is(&p
->address
, value
+skip
, type
))
2289 p
->fd
= fdset_remove(fds
, fd
);
2293 } else if (streq(key
, "netlink")) {
2297 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2298 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2301 LIST_FOREACH(port
, p
, s
->ports
)
2302 if (socket_address_is_netlink(&p
->address
, value
+skip
))
2307 p
->fd
= fdset_remove(fds
, fd
);
2311 } else if (streq(key
, "ffs")) {
2315 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2316 log_unit_debug(u
, "Failed to parse ffs value: %s", value
);
2319 LIST_FOREACH(port
, p
, s
->ports
)
2320 if (p
->type
== SOCKET_USB_FUNCTION
&&
2321 path_equal_or_files_same(p
->path
, value
+skip
))
2326 p
->fd
= fdset_remove(fds
, fd
);
2331 log_unit_debug(UNIT(s
), "Unknown serialization key: %s", key
);
2336 static void socket_distribute_fds(Unit
*u
, FDSet
*fds
) {
2337 Socket
*s
= SOCKET(u
);
2342 LIST_FOREACH(port
, p
, s
->ports
) {
2346 if (p
->type
!= SOCKET_SOCKET
)
2352 FDSET_FOREACH(fd
, fds
, i
) {
2353 if (socket_address_matches_fd(&p
->address
, fd
)) {
2354 p
->fd
= fdset_remove(fds
, fd
);
2355 s
->deserialized_state
= SOCKET_LISTENING
;
2362 _pure_
static UnitActiveState
socket_active_state(Unit
*u
) {
2365 return state_translation_table
[SOCKET(u
)->state
];
2368 _pure_
static const char *socket_sub_state_to_string(Unit
*u
) {
2371 return socket_state_to_string(SOCKET(u
)->state
);
2374 const char* socket_port_type_to_string(SocketPort
*p
) {
2382 switch (p
->address
.type
) {
2390 case SOCK_SEQPACKET
:
2391 return "SequentialPacket";
2394 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2401 case SOCKET_SPECIAL
:
2405 return "MessageQueue";
2410 case SOCKET_USB_FUNCTION
:
2411 return "USBFunction";
2418 _pure_
static bool socket_check_gc(Unit
*u
) {
2419 Socket
*s
= SOCKET(u
);
2423 return s
->n_connections
> 0;
2426 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
2427 SocketPort
*p
= userdata
;
2433 if (p
->socket
->state
!= SOCKET_LISTENING
)
2436 log_unit_debug(UNIT(p
->socket
), "Incoming traffic");
2438 if (revents
!= EPOLLIN
) {
2440 if (revents
& EPOLLHUP
)
2441 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.");
2443 log_unit_error(UNIT(p
->socket
), "Got unexpected poll event (0x%x) on socket.", revents
);
2447 if (p
->socket
->accept
&&
2448 p
->type
== SOCKET_SOCKET
&&
2449 socket_address_can_accept(&p
->address
)) {
2453 cfd
= accept4(fd
, NULL
, NULL
, SOCK_NONBLOCK
);
2459 log_unit_error_errno(UNIT(p
->socket
), errno
, "Failed to accept socket: %m");
2466 socket_apply_socket_options(p
->socket
, cfd
);
2469 socket_enter_running(p
->socket
, cfd
);
2473 socket_enter_stop_pre(p
->socket
, SOCKET_FAILURE_RESOURCES
);
2477 static void socket_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2478 Socket
*s
= SOCKET(u
);
2484 if (pid
!= s
->control_pid
)
2489 if (is_clean_exit(code
, status
, NULL
))
2491 else if (code
== CLD_EXITED
)
2492 f
= SOCKET_FAILURE_EXIT_CODE
;
2493 else if (code
== CLD_KILLED
)
2494 f
= SOCKET_FAILURE_SIGNAL
;
2495 else if (code
== CLD_DUMPED
)
2496 f
= SOCKET_FAILURE_CORE_DUMP
;
2498 assert_not_reached("Unknown sigchld code");
2500 if (s
->control_command
) {
2501 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2503 if (s
->control_command
->ignore
)
2507 log_unit_full(u
, f
== SOCKET_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2508 "Control process exited, code=%s status=%i",
2509 sigchld_code_to_string(code
), status
);
2511 if (f
!= SOCKET_SUCCESS
)
2514 if (s
->control_command
&&
2515 s
->control_command
->command_next
&&
2516 f
== SOCKET_SUCCESS
) {
2518 log_unit_debug(u
, "Running next command for state %s", socket_state_to_string(s
->state
));
2521 s
->control_command
= NULL
;
2522 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
2524 /* No further commands for this step, so let's figure
2525 * out what to do next */
2527 log_unit_debug(u
, "Got final SIGCHLD for state %s", socket_state_to_string(s
->state
));
2531 case SOCKET_START_PRE
:
2532 if (f
== SOCKET_SUCCESS
)
2533 socket_enter_start_chown(s
);
2535 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, f
);
2538 case SOCKET_START_CHOWN
:
2539 if (f
== SOCKET_SUCCESS
)
2540 socket_enter_start_post(s
);
2542 socket_enter_stop_pre(s
, f
);
2545 case SOCKET_START_POST
:
2546 if (f
== SOCKET_SUCCESS
)
2547 socket_enter_listening(s
);
2549 socket_enter_stop_pre(s
, f
);
2552 case SOCKET_STOP_PRE
:
2553 case SOCKET_STOP_PRE_SIGTERM
:
2554 case SOCKET_STOP_PRE_SIGKILL
:
2555 socket_enter_stop_post(s
, f
);
2558 case SOCKET_STOP_POST
:
2559 case SOCKET_FINAL_SIGTERM
:
2560 case SOCKET_FINAL_SIGKILL
:
2561 socket_enter_dead(s
, f
);
2565 assert_not_reached("Uh, control process died at wrong time.");
2569 /* Notify clients about changed exit status */
2570 unit_add_to_dbus_queue(u
);
2573 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2574 Socket
*s
= SOCKET(userdata
);
2577 assert(s
->timer_event_source
== source
);
2581 case SOCKET_START_PRE
:
2582 log_unit_warning(UNIT(s
), "Starting timed out. Terminating.");
2583 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2586 case SOCKET_START_CHOWN
:
2587 case SOCKET_START_POST
:
2588 log_unit_warning(UNIT(s
), "Starting timed out. Stopping.");
2589 socket_enter_stop_pre(s
, SOCKET_FAILURE_TIMEOUT
);
2592 case SOCKET_STOP_PRE
:
2593 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2594 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2597 case SOCKET_STOP_PRE_SIGTERM
:
2598 if (s
->kill_context
.send_sigkill
) {
2599 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
2600 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2602 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL. Ignoring.");
2603 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2607 case SOCKET_STOP_PRE_SIGKILL
:
2608 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2609 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2612 case SOCKET_STOP_POST
:
2613 log_unit_warning(UNIT(s
), "Stopping timed out (2). Terminating.");
2614 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2617 case SOCKET_FINAL_SIGTERM
:
2618 if (s
->kill_context
.send_sigkill
) {
2619 log_unit_warning(UNIT(s
), "Stopping timed out (2). Killing.");
2620 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2622 log_unit_warning(UNIT(s
), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
2623 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2627 case SOCKET_FINAL_SIGKILL
:
2628 log_unit_warning(UNIT(s
), "Still around after SIGKILL (2). Entering failed mode.");
2629 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2633 assert_not_reached("Timeout at wrong time.");
2639 int socket_collect_fds(Socket
*s
, int **fds
) {
2640 int *rfds
, k
= 0, n
= 0;
2646 /* Called from the service code for requesting our fds */
2648 LIST_FOREACH(port
, p
, s
->ports
) {
2651 n
+= p
->n_auxiliary_fds
;
2663 LIST_FOREACH(port
, p
, s
->ports
) {
2668 for (i
= 0; i
< p
->n_auxiliary_fds
; ++i
)
2669 rfds
[k
++] = p
->auxiliary_fds
[i
];
2678 static void socket_reset_failed(Unit
*u
) {
2679 Socket
*s
= SOCKET(u
);
2683 if (s
->state
== SOCKET_FAILED
)
2684 socket_set_state(s
, SOCKET_DEAD
);
2686 s
->result
= SOCKET_SUCCESS
;
2689 static void socket_notify_service_dead(Socket
*s
, bool failed_permanent
) {
2692 /* The service is dead. Dang!
2694 * This is strictly for one-instance-for-all-connections
2697 if (s
->state
== SOCKET_RUNNING
) {
2698 log_unit_debug(UNIT(s
), "Got notified about service death (failed permanently: %s)", yes_no(failed_permanent
));
2699 if (failed_permanent
)
2700 socket_enter_stop_pre(s
, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
);
2702 socket_enter_listening(s
);
2706 void socket_connection_unref(Socket
*s
) {
2709 /* The service is dead. Yay!
2711 * This is strictly for one-instance-per-connection
2714 assert(s
->n_connections
> 0);
2717 log_unit_debug(UNIT(s
), "One connection closed, %u left.", s
->n_connections
);
2720 static void socket_trigger_notify(Unit
*u
, Unit
*other
) {
2721 Socket
*s
= SOCKET(u
);
2727 /* Don't propagate state changes from the service if we are
2728 already down or accepting connections */
2729 if ((s
->state
!= SOCKET_RUNNING
&&
2730 s
->state
!= SOCKET_LISTENING
) ||
2734 if (other
->load_state
!= UNIT_LOADED
||
2735 other
->type
!= UNIT_SERVICE
)
2738 se
= SERVICE(other
);
2740 if (se
->state
== SERVICE_FAILED
)
2741 socket_notify_service_dead(s
, se
->result
== SERVICE_FAILURE_START_LIMIT
);
2743 if (se
->state
== SERVICE_DEAD
||
2744 se
->state
== SERVICE_FINAL_SIGTERM
||
2745 se
->state
== SERVICE_FINAL_SIGKILL
||
2746 se
->state
== SERVICE_AUTO_RESTART
)
2747 socket_notify_service_dead(s
, false);
2749 if (se
->state
== SERVICE_RUNNING
)
2750 socket_set_state(s
, SOCKET_RUNNING
);
2753 static int socket_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
2754 return unit_kill_common(u
, who
, signo
, -1, SOCKET(u
)->control_pid
, error
);
2757 static int socket_get_timeout(Unit
*u
, uint64_t *timeout
) {
2758 Socket
*s
= SOCKET(u
);
2761 if (!s
->timer_event_source
)
2764 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
2771 char *socket_fdname(Socket
*s
) {
2774 /* Returns the name to use for $LISTEN_NAMES. If the user
2775 * didn't specify anything specifically, use the socket unit's
2776 * name as fallback. */
2784 static const char* const socket_exec_command_table
[_SOCKET_EXEC_COMMAND_MAX
] = {
2785 [SOCKET_EXEC_START_PRE
] = "StartPre",
2786 [SOCKET_EXEC_START_CHOWN
] = "StartChown",
2787 [SOCKET_EXEC_START_POST
] = "StartPost",
2788 [SOCKET_EXEC_STOP_PRE
] = "StopPre",
2789 [SOCKET_EXEC_STOP_POST
] = "StopPost"
2792 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command
, SocketExecCommand
);
2794 static const char* const socket_result_table
[_SOCKET_RESULT_MAX
] = {
2795 [SOCKET_SUCCESS
] = "success",
2796 [SOCKET_FAILURE_RESOURCES
] = "resources",
2797 [SOCKET_FAILURE_TIMEOUT
] = "timeout",
2798 [SOCKET_FAILURE_EXIT_CODE
] = "exit-code",
2799 [SOCKET_FAILURE_SIGNAL
] = "signal",
2800 [SOCKET_FAILURE_CORE_DUMP
] = "core-dump",
2801 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
] = "service-failed-permanent"
2804 DEFINE_STRING_TABLE_LOOKUP(socket_result
, SocketResult
);
2806 const UnitVTable socket_vtable
= {
2807 .object_size
= sizeof(Socket
),
2808 .exec_context_offset
= offsetof(Socket
, exec_context
),
2809 .cgroup_context_offset
= offsetof(Socket
, cgroup_context
),
2810 .kill_context_offset
= offsetof(Socket
, kill_context
),
2811 .exec_runtime_offset
= offsetof(Socket
, exec_runtime
),
2817 .private_section
= "Socket",
2819 .init
= socket_init
,
2820 .done
= socket_done
,
2821 .load
= socket_load
,
2823 .coldplug
= socket_coldplug
,
2825 .dump
= socket_dump
,
2827 .start
= socket_start
,
2828 .stop
= socket_stop
,
2830 .kill
= socket_kill
,
2832 .get_timeout
= socket_get_timeout
,
2834 .serialize
= socket_serialize
,
2835 .deserialize_item
= socket_deserialize_item
,
2836 .distribute_fds
= socket_distribute_fds
,
2838 .active_state
= socket_active_state
,
2839 .sub_state_to_string
= socket_sub_state_to_string
,
2841 .check_gc
= socket_check_gc
,
2843 .sigchld_event
= socket_sigchld_event
,
2845 .trigger_notify
= socket_trigger_notify
,
2847 .reset_failed
= socket_reset_failed
,
2849 .bus_vtable
= bus_socket_vtable
,
2850 .bus_set_property
= bus_socket_set_property
,
2851 .bus_commit_properties
= bus_socket_commit_properties
,
2853 .status_message_formats
= {
2854 /*.starting_stopping = {
2855 [0] = "Starting socket %s...",
2856 [1] = "Stopping socket %s...",
2858 .finished_start_job
= {
2859 [JOB_DONE
] = "Listening on %s.",
2860 [JOB_FAILED
] = "Failed to listen on %s.",
2861 [JOB_TIMEOUT
] = "Timed out starting %s.",
2863 .finished_stop_job
= {
2864 [JOB_DONE
] = "Closed %s.",
2865 [JOB_FAILED
] = "Failed stopping %s.",
2866 [JOB_TIMEOUT
] = "Timed out stopping %s.",