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"
510 "%sSELinuxContextFromNet: %s\n",
511 prefix
, socket_state_to_string(s
->state
),
512 prefix
, socket_result_to_string(s
->result
),
513 prefix
, socket_address_bind_ipv6_only_to_string(s
->bind_ipv6_only
),
515 prefix
, s
->socket_mode
,
516 prefix
, s
->directory_mode
,
517 prefix
, yes_no(s
->keep_alive
),
518 prefix
, yes_no(s
->no_delay
),
519 prefix
, yes_no(s
->free_bind
),
520 prefix
, yes_no(s
->transparent
),
521 prefix
, yes_no(s
->broadcast
),
522 prefix
, yes_no(s
->pass_cred
),
523 prefix
, yes_no(s
->pass_sec
),
524 prefix
, strna(s
->tcp_congestion
),
525 prefix
, yes_no(s
->remove_on_stop
),
526 prefix
, yes_no(s
->selinux_context_from_net
));
528 if (s
->control_pid
> 0)
530 "%sControl PID: "PID_FMT
"\n",
531 prefix
, s
->control_pid
);
533 if (s
->bind_to_device
)
535 "%sBindToDevice: %s\n",
536 prefix
, s
->bind_to_device
);
541 "%sNConnections: %u\n"
542 "%sMaxConnections: %u\n",
543 prefix
, s
->n_accepted
,
544 prefix
, s
->n_connections
,
545 prefix
, s
->max_connections
);
547 if (s
->priority
>= 0)
550 prefix
, s
->priority
);
552 if (s
->receive_buffer
> 0)
554 "%sReceiveBuffer: %zu\n",
555 prefix
, s
->receive_buffer
);
557 if (s
->send_buffer
> 0)
559 "%sSendBuffer: %zu\n",
560 prefix
, s
->send_buffer
);
572 if (s
->pipe_size
> 0)
575 prefix
, s
->pipe_size
);
582 if (s
->mq_maxmsg
> 0)
584 "%sMessageQueueMaxMessages: %li\n",
585 prefix
, s
->mq_maxmsg
);
587 if (s
->mq_msgsize
> 0)
589 "%sMessageQueueMessageSize: %li\n",
590 prefix
, s
->mq_msgsize
);
595 prefix
, yes_no(s
->reuse_port
));
599 "%sSmackLabel: %s\n",
604 "%sSmackLabelIPIn: %s\n",
605 prefix
, s
->smack_ip_in
);
609 "%sSmackLabelIPOut: %s\n",
610 prefix
, s
->smack_ip_out
);
612 if (!isempty(s
->user
) || !isempty(s
->group
))
615 "%sOwnerGroup: %s\n",
616 prefix
, strna(s
->user
),
617 prefix
, strna(s
->group
));
619 if (s
->keep_alive_time
> 0)
621 "%sKeepAliveTimeSec: %s\n",
622 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->keep_alive_time
, USEC_PER_SEC
));
624 if (s
->keep_alive_interval
)
626 "%sKeepAliveIntervalSec: %s\n",
627 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->keep_alive_interval
, USEC_PER_SEC
));
629 if (s
->keep_alive_cnt
)
631 "%sKeepAliveProbes: %u\n",
632 prefix
, s
->keep_alive_cnt
);
636 "%sDeferAcceptSec: %s\n",
637 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, s
->defer_accept
, USEC_PER_SEC
));
639 LIST_FOREACH(port
, p
, s
->ports
) {
641 if (p
->type
== SOCKET_SOCKET
) {
646 r
= socket_address_print(&p
->address
, &k
);
652 fprintf(f
, "%s%s: %s\n", prefix
, listen_lookup(socket_address_family(&p
->address
), p
->address
.type
), t
);
654 } else if (p
->type
== SOCKET_SPECIAL
)
655 fprintf(f
, "%sListenSpecial: %s\n", prefix
, p
->path
);
656 else if (p
->type
== SOCKET_USB_FUNCTION
)
657 fprintf(f
, "%sListenUSBFunction: %s\n", prefix
, p
->path
);
658 else if (p
->type
== SOCKET_MQUEUE
)
659 fprintf(f
, "%sListenMessageQueue: %s\n", prefix
, p
->path
);
661 fprintf(f
, "%sListenFIFO: %s\n", prefix
, p
->path
);
664 exec_context_dump(&s
->exec_context
, f
, prefix
);
665 kill_context_dump(&s
->kill_context
, f
, prefix
);
667 for (c
= 0; c
< _SOCKET_EXEC_COMMAND_MAX
; c
++) {
668 if (!s
->exec_command
[c
])
671 fprintf(f
, "%s-> %s:\n",
672 prefix
, socket_exec_command_to_string(c
));
674 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
678 static int instance_from_socket(int fd
, unsigned nr
, char **instance
) {
681 union sockaddr_union local
, remote
;
687 if (getsockname(fd
, &local
.sa
, &l
) < 0)
691 if (getpeername(fd
, &remote
.sa
, &l
) < 0)
694 switch (local
.sa
.sa_family
) {
698 a
= ntohl(local
.in
.sin_addr
.s_addr
),
699 b
= ntohl(remote
.in
.sin_addr
.s_addr
);
702 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
704 a
>> 24, (a
>> 16) & 0xFF, (a
>> 8) & 0xFF, a
& 0xFF,
705 ntohs(local
.in
.sin_port
),
706 b
>> 24, (b
>> 16) & 0xFF, (b
>> 8) & 0xFF, b
& 0xFF,
707 ntohs(remote
.in
.sin_port
)) < 0)
714 static const unsigned char ipv4_prefix
[] = {
715 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
718 if (memcmp(&local
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0 &&
719 memcmp(&remote
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0) {
721 *a
= local
.in6
.sin6_addr
.s6_addr
+12,
722 *b
= remote
.in6
.sin6_addr
.s6_addr
+12;
725 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
727 a
[0], a
[1], a
[2], a
[3],
728 ntohs(local
.in6
.sin6_port
),
729 b
[0], b
[1], b
[2], b
[3],
730 ntohs(remote
.in6
.sin6_port
)) < 0)
733 char a
[INET6_ADDRSTRLEN
], b
[INET6_ADDRSTRLEN
];
738 inet_ntop(AF_INET6
, &local
.in6
.sin6_addr
, a
, sizeof(a
)),
739 ntohs(local
.in6
.sin6_port
),
740 inet_ntop(AF_INET6
, &remote
.in6
.sin6_addr
, b
, sizeof(b
)),
741 ntohs(remote
.in6
.sin6_port
)) < 0)
752 k
= getpeercred(fd
, &ucred
);
755 "%u-"PID_FMT
"-"UID_FMT
,
756 nr
, ucred
.pid
, ucred
.uid
) < 0)
758 } else if (k
== -ENODATA
) {
759 /* This handles the case where somebody is
760 * connecting from another pid/uid namespace
761 * (e.g. from outside of our container). */
773 assert_not_reached("Unhandled socket type.");
780 static void socket_close_fds(Socket
*s
) {
786 LIST_FOREACH(port
, p
, s
->ports
) {
788 p
->event_source
= sd_event_source_unref(p
->event_source
);
793 p
->fd
= safe_close(p
->fd
);
794 socket_cleanup_fd_list(p
);
796 /* One little note: we should normally not delete any
797 * sockets in the file system here! After all some
798 * other process we spawned might still have a
799 * reference of this fd and wants to continue to use
800 * it. Therefore we delete sockets in the file system
801 * before we create a new one, not after we stopped
804 if (s
->remove_on_stop
) {
816 socket_address_unlink(&p
->address
);
825 if (s
->remove_on_stop
)
826 STRV_FOREACH(i
, s
->symlinks
)
830 static void socket_apply_socket_options(Socket
*s
, int fd
) {
837 int b
= s
->keep_alive
;
838 if (setsockopt(fd
, SOL_SOCKET
, SO_KEEPALIVE
, &b
, sizeof(b
)) < 0)
839 log_unit_warning_errno(UNIT(s
), errno
, "SO_KEEPALIVE failed: %m");
842 if (s
->keep_alive_time
) {
843 int value
= s
->keep_alive_time
/ USEC_PER_SEC
;
844 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPIDLE
, &value
, sizeof(value
)) < 0)
845 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPIDLE failed: %m");
848 if (s
->keep_alive_interval
) {
849 int value
= s
->keep_alive_interval
/ USEC_PER_SEC
;
850 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPINTVL
, &value
, sizeof(value
)) < 0)
851 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPINTVL failed: %m");
854 if (s
->keep_alive_cnt
) {
855 int value
= s
->keep_alive_cnt
;
856 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPCNT
, &value
, sizeof(value
)) < 0)
857 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPCNT failed: %m");
860 if (s
->defer_accept
) {
861 int value
= s
->defer_accept
/ USEC_PER_SEC
;
862 if (setsockopt(fd
, SOL_TCP
, TCP_DEFER_ACCEPT
, &value
, sizeof(value
)) < 0)
863 log_unit_warning_errno(UNIT(s
), errno
, "TCP_DEFER_ACCEPT failed: %m");
868 if (setsockopt(fd
, SOL_TCP
, TCP_NODELAY
, &b
, sizeof(b
)) < 0)
869 log_unit_warning_errno(UNIT(s
), errno
, "TCP_NODELAY failed: %m");
874 if (setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
, &one
, sizeof(one
)) < 0)
875 log_unit_warning_errno(UNIT(s
), errno
, "SO_BROADCAST failed: %m");
880 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSCRED
, &one
, sizeof(one
)) < 0)
881 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSCRED failed: %m");
886 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSSEC
, &one
, sizeof(one
)) < 0)
887 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSSEC failed: %m");
890 if (s
->priority
>= 0)
891 if (setsockopt(fd
, SOL_SOCKET
, SO_PRIORITY
, &s
->priority
, sizeof(s
->priority
)) < 0)
892 log_unit_warning_errno(UNIT(s
), errno
, "SO_PRIORITY failed: %m");
894 if (s
->receive_buffer
> 0) {
895 int value
= (int) s
->receive_buffer
;
897 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
899 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUFFORCE
, &value
, sizeof(value
)) < 0)
900 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &value
, sizeof(value
)) < 0)
901 log_unit_warning_errno(UNIT(s
), errno
, "SO_RCVBUF failed: %m");
904 if (s
->send_buffer
> 0) {
905 int value
= (int) s
->send_buffer
;
906 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUFFORCE
, &value
, sizeof(value
)) < 0)
907 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, &value
, sizeof(value
)) < 0)
908 log_unit_warning_errno(UNIT(s
), errno
, "SO_SNDBUF failed: %m");
912 if (setsockopt(fd
, SOL_SOCKET
, SO_MARK
, &s
->mark
, sizeof(s
->mark
)) < 0)
913 log_unit_warning_errno(UNIT(s
), errno
, "SO_MARK failed: %m");
916 if (setsockopt(fd
, IPPROTO_IP
, IP_TOS
, &s
->ip_tos
, sizeof(s
->ip_tos
)) < 0)
917 log_unit_warning_errno(UNIT(s
), errno
, "IP_TOS failed: %m");
919 if (s
->ip_ttl
>= 0) {
922 r
= setsockopt(fd
, IPPROTO_IP
, IP_TTL
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
924 if (socket_ipv6_is_supported())
925 x
= setsockopt(fd
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
928 errno
= EAFNOSUPPORT
;
932 log_unit_warning_errno(UNIT(s
), errno
, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
935 if (s
->tcp_congestion
)
936 if (setsockopt(fd
, SOL_TCP
, TCP_CONGESTION
, s
->tcp_congestion
, strlen(s
->tcp_congestion
)+1) < 0)
937 log_unit_warning_errno(UNIT(s
), errno
, "TCP_CONGESTION failed: %m");
939 if (s
->smack_ip_in
) {
940 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPIN
, s
->smack_ip_in
);
942 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_in_fd: %m");
945 if (s
->smack_ip_out
) {
946 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPOUT
, s
->smack_ip_out
);
948 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_out_fd: %m");
952 static void socket_apply_fifo_options(Socket
*s
, int fd
) {
958 if (s
->pipe_size
> 0)
959 if (fcntl(fd
, F_SETPIPE_SZ
, s
->pipe_size
) < 0)
960 log_unit_warning_errno(UNIT(s
), errno
, "Setting pipe size failed, ignoring: %m");
963 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_ACCESS
, s
->smack
);
965 log_unit_error_errno(UNIT(s
), r
, "SMACK relabelling failed, ignoring: %m");
969 static int fifo_address_create(
971 mode_t directory_mode
,
972 mode_t socket_mode
) {
974 _cleanup_close_
int fd
= -1;
981 mkdir_parents_label(path
, directory_mode
);
983 r
= mac_selinux_create_file_prepare(path
, S_IFIFO
);
987 /* Enforce the right access mode for the fifo */
988 old_mask
= umask(~ socket_mode
);
990 /* Include the original umask in our mask */
991 (void) umask(~socket_mode
| old_mask
);
993 r
= mkfifo(path
, socket_mode
);
994 (void) umask(old_mask
);
996 if (r
< 0 && errno
!= EEXIST
) {
1001 fd
= open(path
, O_RDWR
| O_CLOEXEC
| O_NOCTTY
| O_NONBLOCK
| O_NOFOLLOW
);
1007 mac_selinux_create_file_clear();
1009 if (fstat(fd
, &st
) < 0) {
1014 if (!S_ISFIFO(st
.st_mode
) ||
1015 (st
.st_mode
& 0777) != (socket_mode
& ~old_mask
) ||
1016 st
.st_uid
!= getuid() ||
1017 st
.st_gid
!= getgid()) {
1028 mac_selinux_create_file_clear();
1034 static int special_address_create(const char *path
) {
1035 _cleanup_close_
int fd
= -1;
1041 fd
= open(path
, O_RDONLY
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1045 if (fstat(fd
, &st
) < 0)
1048 /* Check whether this is a /proc, /sys or /dev file or char device */
1049 if (!S_ISREG(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
1058 static int usbffs_address_create(const char *path
) {
1059 _cleanup_close_
int fd
= -1;
1065 fd
= open(path
, O_RDWR
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1069 if (fstat(fd
, &st
) < 0)
1072 /* Check whether this is a regular file (ffs endpoint)*/
1073 if (!S_ISREG(st
.st_mode
))
1082 static int mq_address_create(
1088 _cleanup_close_
int fd
= -1;
1091 struct mq_attr _attr
, *attr
= NULL
;
1096 if (maxmsg
> 0 && msgsize
> 0) {
1097 _attr
= (struct mq_attr
) {
1098 .mq_flags
= O_NONBLOCK
,
1099 .mq_maxmsg
= maxmsg
,
1100 .mq_msgsize
= msgsize
,
1105 /* Enforce the right access mode for the mq */
1106 old_mask
= umask(~ mq_mode
);
1108 /* Include the original umask in our mask */
1109 (void) umask(~mq_mode
| old_mask
);
1110 fd
= mq_open(path
, O_RDONLY
|O_CLOEXEC
|O_NONBLOCK
|O_CREAT
, mq_mode
, attr
);
1111 (void) umask(old_mask
);
1116 if (fstat(fd
, &st
) < 0)
1119 if ((st
.st_mode
& 0777) != (mq_mode
& ~old_mask
) ||
1120 st
.st_uid
!= getuid() ||
1121 st
.st_gid
!= getgid())
1130 static int socket_symlink(Socket
*s
) {
1136 p
= socket_find_symlink_target(s
);
1140 STRV_FOREACH(i
, s
->symlinks
)
1141 symlink_label(p
, *i
);
1146 static int usbffs_write_descs(int fd
, Service
*s
) {
1149 if (!s
->usb_function_descriptors
|| !s
->usb_function_strings
)
1152 r
= copy_file_fd(s
->usb_function_descriptors
, fd
, false);
1156 return copy_file_fd(s
->usb_function_strings
, fd
, false);
1159 static int usbffs_select_ep(const struct dirent
*d
) {
1160 return d
->d_name
[0] != '.' && !streq(d
->d_name
, "ep0");
1163 static int usbffs_dispatch_eps(SocketPort
*p
) {
1164 _cleanup_free_
struct dirent
**ent
= NULL
;
1165 _cleanup_free_
char *path
= NULL
;
1168 r
= path_get_parent(p
->path
, &path
);
1172 r
= scandir(path
, &ent
, usbffs_select_ep
, alphasort
);
1177 p
->auxiliary_fds
= new(int, n
);
1178 if (!p
->auxiliary_fds
)
1181 p
->n_auxiliary_fds
= n
;
1184 for (i
= 0; i
< n
; ++i
) {
1185 _cleanup_free_
char *ep
= NULL
;
1187 ep
= path_make_absolute(ent
[i
]->d_name
, path
);
1191 path_kill_slashes(ep
);
1193 r
= usbffs_address_create(ep
);
1197 p
->auxiliary_fds
[k
] = r
;
1206 close_many(p
->auxiliary_fds
, k
);
1207 p
->auxiliary_fds
= mfree(p
->auxiliary_fds
);
1208 p
->n_auxiliary_fds
= 0;
1213 static int socket_open_fds(Socket
*s
) {
1214 _cleanup_(mac_selinux_freep
) char *label
= NULL
;
1215 bool know_label
= false;
1221 LIST_FOREACH(port
, p
, s
->ports
) {
1231 /* Figure out label, if we don't it know
1232 * yet. We do it once, for the first
1233 * socket where we need this and
1234 * remember it for the rest. */
1236 if (s
->selinux_context_from_net
) {
1237 /* Get it from the network label */
1239 r
= mac_selinux_get_our_label(&label
);
1240 if (r
< 0 && r
!= -EOPNOTSUPP
)
1244 /* Get it from the executable we are about to start */
1246 r
= socket_instantiate_service(s
);
1250 if (UNIT_ISSET(s
->service
) &&
1251 SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]) {
1252 r
= mac_selinux_get_create_label_from_exe(SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]->path
, &label
);
1253 if (r
< 0 && r
!= -EPERM
&& r
!= -EOPNOTSUPP
)
1261 r
= socket_address_listen(
1263 SOCK_CLOEXEC
|SOCK_NONBLOCK
,
1277 socket_apply_socket_options(s
, p
->fd
);
1281 case SOCKET_SPECIAL
:
1283 p
->fd
= special_address_create(p
->path
);
1292 p
->fd
= fifo_address_create(
1301 socket_apply_fifo_options(s
, p
->fd
);
1307 p
->fd
= mq_address_create(
1318 case SOCKET_USB_FUNCTION
:
1320 p
->fd
= usbffs_address_create(p
->path
);
1326 r
= usbffs_write_descs(p
->fd
, SERVICE(UNIT_DEREF(s
->service
)));
1330 r
= usbffs_dispatch_eps(p
);
1337 assert_not_reached("Unknown port type");
1344 socket_close_fds(s
);
1348 static void socket_unwatch_fds(Socket
*s
) {
1354 LIST_FOREACH(port
, p
, s
->ports
) {
1358 if (!p
->event_source
)
1361 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_OFF
);
1363 log_unit_debug_errno(UNIT(s
), r
, "Failed to disable event source: %m");
1367 static int socket_watch_fds(Socket
*s
) {
1373 LIST_FOREACH(port
, p
, s
->ports
) {
1377 if (p
->event_source
) {
1378 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_ON
);
1382 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &p
->event_source
, p
->fd
, EPOLLIN
, socket_dispatch_io
, p
);
1386 (void) sd_event_source_set_description(p
->event_source
, "socket-port-io");
1393 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch listening fds: %m");
1394 socket_unwatch_fds(s
);
1398 static void socket_set_state(Socket
*s
, SocketState state
) {
1399 SocketState old_state
;
1402 old_state
= s
->state
;
1410 SOCKET_STOP_PRE_SIGTERM
,
1411 SOCKET_STOP_PRE_SIGKILL
,
1413 SOCKET_FINAL_SIGTERM
,
1414 SOCKET_FINAL_SIGKILL
)) {
1416 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1417 socket_unwatch_control_pid(s
);
1418 s
->control_command
= NULL
;
1419 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
1422 if (state
!= SOCKET_LISTENING
)
1423 socket_unwatch_fds(s
);
1431 SOCKET_STOP_PRE_SIGTERM
,
1432 SOCKET_STOP_PRE_SIGKILL
))
1433 socket_close_fds(s
);
1435 if (state
!= old_state
)
1436 log_unit_debug(UNIT(s
), "Changed %s -> %s", socket_state_to_string(old_state
), socket_state_to_string(state
));
1438 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
1441 static int socket_coldplug(Unit
*u
) {
1442 Socket
*s
= SOCKET(u
);
1446 assert(s
->state
== SOCKET_DEAD
);
1448 if (s
->deserialized_state
== s
->state
)
1451 if (IN_SET(s
->deserialized_state
,
1456 SOCKET_STOP_PRE_SIGTERM
,
1457 SOCKET_STOP_PRE_SIGKILL
,
1459 SOCKET_FINAL_SIGTERM
,
1460 SOCKET_FINAL_SIGKILL
)) {
1462 if (s
->control_pid
<= 0)
1465 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1469 r
= socket_arm_timer(s
);
1474 if (IN_SET(s
->deserialized_state
,
1480 SOCKET_STOP_PRE_SIGTERM
,
1481 SOCKET_STOP_PRE_SIGKILL
)) {
1482 r
= socket_open_fds(s
);
1487 if (s
->deserialized_state
== SOCKET_LISTENING
) {
1488 r
= socket_watch_fds(s
);
1493 socket_set_state(s
, s
->deserialized_state
);
1497 static int socket_spawn(Socket
*s
, ExecCommand
*c
, pid_t
*_pid
) {
1498 _cleanup_free_
char **argv
= NULL
;
1501 ExecParameters exec_params
= {
1502 .apply_permissions
= true,
1503 .apply_chroot
= true,
1504 .apply_tty_stdin
= true,
1505 .bus_endpoint_fd
= -1,
1512 (void) unit_realize_cgroup(UNIT(s
));
1513 if (s
->reset_cpu_usage
) {
1514 (void) unit_reset_cpu_usage(UNIT(s
));
1515 s
->reset_cpu_usage
= false;
1518 r
= unit_setup_exec_runtime(UNIT(s
));
1522 r
= socket_arm_timer(s
);
1526 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1530 exec_params
.argv
= argv
;
1531 exec_params
.environment
= UNIT(s
)->manager
->environment
;
1532 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1533 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1534 exec_params
.cgroup_path
= UNIT(s
)->cgroup_path
;
1535 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1536 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1538 r
= exec_spawn(UNIT(s
),
1547 r
= unit_watch_pid(UNIT(s
), pid
);
1549 /* FIXME: we need to do something here */
1556 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1560 static int socket_chown(Socket
*s
, pid_t
*_pid
) {
1564 r
= socket_arm_timer(s
);
1568 /* We have to resolve the user names out-of-process, hence
1569 * let's fork here. It's messy, but well, what can we do? */
1577 uid_t uid
= UID_INVALID
;
1578 gid_t gid
= GID_INVALID
;
1581 (void) default_signals(SIGNALS_CRASH_HANDLER
, SIGNALS_IGNORE
, -1);
1582 (void) ignore_signals(SIGPIPE
, -1);
1585 if (!isempty(s
->user
)) {
1586 const char *user
= s
->user
;
1588 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
);
1595 if (!isempty(s
->group
)) {
1596 const char *group
= s
->group
;
1598 r
= get_group_creds(&group
, &gid
);
1605 LIST_FOREACH(port
, p
, s
->ports
) {
1606 const char *path
= NULL
;
1608 if (p
->type
== SOCKET_SOCKET
)
1609 path
= socket_address_get_path(&p
->address
);
1610 else if (p
->type
== SOCKET_FIFO
)
1616 if (chown(path
, uid
, gid
) < 0) {
1627 log_error_errno(r
, "Failed to chown socket at step %s: %m", exit_status_to_string(ret
, EXIT_STATUS_SYSTEMD
));
1632 r
= unit_watch_pid(UNIT(s
), pid
);
1640 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1644 static void socket_enter_dead(Socket
*s
, SocketResult f
) {
1647 if (f
!= SOCKET_SUCCESS
)
1650 exec_runtime_destroy(s
->exec_runtime
);
1651 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1653 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1655 socket_set_state(s
, s
->result
!= SOCKET_SUCCESS
? SOCKET_FAILED
: SOCKET_DEAD
);
1658 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
);
1660 static void socket_enter_stop_post(Socket
*s
, SocketResult f
) {
1664 if (f
!= SOCKET_SUCCESS
)
1667 socket_unwatch_control_pid(s
);
1668 s
->control_command_id
= SOCKET_EXEC_STOP_POST
;
1669 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_POST
];
1671 if (s
->control_command
) {
1672 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1676 socket_set_state(s
, SOCKET_STOP_POST
);
1678 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_SUCCESS
);
1683 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1684 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
1687 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
) {
1692 if (f
!= SOCKET_SUCCESS
)
1695 r
= unit_kill_context(
1698 (state
!= SOCKET_STOP_PRE_SIGTERM
&& state
!= SOCKET_FINAL_SIGTERM
) ?
1699 KILL_KILL
: KILL_TERMINATE
,
1707 r
= socket_arm_timer(s
);
1711 socket_set_state(s
, state
);
1712 } else if (state
== SOCKET_STOP_PRE_SIGTERM
)
1713 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_SUCCESS
);
1714 else if (state
== SOCKET_STOP_PRE_SIGKILL
)
1715 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1716 else if (state
== SOCKET_FINAL_SIGTERM
)
1717 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_SUCCESS
);
1719 socket_enter_dead(s
, SOCKET_SUCCESS
);
1724 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1726 if (state
== SOCKET_STOP_PRE_SIGTERM
|| state
== SOCKET_STOP_PRE_SIGKILL
)
1727 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1729 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1732 static void socket_enter_stop_pre(Socket
*s
, SocketResult f
) {
1736 if (f
!= SOCKET_SUCCESS
)
1739 socket_unwatch_control_pid(s
);
1740 s
->control_command_id
= SOCKET_EXEC_STOP_PRE
;
1741 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_PRE
];
1743 if (s
->control_command
) {
1744 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1748 socket_set_state(s
, SOCKET_STOP_PRE
);
1750 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1755 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-pre' task: %m");
1756 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1759 static void socket_enter_listening(Socket
*s
) {
1763 r
= socket_watch_fds(s
);
1765 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1769 socket_set_state(s
, SOCKET_LISTENING
);
1773 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1776 static void socket_enter_start_post(Socket
*s
) {
1780 socket_unwatch_control_pid(s
);
1781 s
->control_command_id
= SOCKET_EXEC_START_POST
;
1782 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_POST
];
1784 if (s
->control_command
) {
1785 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1787 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1791 socket_set_state(s
, SOCKET_START_POST
);
1793 socket_enter_listening(s
);
1798 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1801 static void socket_enter_start_chown(Socket
*s
) {
1806 r
= socket_open_fds(s
);
1808 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1812 if (!isempty(s
->user
) || !isempty(s
->group
)) {
1814 socket_unwatch_control_pid(s
);
1815 s
->control_command_id
= SOCKET_EXEC_START_CHOWN
;
1816 s
->control_command
= NULL
;
1818 r
= socket_chown(s
, &s
->control_pid
);
1820 log_unit_warning_errno(UNIT(s
), r
, "Failed to fork 'start-chown' task: %m");
1824 socket_set_state(s
, SOCKET_START_CHOWN
);
1826 socket_enter_start_post(s
);
1831 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1834 static void socket_enter_start_pre(Socket
*s
) {
1838 socket_unwatch_control_pid(s
);
1839 s
->control_command_id
= SOCKET_EXEC_START_PRE
;
1840 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_PRE
];
1842 if (s
->control_command
) {
1843 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1845 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1849 socket_set_state(s
, SOCKET_START_PRE
);
1851 socket_enter_start_chown(s
);
1856 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1859 static void socket_enter_running(Socket
*s
, int cfd
) {
1860 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1865 /* We don't take connections anymore if we are supposed to
1866 * shut down anyway */
1867 if (unit_stop_pending(UNIT(s
))) {
1869 log_unit_debug(UNIT(s
), "Suppressing connection request since unit stop is scheduled.");
1874 /* Flush all sockets by closing and reopening them */
1875 socket_close_fds(s
);
1877 r
= socket_open_fds(s
);
1879 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1880 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1884 r
= socket_watch_fds(s
);
1886 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1887 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1897 bool pending
= false;
1899 /* If there's already a start pending don't bother to
1901 SET_FOREACH(other
, UNIT(s
)->dependencies
[UNIT_TRIGGERS
], i
)
1902 if (unit_active_or_pending(other
)) {
1908 if (!UNIT_ISSET(s
->service
)) {
1909 log_unit_error(UNIT(s
), "Service to activate vanished, refusing activation.");
1914 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT_DEREF(s
->service
), JOB_REPLACE
, true, &error
, NULL
);
1919 socket_set_state(s
, SOCKET_RUNNING
);
1921 _cleanup_free_
char *prefix
= NULL
, *instance
= NULL
, *name
= NULL
;
1924 if (s
->n_connections
>= s
->max_connections
) {
1925 log_unit_warning(UNIT(s
), "Too many incoming connections (%u)", s
->n_connections
);
1930 r
= socket_instantiate_service(s
);
1934 r
= instance_from_socket(cfd
, s
->n_accepted
, &instance
);
1939 /* ENOTCONN is legitimate if TCP RST was received.
1940 * This connection is over, but the socket unit lives on. */
1945 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
1949 r
= unit_name_build(prefix
, instance
, ".service", &name
);
1953 r
= unit_add_name(UNIT_DEREF(s
->service
), name
);
1957 service
= SERVICE(UNIT_DEREF(s
->service
));
1958 unit_ref_unset(&s
->service
);
1961 UNIT(service
)->no_gc
= false;
1963 unit_choose_id(UNIT(service
), name
);
1965 r
= service_set_socket_fd(service
, cfd
, s
, s
->selinux_context_from_net
);
1970 s
->n_connections
++;
1972 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT(service
), JOB_REPLACE
, true, &error
, NULL
);
1976 /* Notify clients about changed counters */
1977 unit_add_to_dbus_queue(UNIT(s
));
1983 log_unit_warning(UNIT(s
), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1984 cfd
>= 0 ? "template" : "non-template",
1985 bus_error_message(&error
, r
));
1987 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1991 static void socket_run_next(Socket
*s
) {
1995 assert(s
->control_command
);
1996 assert(s
->control_command
->command_next
);
1998 socket_unwatch_control_pid(s
);
2000 s
->control_command
= s
->control_command
->command_next
;
2002 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
2009 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next task: %m");
2011 if (s
->state
== SOCKET_START_POST
)
2012 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
2013 else if (s
->state
== SOCKET_STOP_POST
)
2014 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
2016 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
2019 static int socket_start(Unit
*u
) {
2020 Socket
*s
= SOCKET(u
);
2024 /* We cannot fulfill this request right now, try again later
2026 if (IN_SET(s
->state
,
2028 SOCKET_STOP_PRE_SIGKILL
,
2029 SOCKET_STOP_PRE_SIGTERM
,
2031 SOCKET_FINAL_SIGTERM
,
2032 SOCKET_FINAL_SIGKILL
))
2035 /* Already on it! */
2036 if (IN_SET(s
->state
,
2042 /* Cannot run this without the service being around */
2043 if (UNIT_ISSET(s
->service
)) {
2046 service
= SERVICE(UNIT_DEREF(s
->service
));
2048 if (UNIT(service
)->load_state
!= UNIT_LOADED
) {
2049 log_unit_error(u
, "Socket service %s not loaded, refusing.", UNIT(service
)->id
);
2053 /* If the service is already active we cannot start the
2055 if (service
->state
!= SERVICE_DEAD
&&
2056 service
->state
!= SERVICE_FAILED
&&
2057 service
->state
!= SERVICE_AUTO_RESTART
) {
2058 log_unit_error(u
, "Socket service %s already active, refusing.", UNIT(service
)->id
);
2063 assert(s
->state
== SOCKET_DEAD
|| s
->state
== SOCKET_FAILED
);
2065 s
->result
= SOCKET_SUCCESS
;
2066 s
->reset_cpu_usage
= true;
2068 socket_enter_start_pre(s
);
2073 static int socket_stop(Unit
*u
) {
2074 Socket
*s
= SOCKET(u
);
2079 if (IN_SET(s
->state
,
2081 SOCKET_STOP_PRE_SIGTERM
,
2082 SOCKET_STOP_PRE_SIGKILL
,
2084 SOCKET_FINAL_SIGTERM
,
2085 SOCKET_FINAL_SIGKILL
))
2088 /* If there's already something running we go directly into
2090 if (IN_SET(s
->state
,
2093 SOCKET_START_POST
)) {
2094 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_SUCCESS
);
2098 assert(s
->state
== SOCKET_LISTENING
|| s
->state
== SOCKET_RUNNING
);
2100 socket_enter_stop_pre(s
, SOCKET_SUCCESS
);
2104 static int socket_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2105 Socket
*s
= SOCKET(u
);
2113 unit_serialize_item(u
, f
, "state", socket_state_to_string(s
->state
));
2114 unit_serialize_item(u
, f
, "result", socket_result_to_string(s
->result
));
2115 unit_serialize_item_format(u
, f
, "n-accepted", "%u", s
->n_accepted
);
2117 if (s
->control_pid
> 0)
2118 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2120 if (s
->control_command_id
>= 0)
2121 unit_serialize_item(u
, f
, "control-command", socket_exec_command_to_string(s
->control_command_id
));
2123 LIST_FOREACH(port
, p
, s
->ports
) {
2129 copy
= fdset_put_dup(fds
, p
->fd
);
2133 if (p
->type
== SOCKET_SOCKET
) {
2134 _cleanup_free_
char *t
= NULL
;
2136 r
= socket_address_print(&p
->address
, &t
);
2140 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2141 unit_serialize_item_format(u
, f
, "netlink", "%i %s", copy
, t
);
2143 unit_serialize_item_format(u
, f
, "socket", "%i %i %s", copy
, p
->address
.type
, t
);
2145 } else if (p
->type
== SOCKET_SPECIAL
)
2146 unit_serialize_item_format(u
, f
, "special", "%i %s", copy
, p
->path
);
2147 else if (p
->type
== SOCKET_MQUEUE
)
2148 unit_serialize_item_format(u
, f
, "mqueue", "%i %s", copy
, p
->path
);
2149 else if (p
->type
== SOCKET_USB_FUNCTION
)
2150 unit_serialize_item_format(u
, f
, "ffs", "%i %s", copy
, p
->path
);
2152 assert(p
->type
== SOCKET_FIFO
);
2153 unit_serialize_item_format(u
, f
, "fifo", "%i %s", copy
, p
->path
);
2160 static int socket_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2161 Socket
*s
= SOCKET(u
);
2167 if (streq(key
, "state")) {
2170 state
= socket_state_from_string(value
);
2172 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2174 s
->deserialized_state
= state
;
2175 } else if (streq(key
, "result")) {
2178 f
= socket_result_from_string(value
);
2180 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2181 else if (f
!= SOCKET_SUCCESS
)
2184 } else if (streq(key
, "n-accepted")) {
2187 if (safe_atou(value
, &k
) < 0)
2188 log_unit_debug(u
, "Failed to parse n-accepted value: %s", value
);
2191 } else if (streq(key
, "control-pid")) {
2194 if (parse_pid(value
, &pid
) < 0)
2195 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2197 s
->control_pid
= pid
;
2198 } else if (streq(key
, "control-command")) {
2199 SocketExecCommand id
;
2201 id
= socket_exec_command_from_string(value
);
2203 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2205 s
->control_command_id
= id
;
2206 s
->control_command
= s
->exec_command
[id
];
2208 } else if (streq(key
, "fifo")) {
2212 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2213 log_unit_debug(u
, "Failed to parse fifo value: %s", value
);
2216 LIST_FOREACH(port
, p
, s
->ports
)
2217 if (p
->type
== SOCKET_FIFO
&&
2218 path_equal_or_files_same(p
->path
, value
+skip
))
2223 p
->fd
= fdset_remove(fds
, fd
);
2227 } else if (streq(key
, "special")) {
2231 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2232 log_unit_debug(u
, "Failed to parse special value: %s", value
);
2235 LIST_FOREACH(port
, p
, s
->ports
)
2236 if (p
->type
== SOCKET_SPECIAL
&&
2237 path_equal_or_files_same(p
->path
, value
+skip
))
2242 p
->fd
= fdset_remove(fds
, fd
);
2246 } else if (streq(key
, "mqueue")) {
2250 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2251 log_unit_debug(u
, "Failed to parse mqueue value: %s", value
);
2254 LIST_FOREACH(port
, p
, s
->ports
)
2255 if (p
->type
== SOCKET_MQUEUE
&&
2256 streq(p
->path
, value
+skip
))
2261 p
->fd
= fdset_remove(fds
, fd
);
2265 } else if (streq(key
, "socket")) {
2266 int fd
, type
, skip
= 0;
2269 if (sscanf(value
, "%i %i %n", &fd
, &type
, &skip
) < 2 || fd
< 0 || type
< 0 || !fdset_contains(fds
, fd
))
2270 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2273 LIST_FOREACH(port
, p
, s
->ports
)
2274 if (socket_address_is(&p
->address
, value
+skip
, type
))
2279 p
->fd
= fdset_remove(fds
, fd
);
2283 } else if (streq(key
, "netlink")) {
2287 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2288 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2291 LIST_FOREACH(port
, p
, s
->ports
)
2292 if (socket_address_is_netlink(&p
->address
, value
+skip
))
2297 p
->fd
= fdset_remove(fds
, fd
);
2301 } else if (streq(key
, "ffs")) {
2305 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2306 log_unit_debug(u
, "Failed to parse ffs value: %s", value
);
2309 LIST_FOREACH(port
, p
, s
->ports
)
2310 if (p
->type
== SOCKET_USB_FUNCTION
&&
2311 path_equal_or_files_same(p
->path
, value
+skip
))
2316 p
->fd
= fdset_remove(fds
, fd
);
2321 log_unit_debug(UNIT(s
), "Unknown serialization key: %s", key
);
2326 static int socket_distribute_fds(Unit
*u
, FDSet
*fds
) {
2327 Socket
*s
= SOCKET(u
);
2332 LIST_FOREACH(port
, p
, s
->ports
) {
2336 if (p
->type
!= SOCKET_SOCKET
)
2342 FDSET_FOREACH(fd
, fds
, i
) {
2343 if (socket_address_matches_fd(&p
->address
, fd
)) {
2344 p
->fd
= fdset_remove(fds
, fd
);
2345 s
->deserialized_state
= SOCKET_LISTENING
;
2354 _pure_
static UnitActiveState
socket_active_state(Unit
*u
) {
2357 return state_translation_table
[SOCKET(u
)->state
];
2360 _pure_
static const char *socket_sub_state_to_string(Unit
*u
) {
2363 return socket_state_to_string(SOCKET(u
)->state
);
2366 const char* socket_port_type_to_string(SocketPort
*p
) {
2374 switch (p
->address
.type
) {
2382 case SOCK_SEQPACKET
:
2383 return "SequentialPacket";
2386 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2393 case SOCKET_SPECIAL
:
2397 return "MessageQueue";
2402 case SOCKET_USB_FUNCTION
:
2403 return "USBFunction";
2410 _pure_
static bool socket_check_gc(Unit
*u
) {
2411 Socket
*s
= SOCKET(u
);
2415 return s
->n_connections
> 0;
2418 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
2419 SocketPort
*p
= userdata
;
2425 if (p
->socket
->state
!= SOCKET_LISTENING
)
2428 log_unit_debug(UNIT(p
->socket
), "Incoming traffic");
2430 if (revents
!= EPOLLIN
) {
2432 if (revents
& EPOLLHUP
)
2433 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.");
2435 log_unit_error(UNIT(p
->socket
), "Got unexpected poll event (0x%x) on socket.", revents
);
2439 if (p
->socket
->accept
&&
2440 p
->type
== SOCKET_SOCKET
&&
2441 socket_address_can_accept(&p
->address
)) {
2445 cfd
= accept4(fd
, NULL
, NULL
, SOCK_NONBLOCK
);
2451 log_unit_error_errno(UNIT(p
->socket
), errno
, "Failed to accept socket: %m");
2458 socket_apply_socket_options(p
->socket
, cfd
);
2461 socket_enter_running(p
->socket
, cfd
);
2465 socket_enter_stop_pre(p
->socket
, SOCKET_FAILURE_RESOURCES
);
2469 static void socket_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2470 Socket
*s
= SOCKET(u
);
2476 if (pid
!= s
->control_pid
)
2481 if (is_clean_exit(code
, status
, NULL
))
2483 else if (code
== CLD_EXITED
)
2484 f
= SOCKET_FAILURE_EXIT_CODE
;
2485 else if (code
== CLD_KILLED
)
2486 f
= SOCKET_FAILURE_SIGNAL
;
2487 else if (code
== CLD_DUMPED
)
2488 f
= SOCKET_FAILURE_CORE_DUMP
;
2490 assert_not_reached("Unknown sigchld code");
2492 if (s
->control_command
) {
2493 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2495 if (s
->control_command
->ignore
)
2499 log_unit_full(u
, f
== SOCKET_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2500 "Control process exited, code=%s status=%i",
2501 sigchld_code_to_string(code
), status
);
2503 if (f
!= SOCKET_SUCCESS
)
2506 if (s
->control_command
&&
2507 s
->control_command
->command_next
&&
2508 f
== SOCKET_SUCCESS
) {
2510 log_unit_debug(u
, "Running next command for state %s", socket_state_to_string(s
->state
));
2513 s
->control_command
= NULL
;
2514 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
2516 /* No further commands for this step, so let's figure
2517 * out what to do next */
2519 log_unit_debug(u
, "Got final SIGCHLD for state %s", socket_state_to_string(s
->state
));
2523 case SOCKET_START_PRE
:
2524 if (f
== SOCKET_SUCCESS
)
2525 socket_enter_start_chown(s
);
2527 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, f
);
2530 case SOCKET_START_CHOWN
:
2531 if (f
== SOCKET_SUCCESS
)
2532 socket_enter_start_post(s
);
2534 socket_enter_stop_pre(s
, f
);
2537 case SOCKET_START_POST
:
2538 if (f
== SOCKET_SUCCESS
)
2539 socket_enter_listening(s
);
2541 socket_enter_stop_pre(s
, f
);
2544 case SOCKET_STOP_PRE
:
2545 case SOCKET_STOP_PRE_SIGTERM
:
2546 case SOCKET_STOP_PRE_SIGKILL
:
2547 socket_enter_stop_post(s
, f
);
2550 case SOCKET_STOP_POST
:
2551 case SOCKET_FINAL_SIGTERM
:
2552 case SOCKET_FINAL_SIGKILL
:
2553 socket_enter_dead(s
, f
);
2557 assert_not_reached("Uh, control process died at wrong time.");
2561 /* Notify clients about changed exit status */
2562 unit_add_to_dbus_queue(u
);
2565 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2566 Socket
*s
= SOCKET(userdata
);
2569 assert(s
->timer_event_source
== source
);
2573 case SOCKET_START_PRE
:
2574 log_unit_warning(UNIT(s
), "Starting timed out. Terminating.");
2575 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2578 case SOCKET_START_CHOWN
:
2579 case SOCKET_START_POST
:
2580 log_unit_warning(UNIT(s
), "Starting timed out. Stopping.");
2581 socket_enter_stop_pre(s
, SOCKET_FAILURE_TIMEOUT
);
2584 case SOCKET_STOP_PRE
:
2585 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2586 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2589 case SOCKET_STOP_PRE_SIGTERM
:
2590 if (s
->kill_context
.send_sigkill
) {
2591 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
2592 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2594 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL. Ignoring.");
2595 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2599 case SOCKET_STOP_PRE_SIGKILL
:
2600 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2601 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2604 case SOCKET_STOP_POST
:
2605 log_unit_warning(UNIT(s
), "Stopping timed out (2). Terminating.");
2606 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2609 case SOCKET_FINAL_SIGTERM
:
2610 if (s
->kill_context
.send_sigkill
) {
2611 log_unit_warning(UNIT(s
), "Stopping timed out (2). Killing.");
2612 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2614 log_unit_warning(UNIT(s
), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
2615 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2619 case SOCKET_FINAL_SIGKILL
:
2620 log_unit_warning(UNIT(s
), "Still around after SIGKILL (2). Entering failed mode.");
2621 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2625 assert_not_reached("Timeout at wrong time.");
2631 int socket_collect_fds(Socket
*s
, int **fds
, unsigned *n_fds
) {
2641 /* Called from the service code for requesting our fds */
2644 LIST_FOREACH(port
, p
, s
->ports
) {
2647 rn_fds
+= p
->n_auxiliary_fds
;
2656 rfds
= new(int, rn_fds
);
2661 LIST_FOREACH(port
, p
, s
->ports
) {
2664 for (i
= 0; i
< p
->n_auxiliary_fds
; ++i
)
2665 rfds
[k
++] = p
->auxiliary_fds
[i
];
2668 assert(k
== rn_fds
);
2676 static void socket_reset_failed(Unit
*u
) {
2677 Socket
*s
= SOCKET(u
);
2681 if (s
->state
== SOCKET_FAILED
)
2682 socket_set_state(s
, SOCKET_DEAD
);
2684 s
->result
= SOCKET_SUCCESS
;
2687 static void socket_notify_service_dead(Socket
*s
, bool failed_permanent
) {
2690 /* The service is dead. Dang!
2692 * This is strictly for one-instance-for-all-connections
2695 if (s
->state
== SOCKET_RUNNING
) {
2696 log_unit_debug(UNIT(s
), "Got notified about service death (failed permanently: %s)", yes_no(failed_permanent
));
2697 if (failed_permanent
)
2698 socket_enter_stop_pre(s
, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
);
2700 socket_enter_listening(s
);
2704 void socket_connection_unref(Socket
*s
) {
2707 /* The service is dead. Yay!
2709 * This is strictly for one-instance-per-connection
2712 assert(s
->n_connections
> 0);
2715 log_unit_debug(UNIT(s
), "One connection closed, %u left.", s
->n_connections
);
2718 static void socket_trigger_notify(Unit
*u
, Unit
*other
) {
2719 Socket
*s
= SOCKET(u
);
2725 /* Don't propagate state changes from the service if we are
2726 already down or accepting connections */
2727 if ((s
->state
!= SOCKET_RUNNING
&&
2728 s
->state
!= SOCKET_LISTENING
) ||
2732 if (other
->load_state
!= UNIT_LOADED
||
2733 other
->type
!= UNIT_SERVICE
)
2736 se
= SERVICE(other
);
2738 if (se
->state
== SERVICE_FAILED
)
2739 socket_notify_service_dead(s
, se
->result
== SERVICE_FAILURE_START_LIMIT
);
2741 if (se
->state
== SERVICE_DEAD
||
2742 se
->state
== SERVICE_FINAL_SIGTERM
||
2743 se
->state
== SERVICE_FINAL_SIGKILL
||
2744 se
->state
== SERVICE_AUTO_RESTART
)
2745 socket_notify_service_dead(s
, false);
2747 if (se
->state
== SERVICE_RUNNING
)
2748 socket_set_state(s
, SOCKET_RUNNING
);
2751 static int socket_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
2752 return unit_kill_common(u
, who
, signo
, -1, SOCKET(u
)->control_pid
, error
);
2755 static int socket_get_timeout(Unit
*u
, uint64_t *timeout
) {
2756 Socket
*s
= SOCKET(u
);
2759 if (!s
->timer_event_source
)
2762 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
2769 static const char* const socket_exec_command_table
[_SOCKET_EXEC_COMMAND_MAX
] = {
2770 [SOCKET_EXEC_START_PRE
] = "StartPre",
2771 [SOCKET_EXEC_START_CHOWN
] = "StartChown",
2772 [SOCKET_EXEC_START_POST
] = "StartPost",
2773 [SOCKET_EXEC_STOP_PRE
] = "StopPre",
2774 [SOCKET_EXEC_STOP_POST
] = "StopPost"
2777 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command
, SocketExecCommand
);
2779 static const char* const socket_result_table
[_SOCKET_RESULT_MAX
] = {
2780 [SOCKET_SUCCESS
] = "success",
2781 [SOCKET_FAILURE_RESOURCES
] = "resources",
2782 [SOCKET_FAILURE_TIMEOUT
] = "timeout",
2783 [SOCKET_FAILURE_EXIT_CODE
] = "exit-code",
2784 [SOCKET_FAILURE_SIGNAL
] = "signal",
2785 [SOCKET_FAILURE_CORE_DUMP
] = "core-dump",
2786 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
] = "service-failed-permanent"
2789 DEFINE_STRING_TABLE_LOOKUP(socket_result
, SocketResult
);
2791 const UnitVTable socket_vtable
= {
2792 .object_size
= sizeof(Socket
),
2793 .exec_context_offset
= offsetof(Socket
, exec_context
),
2794 .cgroup_context_offset
= offsetof(Socket
, cgroup_context
),
2795 .kill_context_offset
= offsetof(Socket
, kill_context
),
2796 .exec_runtime_offset
= offsetof(Socket
, exec_runtime
),
2802 .private_section
= "Socket",
2804 .init
= socket_init
,
2805 .done
= socket_done
,
2806 .load
= socket_load
,
2808 .coldplug
= socket_coldplug
,
2810 .dump
= socket_dump
,
2812 .start
= socket_start
,
2813 .stop
= socket_stop
,
2815 .kill
= socket_kill
,
2817 .get_timeout
= socket_get_timeout
,
2819 .serialize
= socket_serialize
,
2820 .deserialize_item
= socket_deserialize_item
,
2821 .distribute_fds
= socket_distribute_fds
,
2823 .active_state
= socket_active_state
,
2824 .sub_state_to_string
= socket_sub_state_to_string
,
2826 .check_gc
= socket_check_gc
,
2828 .sigchld_event
= socket_sigchld_event
,
2830 .trigger_notify
= socket_trigger_notify
,
2832 .reset_failed
= socket_reset_failed
,
2834 .bus_vtable
= bus_socket_vtable
,
2835 .bus_set_property
= bus_socket_set_property
,
2836 .bus_commit_properties
= bus_socket_commit_properties
,
2838 .status_message_formats
= {
2839 /*.starting_stopping = {
2840 [0] = "Starting socket %s...",
2841 [1] = "Stopping socket %s...",
2843 .finished_start_job
= {
2844 [JOB_DONE
] = "Listening on %s.",
2845 [JOB_FAILED
] = "Failed to listen on %s.",
2846 [JOB_TIMEOUT
] = "Timed out starting %s.",
2848 .finished_stop_job
= {
2849 [JOB_DONE
] = "Closed %s.",
2850 [JOB_FAILED
] = "Failed stopping %s.",
2851 [JOB_TIMEOUT
] = "Timed out stopping %s.",