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 if ((r
= socket_address_print(&p
->address
, &k
)) < 0)
651 fprintf(f
, "%s%s: %s\n", prefix
, listen_lookup(socket_address_family(&p
->address
), p
->address
.type
), t
);
653 } else if (p
->type
== SOCKET_SPECIAL
)
654 fprintf(f
, "%sListenSpecial: %s\n", prefix
, p
->path
);
655 else if (p
->type
== SOCKET_USB_FUNCTION
)
656 fprintf(f
, "%sListenUSBFunction: %s\n", prefix
, p
->path
);
657 else if (p
->type
== SOCKET_MQUEUE
)
658 fprintf(f
, "%sListenMessageQueue: %s\n", prefix
, p
->path
);
660 fprintf(f
, "%sListenFIFO: %s\n", prefix
, p
->path
);
663 exec_context_dump(&s
->exec_context
, f
, prefix
);
664 kill_context_dump(&s
->kill_context
, f
, prefix
);
666 for (c
= 0; c
< _SOCKET_EXEC_COMMAND_MAX
; c
++) {
667 if (!s
->exec_command
[c
])
670 fprintf(f
, "%s-> %s:\n",
671 prefix
, socket_exec_command_to_string(c
));
673 exec_command_dump_list(s
->exec_command
[c
], f
, prefix2
);
677 static int instance_from_socket(int fd
, unsigned nr
, char **instance
) {
680 union sockaddr_union local
, remote
;
686 if (getsockname(fd
, &local
.sa
, &l
) < 0)
690 if (getpeername(fd
, &remote
.sa
, &l
) < 0)
693 switch (local
.sa
.sa_family
) {
697 a
= ntohl(local
.in
.sin_addr
.s_addr
),
698 b
= ntohl(remote
.in
.sin_addr
.s_addr
);
701 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
703 a
>> 24, (a
>> 16) & 0xFF, (a
>> 8) & 0xFF, a
& 0xFF,
704 ntohs(local
.in
.sin_port
),
705 b
>> 24, (b
>> 16) & 0xFF, (b
>> 8) & 0xFF, b
& 0xFF,
706 ntohs(remote
.in
.sin_port
)) < 0)
713 static const unsigned char ipv4_prefix
[] = {
714 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
717 if (memcmp(&local
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0 &&
718 memcmp(&remote
.in6
.sin6_addr
, ipv4_prefix
, sizeof(ipv4_prefix
)) == 0) {
720 *a
= local
.in6
.sin6_addr
.s6_addr
+12,
721 *b
= remote
.in6
.sin6_addr
.s6_addr
+12;
724 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
726 a
[0], a
[1], a
[2], a
[3],
727 ntohs(local
.in6
.sin6_port
),
728 b
[0], b
[1], b
[2], b
[3],
729 ntohs(remote
.in6
.sin6_port
)) < 0)
732 char a
[INET6_ADDRSTRLEN
], b
[INET6_ADDRSTRLEN
];
737 inet_ntop(AF_INET6
, &local
.in6
.sin6_addr
, a
, sizeof(a
)),
738 ntohs(local
.in6
.sin6_port
),
739 inet_ntop(AF_INET6
, &remote
.in6
.sin6_addr
, b
, sizeof(b
)),
740 ntohs(remote
.in6
.sin6_port
)) < 0)
751 k
= getpeercred(fd
, &ucred
);
754 "%u-"PID_FMT
"-"UID_FMT
,
755 nr
, ucred
.pid
, ucred
.uid
) < 0)
757 } else if (k
== -ENODATA
) {
758 /* This handles the case where somebody is
759 * connecting from another pid/uid namespace
760 * (e.g. from outside of our container). */
772 assert_not_reached("Unhandled socket type.");
779 static void socket_close_fds(Socket
*s
) {
785 LIST_FOREACH(port
, p
, s
->ports
) {
787 p
->event_source
= sd_event_source_unref(p
->event_source
);
792 p
->fd
= safe_close(p
->fd
);
793 socket_cleanup_fd_list(p
);
795 /* One little note: we should normally not delete any
796 * sockets in the file system here! After all some
797 * other process we spawned might still have a
798 * reference of this fd and wants to continue to use
799 * it. Therefore we delete sockets in the file system
800 * before we create a new one, not after we stopped
803 if (s
->remove_on_stop
) {
815 socket_address_unlink(&p
->address
);
824 if (s
->remove_on_stop
)
825 STRV_FOREACH(i
, s
->symlinks
)
829 static void socket_apply_socket_options(Socket
*s
, int fd
) {
836 int b
= s
->keep_alive
;
837 if (setsockopt(fd
, SOL_SOCKET
, SO_KEEPALIVE
, &b
, sizeof(b
)) < 0)
838 log_unit_warning_errno(UNIT(s
), errno
, "SO_KEEPALIVE failed: %m");
841 if (s
->keep_alive_time
) {
842 int value
= s
->keep_alive_time
/ USEC_PER_SEC
;
843 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPIDLE
, &value
, sizeof(value
)) < 0)
844 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPIDLE failed: %m");
847 if (s
->keep_alive_interval
) {
848 int value
= s
->keep_alive_interval
/ USEC_PER_SEC
;
849 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPINTVL
, &value
, sizeof(value
)) < 0)
850 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPINTVL failed: %m");
853 if (s
->keep_alive_cnt
) {
854 int value
= s
->keep_alive_cnt
;
855 if (setsockopt(fd
, SOL_TCP
, TCP_KEEPCNT
, &value
, sizeof(value
)) < 0)
856 log_unit_warning_errno(UNIT(s
), errno
, "TCP_KEEPCNT failed: %m");
859 if (s
->defer_accept
) {
860 int value
= s
->defer_accept
/ USEC_PER_SEC
;
861 if (setsockopt(fd
, SOL_TCP
, TCP_DEFER_ACCEPT
, &value
, sizeof(value
)) < 0)
862 log_unit_warning_errno(UNIT(s
), errno
, "TCP_DEFER_ACCEPT failed: %m");
867 if (setsockopt(fd
, SOL_TCP
, TCP_NODELAY
, &b
, sizeof(b
)) < 0)
868 log_unit_warning_errno(UNIT(s
), errno
, "TCP_NODELAY failed: %m");
873 if (setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
, &one
, sizeof(one
)) < 0)
874 log_unit_warning_errno(UNIT(s
), errno
, "SO_BROADCAST failed: %m");
879 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSCRED
, &one
, sizeof(one
)) < 0)
880 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSCRED failed: %m");
885 if (setsockopt(fd
, SOL_SOCKET
, SO_PASSSEC
, &one
, sizeof(one
)) < 0)
886 log_unit_warning_errno(UNIT(s
), errno
, "SO_PASSSEC failed: %m");
889 if (s
->priority
>= 0)
890 if (setsockopt(fd
, SOL_SOCKET
, SO_PRIORITY
, &s
->priority
, sizeof(s
->priority
)) < 0)
891 log_unit_warning_errno(UNIT(s
), errno
, "SO_PRIORITY failed: %m");
893 if (s
->receive_buffer
> 0) {
894 int value
= (int) s
->receive_buffer
;
896 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
898 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUFFORCE
, &value
, sizeof(value
)) < 0)
899 if (setsockopt(fd
, SOL_SOCKET
, SO_RCVBUF
, &value
, sizeof(value
)) < 0)
900 log_unit_warning_errno(UNIT(s
), errno
, "SO_RCVBUF failed: %m");
903 if (s
->send_buffer
> 0) {
904 int value
= (int) s
->send_buffer
;
905 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUFFORCE
, &value
, sizeof(value
)) < 0)
906 if (setsockopt(fd
, SOL_SOCKET
, SO_SNDBUF
, &value
, sizeof(value
)) < 0)
907 log_unit_warning_errno(UNIT(s
), errno
, "SO_SNDBUF failed: %m");
911 if (setsockopt(fd
, SOL_SOCKET
, SO_MARK
, &s
->mark
, sizeof(s
->mark
)) < 0)
912 log_unit_warning_errno(UNIT(s
), errno
, "SO_MARK failed: %m");
915 if (setsockopt(fd
, IPPROTO_IP
, IP_TOS
, &s
->ip_tos
, sizeof(s
->ip_tos
)) < 0)
916 log_unit_warning_errno(UNIT(s
), errno
, "IP_TOS failed: %m");
918 if (s
->ip_ttl
>= 0) {
921 r
= setsockopt(fd
, IPPROTO_IP
, IP_TTL
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
923 if (socket_ipv6_is_supported())
924 x
= setsockopt(fd
, IPPROTO_IPV6
, IPV6_UNICAST_HOPS
, &s
->ip_ttl
, sizeof(s
->ip_ttl
));
927 errno
= EAFNOSUPPORT
;
931 log_unit_warning_errno(UNIT(s
), errno
, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
934 if (s
->tcp_congestion
)
935 if (setsockopt(fd
, SOL_TCP
, TCP_CONGESTION
, s
->tcp_congestion
, strlen(s
->tcp_congestion
)+1) < 0)
936 log_unit_warning_errno(UNIT(s
), errno
, "TCP_CONGESTION failed: %m");
938 if (s
->smack_ip_in
) {
939 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPIN
, s
->smack_ip_in
);
941 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_in_fd: %m");
944 if (s
->smack_ip_out
) {
945 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_IPOUT
, s
->smack_ip_out
);
947 log_unit_error_errno(UNIT(s
), r
, "mac_smack_apply_ip_out_fd: %m");
951 static void socket_apply_fifo_options(Socket
*s
, int fd
) {
957 if (s
->pipe_size
> 0)
958 if (fcntl(fd
, F_SETPIPE_SZ
, s
->pipe_size
) < 0)
959 log_unit_warning_errno(UNIT(s
), errno
, "Setting pipe size failed, ignoring: %m");
962 r
= mac_smack_apply_fd(fd
, SMACK_ATTR_ACCESS
, s
->smack
);
964 log_unit_error_errno(UNIT(s
), r
, "SMACK relabelling failed, ignoring: %m");
968 static int fifo_address_create(
970 mode_t directory_mode
,
971 mode_t socket_mode
) {
973 _cleanup_close_
int fd
= -1;
980 mkdir_parents_label(path
, directory_mode
);
982 r
= mac_selinux_create_file_prepare(path
, S_IFIFO
);
986 /* Enforce the right access mode for the fifo */
987 old_mask
= umask(~ socket_mode
);
989 /* Include the original umask in our mask */
990 (void) umask(~socket_mode
| old_mask
);
992 r
= mkfifo(path
, socket_mode
);
993 (void) umask(old_mask
);
995 if (r
< 0 && errno
!= EEXIST
) {
1000 fd
= open(path
, O_RDWR
| O_CLOEXEC
| O_NOCTTY
| O_NONBLOCK
| O_NOFOLLOW
);
1006 mac_selinux_create_file_clear();
1008 if (fstat(fd
, &st
) < 0) {
1013 if (!S_ISFIFO(st
.st_mode
) ||
1014 (st
.st_mode
& 0777) != (socket_mode
& ~old_mask
) ||
1015 st
.st_uid
!= getuid() ||
1016 st
.st_gid
!= getgid()) {
1027 mac_selinux_create_file_clear();
1033 static int special_address_create(const char *path
) {
1034 _cleanup_close_
int fd
= -1;
1040 fd
= open(path
, O_RDONLY
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1044 if (fstat(fd
, &st
) < 0)
1047 /* Check whether this is a /proc, /sys or /dev file or char device */
1048 if (!S_ISREG(st
.st_mode
) && !S_ISCHR(st
.st_mode
))
1057 static int ffs_address_create(const char *path
) {
1058 _cleanup_close_
int fd
= -1;
1064 fd
= open(path
, O_RDWR
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
|O_NOFOLLOW
);
1068 if (fstat(fd
, &st
) < 0)
1071 /* Check whether this is a regular file (ffs endpoint)*/
1072 if (!S_ISREG(st
.st_mode
))
1081 static int mq_address_create(
1087 _cleanup_close_
int fd
= -1;
1090 struct mq_attr _attr
, *attr
= NULL
;
1095 if (maxmsg
> 0 && msgsize
> 0) {
1096 _attr
= (struct mq_attr
) {
1097 .mq_flags
= O_NONBLOCK
,
1098 .mq_maxmsg
= maxmsg
,
1099 .mq_msgsize
= msgsize
,
1104 /* Enforce the right access mode for the mq */
1105 old_mask
= umask(~ mq_mode
);
1107 /* Include the original umask in our mask */
1108 (void) umask(~mq_mode
| old_mask
);
1109 fd
= mq_open(path
, O_RDONLY
|O_CLOEXEC
|O_NONBLOCK
|O_CREAT
, mq_mode
, attr
);
1110 (void) umask(old_mask
);
1115 if (fstat(fd
, &st
) < 0)
1118 if ((st
.st_mode
& 0777) != (mq_mode
& ~old_mask
) ||
1119 st
.st_uid
!= getuid() ||
1120 st
.st_gid
!= getgid())
1129 static int socket_symlink(Socket
*s
) {
1135 p
= socket_find_symlink_target(s
);
1139 STRV_FOREACH(i
, s
->symlinks
)
1140 symlink_label(p
, *i
);
1145 static int ffs_write_descs(int fd
, Service
*s
) {
1148 if (!s
->usb_function_descriptors
|| !s
->usb_function_strings
)
1151 r
= copy_file_fd(s
->usb_function_descriptors
, fd
, false);
1155 return copy_file_fd(s
->usb_function_strings
, fd
, false);
1158 static int select_ep(const struct dirent
*d
) {
1159 return d
->d_name
[0] != '.' && !streq(d
->d_name
, "ep0");
1162 static int ffs_dispatch_eps(SocketPort
*p
) {
1163 _cleanup_free_
struct dirent
**ent
= NULL
;
1165 _cleanup_free_
char *path
= NULL
;
1167 r
= path_get_parent(p
->path
, &path
);
1171 r
= scandir(path
, &ent
, select_ep
, alphasort
);
1176 p
->auxiliary_fds
= new(int, n
);
1177 if (!p
->auxiliary_fds
)
1180 p
->n_auxiliary_fds
= n
;
1183 for (i
= 0; i
< n
; ++i
) {
1184 _cleanup_free_
char *ep
= NULL
;
1186 ep
= path_make_absolute(ent
[i
]->d_name
, path
);
1190 path_kill_slashes(ep
);
1192 r
= ffs_address_create(ep
);
1196 p
->auxiliary_fds
[k
] = r
;
1205 close_many(p
->auxiliary_fds
, k
);
1206 p
->auxiliary_fds
= mfree(p
->auxiliary_fds
);
1207 p
->n_auxiliary_fds
= 0;
1212 static int socket_open_fds(Socket
*s
) {
1213 _cleanup_(mac_selinux_freep
) char *label
= NULL
;
1214 bool know_label
= false;
1220 LIST_FOREACH(port
, p
, s
->ports
) {
1230 /* Figure out label, if we don't it know
1231 * yet. We do it once, for the first
1232 * socket where we need this and
1233 * remember it for the rest. */
1235 if (s
->selinux_context_from_net
) {
1236 /* Get it from the network label */
1238 r
= mac_selinux_get_our_label(&label
);
1239 if (r
< 0 && r
!= -EOPNOTSUPP
)
1243 /* Get it from the executable we are about to start */
1245 r
= socket_instantiate_service(s
);
1249 if (UNIT_ISSET(s
->service
) &&
1250 SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]) {
1251 r
= mac_selinux_get_create_label_from_exe(SERVICE(UNIT_DEREF(s
->service
))->exec_command
[SERVICE_EXEC_START
]->path
, &label
);
1252 if (r
< 0 && r
!= -EPERM
&& r
!= -EOPNOTSUPP
)
1260 r
= socket_address_listen(
1262 SOCK_CLOEXEC
|SOCK_NONBLOCK
,
1276 socket_apply_socket_options(s
, p
->fd
);
1280 case SOCKET_SPECIAL
:
1282 p
->fd
= special_address_create(p
->path
);
1291 p
->fd
= fifo_address_create(
1300 socket_apply_fifo_options(s
, p
->fd
);
1306 p
->fd
= mq_address_create(
1317 case SOCKET_USB_FUNCTION
:
1319 p
->fd
= ffs_address_create(p
->path
);
1325 r
= ffs_write_descs(p
->fd
, SERVICE(UNIT_DEREF(s
->service
)));
1329 r
= ffs_dispatch_eps(p
);
1336 assert_not_reached("Unknown port type");
1343 socket_close_fds(s
);
1347 static void socket_unwatch_fds(Socket
*s
) {
1353 LIST_FOREACH(port
, p
, s
->ports
) {
1357 if (!p
->event_source
)
1360 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_OFF
);
1362 log_unit_debug_errno(UNIT(s
), r
, "Failed to disable event source: %m");
1366 static int socket_watch_fds(Socket
*s
) {
1372 LIST_FOREACH(port
, p
, s
->ports
) {
1376 if (p
->event_source
) {
1377 r
= sd_event_source_set_enabled(p
->event_source
, SD_EVENT_ON
);
1381 r
= sd_event_add_io(UNIT(s
)->manager
->event
, &p
->event_source
, p
->fd
, EPOLLIN
, socket_dispatch_io
, p
);
1385 (void) sd_event_source_set_description(p
->event_source
, "socket-port-io");
1392 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch listening fds: %m");
1393 socket_unwatch_fds(s
);
1397 static void socket_set_state(Socket
*s
, SocketState state
) {
1398 SocketState old_state
;
1401 old_state
= s
->state
;
1409 SOCKET_STOP_PRE_SIGTERM
,
1410 SOCKET_STOP_PRE_SIGKILL
,
1412 SOCKET_FINAL_SIGTERM
,
1413 SOCKET_FINAL_SIGKILL
)) {
1415 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1416 socket_unwatch_control_pid(s
);
1417 s
->control_command
= NULL
;
1418 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
1421 if (state
!= SOCKET_LISTENING
)
1422 socket_unwatch_fds(s
);
1430 SOCKET_STOP_PRE_SIGTERM
,
1431 SOCKET_STOP_PRE_SIGKILL
))
1432 socket_close_fds(s
);
1434 if (state
!= old_state
)
1435 log_unit_debug(UNIT(s
), "Changed %s -> %s", socket_state_to_string(old_state
), socket_state_to_string(state
));
1437 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
1440 static int socket_coldplug(Unit
*u
) {
1441 Socket
*s
= SOCKET(u
);
1445 assert(s
->state
== SOCKET_DEAD
);
1447 if (s
->deserialized_state
== s
->state
)
1450 if (IN_SET(s
->deserialized_state
,
1455 SOCKET_STOP_PRE_SIGTERM
,
1456 SOCKET_STOP_PRE_SIGKILL
,
1458 SOCKET_FINAL_SIGTERM
,
1459 SOCKET_FINAL_SIGKILL
)) {
1461 if (s
->control_pid
<= 0)
1464 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
1468 r
= socket_arm_timer(s
);
1473 if (IN_SET(s
->deserialized_state
,
1479 SOCKET_STOP_PRE_SIGTERM
,
1480 SOCKET_STOP_PRE_SIGKILL
)) {
1481 r
= socket_open_fds(s
);
1486 if (s
->deserialized_state
== SOCKET_LISTENING
) {
1487 r
= socket_watch_fds(s
);
1492 socket_set_state(s
, s
->deserialized_state
);
1496 static int socket_spawn(Socket
*s
, ExecCommand
*c
, pid_t
*_pid
) {
1497 _cleanup_free_
char **argv
= NULL
;
1500 ExecParameters exec_params
= {
1501 .apply_permissions
= true,
1502 .apply_chroot
= true,
1503 .apply_tty_stdin
= true,
1504 .bus_endpoint_fd
= -1,
1511 (void) unit_realize_cgroup(UNIT(s
));
1512 if (s
->reset_cpu_usage
) {
1513 (void) unit_reset_cpu_usage(UNIT(s
));
1514 s
->reset_cpu_usage
= false;
1517 r
= unit_setup_exec_runtime(UNIT(s
));
1521 r
= socket_arm_timer(s
);
1525 r
= unit_full_printf_strv(UNIT(s
), c
->argv
, &argv
);
1529 exec_params
.argv
= argv
;
1530 exec_params
.environment
= UNIT(s
)->manager
->environment
;
1531 exec_params
.confirm_spawn
= UNIT(s
)->manager
->confirm_spawn
;
1532 exec_params
.cgroup_supported
= UNIT(s
)->manager
->cgroup_supported
;
1533 exec_params
.cgroup_path
= UNIT(s
)->cgroup_path
;
1534 exec_params
.cgroup_delegate
= s
->cgroup_context
.delegate
;
1535 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(s
)->manager
);
1537 r
= exec_spawn(UNIT(s
),
1546 r
= unit_watch_pid(UNIT(s
), pid
);
1548 /* FIXME: we need to do something here */
1555 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1559 static int socket_chown(Socket
*s
, pid_t
*_pid
) {
1563 r
= socket_arm_timer(s
);
1567 /* We have to resolve the user names out-of-process, hence
1568 * let's fork here. It's messy, but well, what can we do? */
1576 uid_t uid
= UID_INVALID
;
1577 gid_t gid
= GID_INVALID
;
1580 (void) default_signals(SIGNALS_CRASH_HANDLER
, SIGNALS_IGNORE
, -1);
1581 (void) ignore_signals(SIGPIPE
, -1);
1584 if (!isempty(s
->user
)) {
1585 const char *user
= s
->user
;
1587 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
);
1594 if (!isempty(s
->group
)) {
1595 const char *group
= s
->group
;
1597 r
= get_group_creds(&group
, &gid
);
1604 LIST_FOREACH(port
, p
, s
->ports
) {
1605 const char *path
= NULL
;
1607 if (p
->type
== SOCKET_SOCKET
)
1608 path
= socket_address_get_path(&p
->address
);
1609 else if (p
->type
== SOCKET_FIFO
)
1615 if (chown(path
, uid
, gid
) < 0) {
1626 log_error_errno(r
, "Failed to chown socket at step %s: %m", exit_status_to_string(ret
, EXIT_STATUS_SYSTEMD
));
1631 r
= unit_watch_pid(UNIT(s
), pid
);
1639 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
1643 static void socket_enter_dead(Socket
*s
, SocketResult f
) {
1646 if (f
!= SOCKET_SUCCESS
)
1649 exec_runtime_destroy(s
->exec_runtime
);
1650 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
);
1652 exec_context_destroy_runtime_directory(&s
->exec_context
, manager_get_runtime_prefix(UNIT(s
)->manager
));
1654 socket_set_state(s
, s
->result
!= SOCKET_SUCCESS
? SOCKET_FAILED
: SOCKET_DEAD
);
1657 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
);
1659 static void socket_enter_stop_post(Socket
*s
, SocketResult f
) {
1663 if (f
!= SOCKET_SUCCESS
)
1666 socket_unwatch_control_pid(s
);
1667 s
->control_command_id
= SOCKET_EXEC_STOP_POST
;
1668 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_POST
];
1670 if (s
->control_command
) {
1671 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1675 socket_set_state(s
, SOCKET_STOP_POST
);
1677 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_SUCCESS
);
1682 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-post' task: %m");
1683 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
1686 static void socket_enter_signal(Socket
*s
, SocketState state
, SocketResult f
) {
1691 if (f
!= SOCKET_SUCCESS
)
1694 r
= unit_kill_context(
1697 (state
!= SOCKET_STOP_PRE_SIGTERM
&& state
!= SOCKET_FINAL_SIGTERM
) ?
1698 KILL_KILL
: KILL_TERMINATE
,
1706 r
= socket_arm_timer(s
);
1710 socket_set_state(s
, state
);
1711 } else if (state
== SOCKET_STOP_PRE_SIGTERM
)
1712 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_SUCCESS
);
1713 else if (state
== SOCKET_STOP_PRE_SIGKILL
)
1714 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1715 else if (state
== SOCKET_FINAL_SIGTERM
)
1716 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_SUCCESS
);
1718 socket_enter_dead(s
, SOCKET_SUCCESS
);
1723 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
1725 if (state
== SOCKET_STOP_PRE_SIGTERM
|| state
== SOCKET_STOP_PRE_SIGKILL
)
1726 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1728 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1731 static void socket_enter_stop_pre(Socket
*s
, SocketResult f
) {
1735 if (f
!= SOCKET_SUCCESS
)
1738 socket_unwatch_control_pid(s
);
1739 s
->control_command_id
= SOCKET_EXEC_STOP_PRE
;
1740 s
->control_command
= s
->exec_command
[SOCKET_EXEC_STOP_PRE
];
1742 if (s
->control_command
) {
1743 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1747 socket_set_state(s
, SOCKET_STOP_PRE
);
1749 socket_enter_stop_post(s
, SOCKET_SUCCESS
);
1754 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'stop-pre' task: %m");
1755 socket_enter_stop_post(s
, SOCKET_FAILURE_RESOURCES
);
1758 static void socket_enter_listening(Socket
*s
) {
1762 r
= socket_watch_fds(s
);
1764 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1768 socket_set_state(s
, SOCKET_LISTENING
);
1772 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1775 static void socket_enter_start_post(Socket
*s
) {
1779 socket_unwatch_control_pid(s
);
1780 s
->control_command_id
= SOCKET_EXEC_START_POST
;
1781 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_POST
];
1783 if (s
->control_command
) {
1784 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1786 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-post' task: %m");
1790 socket_set_state(s
, SOCKET_START_POST
);
1792 socket_enter_listening(s
);
1797 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1800 static void socket_enter_start_chown(Socket
*s
) {
1805 r
= socket_open_fds(s
);
1807 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1811 if (!isempty(s
->user
) || !isempty(s
->group
)) {
1813 socket_unwatch_control_pid(s
);
1814 s
->control_command_id
= SOCKET_EXEC_START_CHOWN
;
1815 s
->control_command
= NULL
;
1817 r
= socket_chown(s
, &s
->control_pid
);
1819 log_unit_warning_errno(UNIT(s
), r
, "Failed to fork 'start-chown' task: %m");
1823 socket_set_state(s
, SOCKET_START_CHOWN
);
1825 socket_enter_start_post(s
);
1830 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1833 static void socket_enter_start_pre(Socket
*s
) {
1837 socket_unwatch_control_pid(s
);
1838 s
->control_command_id
= SOCKET_EXEC_START_PRE
;
1839 s
->control_command
= s
->exec_command
[SOCKET_EXEC_START_PRE
];
1841 if (s
->control_command
) {
1842 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
1844 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'start-pre' task: %m");
1848 socket_set_state(s
, SOCKET_START_PRE
);
1850 socket_enter_start_chown(s
);
1855 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
1858 static void socket_enter_running(Socket
*s
, int cfd
) {
1859 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
1864 /* We don't take connections anymore if we are supposed to
1865 * shut down anyway */
1866 if (unit_stop_pending(UNIT(s
))) {
1868 log_unit_debug(UNIT(s
), "Suppressing connection request since unit stop is scheduled.");
1873 /* Flush all sockets by closing and reopening them */
1874 socket_close_fds(s
);
1876 r
= socket_open_fds(s
);
1878 log_unit_warning_errno(UNIT(s
), r
, "Failed to listen on sockets: %m");
1879 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1883 r
= socket_watch_fds(s
);
1885 log_unit_warning_errno(UNIT(s
), r
, "Failed to watch sockets: %m");
1886 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1896 bool pending
= false;
1898 /* If there's already a start pending don't bother to
1900 SET_FOREACH(other
, UNIT(s
)->dependencies
[UNIT_TRIGGERS
], i
)
1901 if (unit_active_or_pending(other
)) {
1907 if (!UNIT_ISSET(s
->service
)) {
1908 log_unit_error(UNIT(s
), "Service to activate vanished, refusing activation.");
1913 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT_DEREF(s
->service
), JOB_REPLACE
, true, &error
, NULL
);
1918 socket_set_state(s
, SOCKET_RUNNING
);
1920 _cleanup_free_
char *prefix
= NULL
, *instance
= NULL
, *name
= NULL
;
1923 if (s
->n_connections
>= s
->max_connections
) {
1924 log_unit_warning(UNIT(s
), "Too many incoming connections (%u)", s
->n_connections
);
1929 r
= socket_instantiate_service(s
);
1933 r
= instance_from_socket(cfd
, s
->n_accepted
, &instance
);
1938 /* ENOTCONN is legitimate if TCP RST was received.
1939 * This connection is over, but the socket unit lives on. */
1944 r
= unit_name_to_prefix(UNIT(s
)->id
, &prefix
);
1948 r
= unit_name_build(prefix
, instance
, ".service", &name
);
1952 r
= unit_add_name(UNIT_DEREF(s
->service
), name
);
1956 service
= SERVICE(UNIT_DEREF(s
->service
));
1957 unit_ref_unset(&s
->service
);
1960 UNIT(service
)->no_gc
= false;
1962 unit_choose_id(UNIT(service
), name
);
1964 r
= service_set_socket_fd(service
, cfd
, s
, s
->selinux_context_from_net
);
1969 s
->n_connections
++;
1971 r
= manager_add_job(UNIT(s
)->manager
, JOB_START
, UNIT(service
), JOB_REPLACE
, true, &error
, NULL
);
1975 /* Notify clients about changed counters */
1976 unit_add_to_dbus_queue(UNIT(s
));
1982 log_unit_warning(UNIT(s
), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1983 cfd
>= 0 ? "template" : "non-template",
1984 bus_error_message(&error
, r
));
1986 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
1990 static void socket_run_next(Socket
*s
) {
1994 assert(s
->control_command
);
1995 assert(s
->control_command
->command_next
);
1997 socket_unwatch_control_pid(s
);
1999 s
->control_command
= s
->control_command
->command_next
;
2001 r
= socket_spawn(s
, s
->control_command
, &s
->control_pid
);
2008 log_unit_warning_errno(UNIT(s
), r
, "Failed to run next task: %m");
2010 if (s
->state
== SOCKET_START_POST
)
2011 socket_enter_stop_pre(s
, SOCKET_FAILURE_RESOURCES
);
2012 else if (s
->state
== SOCKET_STOP_POST
)
2013 socket_enter_dead(s
, SOCKET_FAILURE_RESOURCES
);
2015 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_RESOURCES
);
2018 static int socket_start(Unit
*u
) {
2019 Socket
*s
= SOCKET(u
);
2023 /* We cannot fulfill this request right now, try again later
2025 if (IN_SET(s
->state
,
2027 SOCKET_STOP_PRE_SIGKILL
,
2028 SOCKET_STOP_PRE_SIGTERM
,
2030 SOCKET_FINAL_SIGTERM
,
2031 SOCKET_FINAL_SIGKILL
))
2034 /* Already on it! */
2035 if (IN_SET(s
->state
,
2041 /* Cannot run this without the service being around */
2042 if (UNIT_ISSET(s
->service
)) {
2045 service
= SERVICE(UNIT_DEREF(s
->service
));
2047 if (UNIT(service
)->load_state
!= UNIT_LOADED
) {
2048 log_unit_error(u
, "Socket service %s not loaded, refusing.", UNIT(service
)->id
);
2052 /* If the service is already active we cannot start the
2054 if (service
->state
!= SERVICE_DEAD
&&
2055 service
->state
!= SERVICE_FAILED
&&
2056 service
->state
!= SERVICE_AUTO_RESTART
) {
2057 log_unit_error(u
, "Socket service %s already active, refusing.", UNIT(service
)->id
);
2062 assert(s
->state
== SOCKET_DEAD
|| s
->state
== SOCKET_FAILED
);
2064 s
->result
= SOCKET_SUCCESS
;
2065 s
->reset_cpu_usage
= true;
2067 socket_enter_start_pre(s
);
2072 static int socket_stop(Unit
*u
) {
2073 Socket
*s
= SOCKET(u
);
2078 if (IN_SET(s
->state
,
2080 SOCKET_STOP_PRE_SIGTERM
,
2081 SOCKET_STOP_PRE_SIGKILL
,
2083 SOCKET_FINAL_SIGTERM
,
2084 SOCKET_FINAL_SIGKILL
))
2087 /* If there's already something running we go directly into
2089 if (IN_SET(s
->state
,
2092 SOCKET_START_POST
)) {
2093 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_SUCCESS
);
2097 assert(s
->state
== SOCKET_LISTENING
|| s
->state
== SOCKET_RUNNING
);
2099 socket_enter_stop_pre(s
, SOCKET_SUCCESS
);
2103 static int socket_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2104 Socket
*s
= SOCKET(u
);
2112 unit_serialize_item(u
, f
, "state", socket_state_to_string(s
->state
));
2113 unit_serialize_item(u
, f
, "result", socket_result_to_string(s
->result
));
2114 unit_serialize_item_format(u
, f
, "n-accepted", "%u", s
->n_accepted
);
2116 if (s
->control_pid
> 0)
2117 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
2119 if (s
->control_command_id
>= 0)
2120 unit_serialize_item(u
, f
, "control-command", socket_exec_command_to_string(s
->control_command_id
));
2122 LIST_FOREACH(port
, p
, s
->ports
) {
2128 copy
= fdset_put_dup(fds
, p
->fd
);
2132 if (p
->type
== SOCKET_SOCKET
) {
2133 _cleanup_free_
char *t
= NULL
;
2135 r
= socket_address_print(&p
->address
, &t
);
2139 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2140 unit_serialize_item_format(u
, f
, "netlink", "%i %s", copy
, t
);
2142 unit_serialize_item_format(u
, f
, "socket", "%i %i %s", copy
, p
->address
.type
, t
);
2144 } else if (p
->type
== SOCKET_SPECIAL
)
2145 unit_serialize_item_format(u
, f
, "special", "%i %s", copy
, p
->path
);
2146 else if (p
->type
== SOCKET_MQUEUE
)
2147 unit_serialize_item_format(u
, f
, "mqueue", "%i %s", copy
, p
->path
);
2148 else if (p
->type
== SOCKET_USB_FUNCTION
)
2149 unit_serialize_item_format(u
, f
, "ffs", "%i %s", copy
, p
->path
);
2151 assert(p
->type
== SOCKET_FIFO
);
2152 unit_serialize_item_format(u
, f
, "fifo", "%i %s", copy
, p
->path
);
2159 static int socket_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
2160 Socket
*s
= SOCKET(u
);
2166 if (streq(key
, "state")) {
2169 state
= socket_state_from_string(value
);
2171 log_unit_debug(u
, "Failed to parse state value: %s", value
);
2173 s
->deserialized_state
= state
;
2174 } else if (streq(key
, "result")) {
2177 f
= socket_result_from_string(value
);
2179 log_unit_debug(u
, "Failed to parse result value: %s", value
);
2180 else if (f
!= SOCKET_SUCCESS
)
2183 } else if (streq(key
, "n-accepted")) {
2186 if (safe_atou(value
, &k
) < 0)
2187 log_unit_debug(u
, "Failed to parse n-accepted value: %s", value
);
2190 } else if (streq(key
, "control-pid")) {
2193 if (parse_pid(value
, &pid
) < 0)
2194 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
2196 s
->control_pid
= pid
;
2197 } else if (streq(key
, "control-command")) {
2198 SocketExecCommand id
;
2200 id
= socket_exec_command_from_string(value
);
2202 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
2204 s
->control_command_id
= id
;
2205 s
->control_command
= s
->exec_command
[id
];
2207 } else if (streq(key
, "fifo")) {
2211 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2212 log_unit_debug(u
, "Failed to parse fifo value: %s", value
);
2215 LIST_FOREACH(port
, p
, s
->ports
)
2216 if (p
->type
== SOCKET_FIFO
&&
2217 path_equal_or_files_same(p
->path
, value
+skip
))
2222 p
->fd
= fdset_remove(fds
, fd
);
2226 } else if (streq(key
, "special")) {
2230 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2231 log_unit_debug(u
, "Failed to parse special value: %s", value
);
2234 LIST_FOREACH(port
, p
, s
->ports
)
2235 if (p
->type
== SOCKET_SPECIAL
&&
2236 path_equal_or_files_same(p
->path
, value
+skip
))
2241 p
->fd
= fdset_remove(fds
, fd
);
2245 } else if (streq(key
, "mqueue")) {
2249 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2250 log_unit_debug(u
, "Failed to parse mqueue value: %s", value
);
2253 LIST_FOREACH(port
, p
, s
->ports
)
2254 if (p
->type
== SOCKET_MQUEUE
&&
2255 streq(p
->path
, value
+skip
))
2260 p
->fd
= fdset_remove(fds
, fd
);
2264 } else if (streq(key
, "socket")) {
2265 int fd
, type
, skip
= 0;
2268 if (sscanf(value
, "%i %i %n", &fd
, &type
, &skip
) < 2 || fd
< 0 || type
< 0 || !fdset_contains(fds
, fd
))
2269 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2272 LIST_FOREACH(port
, p
, s
->ports
)
2273 if (socket_address_is(&p
->address
, value
+skip
, type
))
2278 p
->fd
= fdset_remove(fds
, fd
);
2282 } else if (streq(key
, "netlink")) {
2286 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2287 log_unit_debug(u
, "Failed to parse socket value: %s", value
);
2290 LIST_FOREACH(port
, p
, s
->ports
)
2291 if (socket_address_is_netlink(&p
->address
, value
+skip
))
2296 p
->fd
= fdset_remove(fds
, fd
);
2300 } else if (streq(key
, "ffs")) {
2304 if (sscanf(value
, "%i %n", &fd
, &skip
) < 1 || fd
< 0 || !fdset_contains(fds
, fd
))
2305 log_unit_debug(u
, "Failed to parse ffs value: %s", value
);
2308 LIST_FOREACH(port
, p
, s
->ports
)
2309 if (p
->type
== SOCKET_USB_FUNCTION
&&
2310 path_equal_or_files_same(p
->path
, value
+skip
))
2315 p
->fd
= fdset_remove(fds
, fd
);
2320 log_unit_debug(UNIT(s
), "Unknown serialization key: %s", key
);
2325 static int socket_distribute_fds(Unit
*u
, FDSet
*fds
) {
2326 Socket
*s
= SOCKET(u
);
2331 LIST_FOREACH(port
, p
, s
->ports
) {
2335 if (p
->type
!= SOCKET_SOCKET
)
2341 FDSET_FOREACH(fd
, fds
, i
) {
2342 if (socket_address_matches_fd(&p
->address
, fd
)) {
2343 p
->fd
= fdset_remove(fds
, fd
);
2344 s
->deserialized_state
= SOCKET_LISTENING
;
2353 _pure_
static UnitActiveState
socket_active_state(Unit
*u
) {
2356 return state_translation_table
[SOCKET(u
)->state
];
2359 _pure_
static const char *socket_sub_state_to_string(Unit
*u
) {
2362 return socket_state_to_string(SOCKET(u
)->state
);
2365 const char* socket_port_type_to_string(SocketPort
*p
) {
2373 switch (p
->address
.type
) {
2381 case SOCK_SEQPACKET
:
2382 return "SequentialPacket";
2385 if (socket_address_family(&p
->address
) == AF_NETLINK
)
2392 case SOCKET_SPECIAL
:
2396 return "MessageQueue";
2401 case SOCKET_USB_FUNCTION
:
2402 return "USBFunction";
2409 _pure_
static bool socket_check_gc(Unit
*u
) {
2410 Socket
*s
= SOCKET(u
);
2414 return s
->n_connections
> 0;
2417 static int socket_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
2418 SocketPort
*p
= userdata
;
2424 if (p
->socket
->state
!= SOCKET_LISTENING
)
2427 log_unit_debug(UNIT(p
->socket
), "Incoming traffic");
2429 if (revents
!= EPOLLIN
) {
2431 if (revents
& EPOLLHUP
)
2432 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.");
2434 log_unit_error(UNIT(p
->socket
), "Got unexpected poll event (0x%x) on socket.", revents
);
2438 if (p
->socket
->accept
&&
2439 p
->type
== SOCKET_SOCKET
&&
2440 socket_address_can_accept(&p
->address
)) {
2444 cfd
= accept4(fd
, NULL
, NULL
, SOCK_NONBLOCK
);
2450 log_unit_error_errno(UNIT(p
->socket
), errno
, "Failed to accept socket: %m");
2457 socket_apply_socket_options(p
->socket
, cfd
);
2460 socket_enter_running(p
->socket
, cfd
);
2464 socket_enter_stop_pre(p
->socket
, SOCKET_FAILURE_RESOURCES
);
2468 static void socket_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
2469 Socket
*s
= SOCKET(u
);
2475 if (pid
!= s
->control_pid
)
2480 if (is_clean_exit(code
, status
, NULL
))
2482 else if (code
== CLD_EXITED
)
2483 f
= SOCKET_FAILURE_EXIT_CODE
;
2484 else if (code
== CLD_KILLED
)
2485 f
= SOCKET_FAILURE_SIGNAL
;
2486 else if (code
== CLD_DUMPED
)
2487 f
= SOCKET_FAILURE_CORE_DUMP
;
2489 assert_not_reached("Unknown sigchld code");
2491 if (s
->control_command
) {
2492 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
2494 if (s
->control_command
->ignore
)
2498 log_unit_full(u
, f
== SOCKET_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
2499 "Control process exited, code=%s status=%i",
2500 sigchld_code_to_string(code
), status
);
2502 if (f
!= SOCKET_SUCCESS
)
2505 if (s
->control_command
&&
2506 s
->control_command
->command_next
&&
2507 f
== SOCKET_SUCCESS
) {
2509 log_unit_debug(u
, "Running next command for state %s", socket_state_to_string(s
->state
));
2512 s
->control_command
= NULL
;
2513 s
->control_command_id
= _SOCKET_EXEC_COMMAND_INVALID
;
2515 /* No further commands for this step, so let's figure
2516 * out what to do next */
2518 log_unit_debug(u
, "Got final SIGCHLD for state %s", socket_state_to_string(s
->state
));
2522 case SOCKET_START_PRE
:
2523 if (f
== SOCKET_SUCCESS
)
2524 socket_enter_start_chown(s
);
2526 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, f
);
2529 case SOCKET_START_CHOWN
:
2530 if (f
== SOCKET_SUCCESS
)
2531 socket_enter_start_post(s
);
2533 socket_enter_stop_pre(s
, f
);
2536 case SOCKET_START_POST
:
2537 if (f
== SOCKET_SUCCESS
)
2538 socket_enter_listening(s
);
2540 socket_enter_stop_pre(s
, f
);
2543 case SOCKET_STOP_PRE
:
2544 case SOCKET_STOP_PRE_SIGTERM
:
2545 case SOCKET_STOP_PRE_SIGKILL
:
2546 socket_enter_stop_post(s
, f
);
2549 case SOCKET_STOP_POST
:
2550 case SOCKET_FINAL_SIGTERM
:
2551 case SOCKET_FINAL_SIGKILL
:
2552 socket_enter_dead(s
, f
);
2556 assert_not_reached("Uh, control process died at wrong time.");
2560 /* Notify clients about changed exit status */
2561 unit_add_to_dbus_queue(u
);
2564 static int socket_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
2565 Socket
*s
= SOCKET(userdata
);
2568 assert(s
->timer_event_source
== source
);
2572 case SOCKET_START_PRE
:
2573 log_unit_warning(UNIT(s
), "Starting timed out. Terminating.");
2574 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2577 case SOCKET_START_CHOWN
:
2578 case SOCKET_START_POST
:
2579 log_unit_warning(UNIT(s
), "Starting timed out. Stopping.");
2580 socket_enter_stop_pre(s
, SOCKET_FAILURE_TIMEOUT
);
2583 case SOCKET_STOP_PRE
:
2584 log_unit_warning(UNIT(s
), "Stopping timed out. Terminating.");
2585 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2588 case SOCKET_STOP_PRE_SIGTERM
:
2589 if (s
->kill_context
.send_sigkill
) {
2590 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
2591 socket_enter_signal(s
, SOCKET_STOP_PRE_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2593 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL. Ignoring.");
2594 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2598 case SOCKET_STOP_PRE_SIGKILL
:
2599 log_unit_warning(UNIT(s
), "Processes still around after SIGKILL. Ignoring.");
2600 socket_enter_stop_post(s
, SOCKET_FAILURE_TIMEOUT
);
2603 case SOCKET_STOP_POST
:
2604 log_unit_warning(UNIT(s
), "Stopping timed out (2). Terminating.");
2605 socket_enter_signal(s
, SOCKET_FINAL_SIGTERM
, SOCKET_FAILURE_TIMEOUT
);
2608 case SOCKET_FINAL_SIGTERM
:
2609 if (s
->kill_context
.send_sigkill
) {
2610 log_unit_warning(UNIT(s
), "Stopping timed out (2). Killing.");
2611 socket_enter_signal(s
, SOCKET_FINAL_SIGKILL
, SOCKET_FAILURE_TIMEOUT
);
2613 log_unit_warning(UNIT(s
), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
2614 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2618 case SOCKET_FINAL_SIGKILL
:
2619 log_unit_warning(UNIT(s
), "Still around after SIGKILL (2). Entering failed mode.");
2620 socket_enter_dead(s
, SOCKET_FAILURE_TIMEOUT
);
2624 assert_not_reached("Timeout at wrong time.");
2630 int socket_collect_fds(Socket
*s
, int **fds
, unsigned *n_fds
) {
2640 /* Called from the service code for requesting our fds */
2643 LIST_FOREACH(port
, p
, s
->ports
) {
2646 rn_fds
+= p
->n_auxiliary_fds
;
2655 rfds
= new(int, rn_fds
);
2660 LIST_FOREACH(port
, p
, s
->ports
) {
2663 for (i
= 0; i
< p
->n_auxiliary_fds
; ++i
)
2664 rfds
[k
++] = p
->auxiliary_fds
[i
];
2667 assert(k
== rn_fds
);
2675 static void socket_reset_failed(Unit
*u
) {
2676 Socket
*s
= SOCKET(u
);
2680 if (s
->state
== SOCKET_FAILED
)
2681 socket_set_state(s
, SOCKET_DEAD
);
2683 s
->result
= SOCKET_SUCCESS
;
2686 static void socket_notify_service_dead(Socket
*s
, bool failed_permanent
) {
2689 /* The service is dead. Dang!
2691 * This is strictly for one-instance-for-all-connections
2694 if (s
->state
== SOCKET_RUNNING
) {
2695 log_unit_debug(UNIT(s
), "Got notified about service death (failed permanently: %s)", yes_no(failed_permanent
));
2696 if (failed_permanent
)
2697 socket_enter_stop_pre(s
, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
);
2699 socket_enter_listening(s
);
2703 void socket_connection_unref(Socket
*s
) {
2706 /* The service is dead. Yay!
2708 * This is strictly for one-instance-per-connection
2711 assert(s
->n_connections
> 0);
2714 log_unit_debug(UNIT(s
), "One connection closed, %u left.", s
->n_connections
);
2717 static void socket_trigger_notify(Unit
*u
, Unit
*other
) {
2718 Socket
*s
= SOCKET(u
);
2724 /* Don't propagate state changes from the service if we are
2725 already down or accepting connections */
2726 if ((s
->state
!= SOCKET_RUNNING
&&
2727 s
->state
!= SOCKET_LISTENING
) ||
2731 if (other
->load_state
!= UNIT_LOADED
||
2732 other
->type
!= UNIT_SERVICE
)
2735 se
= SERVICE(other
);
2737 if (se
->state
== SERVICE_FAILED
)
2738 socket_notify_service_dead(s
, se
->result
== SERVICE_FAILURE_START_LIMIT
);
2740 if (se
->state
== SERVICE_DEAD
||
2741 se
->state
== SERVICE_FINAL_SIGTERM
||
2742 se
->state
== SERVICE_FINAL_SIGKILL
||
2743 se
->state
== SERVICE_AUTO_RESTART
)
2744 socket_notify_service_dead(s
, false);
2746 if (se
->state
== SERVICE_RUNNING
)
2747 socket_set_state(s
, SOCKET_RUNNING
);
2750 static int socket_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
2751 return unit_kill_common(u
, who
, signo
, -1, SOCKET(u
)->control_pid
, error
);
2754 static int socket_get_timeout(Unit
*u
, uint64_t *timeout
) {
2755 Socket
*s
= SOCKET(u
);
2758 if (!s
->timer_event_source
)
2761 r
= sd_event_source_get_time(s
->timer_event_source
, timeout
);
2768 static const char* const socket_state_table
[_SOCKET_STATE_MAX
] = {
2769 [SOCKET_DEAD
] = "dead",
2770 [SOCKET_START_PRE
] = "start-pre",
2771 [SOCKET_START_CHOWN
] = "start-chown",
2772 [SOCKET_START_POST
] = "start-post",
2773 [SOCKET_LISTENING
] = "listening",
2774 [SOCKET_RUNNING
] = "running",
2775 [SOCKET_STOP_PRE
] = "stop-pre",
2776 [SOCKET_STOP_PRE_SIGTERM
] = "stop-pre-sigterm",
2777 [SOCKET_STOP_PRE_SIGKILL
] = "stop-pre-sigkill",
2778 [SOCKET_STOP_POST
] = "stop-post",
2779 [SOCKET_FINAL_SIGTERM
] = "final-sigterm",
2780 [SOCKET_FINAL_SIGKILL
] = "final-sigkill",
2781 [SOCKET_FAILED
] = "failed"
2784 DEFINE_STRING_TABLE_LOOKUP(socket_state
, SocketState
);
2786 static const char* const socket_exec_command_table
[_SOCKET_EXEC_COMMAND_MAX
] = {
2787 [SOCKET_EXEC_START_PRE
] = "StartPre",
2788 [SOCKET_EXEC_START_CHOWN
] = "StartChown",
2789 [SOCKET_EXEC_START_POST
] = "StartPost",
2790 [SOCKET_EXEC_STOP_PRE
] = "StopPre",
2791 [SOCKET_EXEC_STOP_POST
] = "StopPost"
2794 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command
, SocketExecCommand
);
2796 static const char* const socket_result_table
[_SOCKET_RESULT_MAX
] = {
2797 [SOCKET_SUCCESS
] = "success",
2798 [SOCKET_FAILURE_RESOURCES
] = "resources",
2799 [SOCKET_FAILURE_TIMEOUT
] = "timeout",
2800 [SOCKET_FAILURE_EXIT_CODE
] = "exit-code",
2801 [SOCKET_FAILURE_SIGNAL
] = "signal",
2802 [SOCKET_FAILURE_CORE_DUMP
] = "core-dump",
2803 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT
] = "service-failed-permanent"
2806 DEFINE_STRING_TABLE_LOOKUP(socket_result
, SocketResult
);
2808 const UnitVTable socket_vtable
= {
2809 .object_size
= sizeof(Socket
),
2810 .exec_context_offset
= offsetof(Socket
, exec_context
),
2811 .cgroup_context_offset
= offsetof(Socket
, cgroup_context
),
2812 .kill_context_offset
= offsetof(Socket
, kill_context
),
2813 .exec_runtime_offset
= offsetof(Socket
, exec_runtime
),
2819 .private_section
= "Socket",
2821 .init
= socket_init
,
2822 .done
= socket_done
,
2823 .load
= socket_load
,
2825 .coldplug
= socket_coldplug
,
2827 .dump
= socket_dump
,
2829 .start
= socket_start
,
2830 .stop
= socket_stop
,
2832 .kill
= socket_kill
,
2834 .get_timeout
= socket_get_timeout
,
2836 .serialize
= socket_serialize
,
2837 .deserialize_item
= socket_deserialize_item
,
2838 .distribute_fds
= socket_distribute_fds
,
2840 .active_state
= socket_active_state
,
2841 .sub_state_to_string
= socket_sub_state_to_string
,
2843 .check_gc
= socket_check_gc
,
2845 .sigchld_event
= socket_sigchld_event
,
2847 .trigger_notify
= socket_trigger_notify
,
2849 .reset_failed
= socket_reset_failed
,
2851 .bus_vtable
= bus_socket_vtable
,
2852 .bus_set_property
= bus_socket_set_property
,
2853 .bus_commit_properties
= bus_socket_commit_properties
,
2855 .status_message_formats
= {
2856 /*.starting_stopping = {
2857 [0] = "Starting socket %s...",
2858 [1] = "Stopping socket %s...",
2860 .finished_start_job
= {
2861 [JOB_DONE
] = "Listening on %s.",
2862 [JOB_FAILED
] = "Failed to listen on %s.",
2863 [JOB_TIMEOUT
] = "Timed out starting %s.",
2865 .finished_stop_job
= {
2866 [JOB_DONE
] = "Closed %s.",
2867 [JOB_FAILED
] = "Failed stopping %s.",
2868 [JOB_TIMEOUT
] = "Timed out stopping %s.",