]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/socket.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #16112 from poettering/nss-systemd-block-fix
[thirdparty/systemd.git] / src / core / socket.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <arpa/inet.h>
4 #include <errno.h>
5 #include <fcntl.h>
6 #include <mqueue.h>
7 #include <netinet/tcp.h>
8 #include <sys/epoll.h>
9 #include <sys/stat.h>
10 #include <unistd.h>
11 #include <linux/sctp.h>
12
13 #include "alloc-util.h"
14 #include "bpf-firewall.h"
15 #include "bus-error.h"
16 #include "bus-util.h"
17 #include "copy.h"
18 #include "dbus-socket.h"
19 #include "dbus-unit.h"
20 #include "def.h"
21 #include "exit-status.h"
22 #include "fd-util.h"
23 #include "format-util.h"
24 #include "fs-util.h"
25 #include "in-addr-util.h"
26 #include "io-util.h"
27 #include "ip-protocol-list.h"
28 #include "label.h"
29 #include "log.h"
30 #include "mkdir.h"
31 #include "parse-util.h"
32 #include "path-util.h"
33 #include "process-util.h"
34 #include "selinux-util.h"
35 #include "serialize.h"
36 #include "signal-util.h"
37 #include "smack-util.h"
38 #include "socket.h"
39 #include "socket-netlink.h"
40 #include "special.h"
41 #include "string-table.h"
42 #include "string-util.h"
43 #include "strv.h"
44 #include "unit-name.h"
45 #include "unit.h"
46 #include "user-util.h"
47
48 struct SocketPeer {
49 unsigned n_ref;
50
51 Socket *socket;
52 union sockaddr_union peer;
53 socklen_t peer_salen;
54 };
55
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,
70 [SOCKET_CLEANING] = UNIT_MAINTENANCE,
71 };
72
73 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
74 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
75
76 static void socket_init(Unit *u) {
77 Socket *s = SOCKET(u);
78
79 assert(u);
80 assert(u->load_state == UNIT_STUB);
81
82 s->backlog = SOMAXCONN;
83 s->timeout_usec = u->manager->default_timeout_start_usec;
84 s->directory_mode = 0755;
85 s->socket_mode = 0666;
86
87 s->max_connections = 64;
88
89 s->priority = -1;
90 s->ip_tos = -1;
91 s->ip_ttl = -1;
92 s->mark = -1;
93
94 s->exec_context.std_output = u->manager->default_std_output;
95 s->exec_context.std_error = u->manager->default_std_error;
96
97 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
98
99 s->trigger_limit.interval = USEC_INFINITY;
100 s->trigger_limit.burst = (unsigned) -1;
101 }
102
103 static void socket_unwatch_control_pid(Socket *s) {
104 assert(s);
105
106 if (s->control_pid <= 0)
107 return;
108
109 unit_unwatch_pid(UNIT(s), s->control_pid);
110 s->control_pid = 0;
111 }
112
113 static void socket_cleanup_fd_list(SocketPort *p) {
114 assert(p);
115
116 close_many(p->auxiliary_fds, p->n_auxiliary_fds);
117 p->auxiliary_fds = mfree(p->auxiliary_fds);
118 p->n_auxiliary_fds = 0;
119 }
120
121 void socket_free_ports(Socket *s) {
122 SocketPort *p;
123
124 assert(s);
125
126 while ((p = s->ports)) {
127 LIST_REMOVE(port, s->ports, p);
128
129 sd_event_source_unref(p->event_source);
130
131 socket_cleanup_fd_list(p);
132 safe_close(p->fd);
133 free(p->path);
134 free(p);
135 }
136 }
137
138 static void socket_done(Unit *u) {
139 Socket *s = SOCKET(u);
140 SocketPeer *p;
141
142 assert(s);
143
144 socket_free_ports(s);
145
146 while ((p = set_steal_first(s->peers_by_address)))
147 p->socket = NULL;
148
149 s->peers_by_address = set_free(s->peers_by_address);
150
151 s->exec_runtime = exec_runtime_unref(s->exec_runtime, false);
152 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
153 s->control_command = NULL;
154
155 dynamic_creds_unref(&s->dynamic_creds);
156
157 socket_unwatch_control_pid(s);
158
159 unit_ref_unset(&s->service);
160
161 s->tcp_congestion = mfree(s->tcp_congestion);
162 s->bind_to_device = mfree(s->bind_to_device);
163
164 s->smack = mfree(s->smack);
165 s->smack_ip_in = mfree(s->smack_ip_in);
166 s->smack_ip_out = mfree(s->smack_ip_out);
167
168 strv_free(s->symlinks);
169
170 s->user = mfree(s->user);
171 s->group = mfree(s->group);
172
173 s->fdname = mfree(s->fdname);
174
175 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
176 }
177
178 static int socket_arm_timer(Socket *s, usec_t usec) {
179 int r;
180
181 assert(s);
182
183 if (s->timer_event_source) {
184 r = sd_event_source_set_time(s->timer_event_source, usec);
185 if (r < 0)
186 return r;
187
188 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
189 }
190
191 if (usec == USEC_INFINITY)
192 return 0;
193
194 r = sd_event_add_time(
195 UNIT(s)->manager->event,
196 &s->timer_event_source,
197 CLOCK_MONOTONIC,
198 usec, 0,
199 socket_dispatch_timer, s);
200 if (r < 0)
201 return r;
202
203 (void) sd_event_source_set_description(s->timer_event_source, "socket-timer");
204
205 return 0;
206 }
207
208 static int socket_instantiate_service(Socket *s, int cfd) {
209 Unit *service;
210 int r;
211
212 assert(s);
213 assert(cfd >= 0);
214
215 /* This fills in s->service if it isn't filled in yet. For Accept=yes sockets we create the next
216 * connection service here. For Accept=no this is mostly a NOP since the service is figured out at
217 * load time anyway. */
218
219 r = socket_load_service_unit(s, cfd, &service);
220 if (r < 0)
221 return r;
222
223 unit_ref_set(&s->service, UNIT(s), service);
224
225 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, service,
226 false, UNIT_DEPENDENCY_IMPLICIT);
227 }
228
229 static bool have_non_accept_socket(Socket *s) {
230 SocketPort *p;
231
232 assert(s);
233
234 if (!s->accept)
235 return true;
236
237 LIST_FOREACH(port, p, s->ports) {
238
239 if (p->type != SOCKET_SOCKET)
240 return true;
241
242 if (!socket_address_can_accept(&p->address))
243 return true;
244 }
245
246 return false;
247 }
248
249 static int socket_add_mount_dependencies(Socket *s) {
250 SocketPort *p;
251 int r;
252
253 assert(s);
254
255 LIST_FOREACH(port, p, s->ports) {
256 const char *path = NULL;
257
258 if (p->type == SOCKET_SOCKET)
259 path = socket_address_get_path(&p->address);
260 else if (IN_SET(p->type, SOCKET_FIFO, SOCKET_SPECIAL, SOCKET_USB_FUNCTION))
261 path = p->path;
262
263 if (!path)
264 continue;
265
266 r = unit_require_mounts_for(UNIT(s), path, UNIT_DEPENDENCY_FILE);
267 if (r < 0)
268 return r;
269 }
270
271 return 0;
272 }
273
274 static int socket_add_device_dependencies(Socket *s) {
275 char *t;
276
277 assert(s);
278
279 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
280 return 0;
281
282 t = strjoina("/sys/subsystem/net/devices/", s->bind_to_device);
283 return unit_add_node_dependency(UNIT(s), t, UNIT_BINDS_TO, UNIT_DEPENDENCY_FILE);
284 }
285
286 static int socket_add_default_dependencies(Socket *s) {
287 int r;
288 assert(s);
289
290 if (!UNIT(s)->default_dependencies)
291 return 0;
292
293 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
294 if (r < 0)
295 return r;
296
297 if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
298 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
299 if (r < 0)
300 return r;
301 }
302
303 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
304 }
305
306 _pure_ static bool socket_has_exec(Socket *s) {
307 unsigned i;
308 assert(s);
309
310 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
311 if (s->exec_command[i])
312 return true;
313
314 return false;
315 }
316
317 static int socket_add_extras(Socket *s) {
318 Unit *u = UNIT(s);
319 int r;
320
321 assert(s);
322
323 /* Pick defaults for the trigger limit, if nothing was explicitly configured. We pick a relatively high limit
324 * in Accept=yes mode, and a lower limit for Accept=no. Reason: in Accept=yes mode we are invoking accept()
325 * ourselves before the trigger limit can hit, thus incoming connections are taken off the socket queue quickly
326 * and reliably. This is different for Accept=no, where the spawned service has to take the incoming traffic
327 * off the queues, which it might not necessarily do. Moreover, while Accept=no services are supposed to
328 * process whatever is queued in one go, and thus should normally never have to be started frequently. This is
329 * different for Accept=yes where each connection is processed by a new service instance, and thus frequent
330 * service starts are typical. */
331
332 if (s->trigger_limit.interval == USEC_INFINITY)
333 s->trigger_limit.interval = 2 * USEC_PER_SEC;
334
335 if (s->trigger_limit.burst == (unsigned) -1) {
336 if (s->accept)
337 s->trigger_limit.burst = 200;
338 else
339 s->trigger_limit.burst = 20;
340 }
341
342 if (have_non_accept_socket(s)) {
343
344 if (!UNIT_DEREF(s->service)) {
345 Unit *x;
346
347 r = unit_load_related_unit(u, ".service", &x);
348 if (r < 0)
349 return r;
350
351 unit_ref_set(&s->service, u, x);
352 }
353
354 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true, UNIT_DEPENDENCY_IMPLICIT);
355 if (r < 0)
356 return r;
357 }
358
359 r = socket_add_mount_dependencies(s);
360 if (r < 0)
361 return r;
362
363 r = socket_add_device_dependencies(s);
364 if (r < 0)
365 return r;
366
367 r = unit_patch_contexts(u);
368 if (r < 0)
369 return r;
370
371 if (socket_has_exec(s)) {
372 r = unit_add_exec_dependencies(u, &s->exec_context);
373 if (r < 0)
374 return r;
375 }
376
377 r = unit_set_default_slice(u);
378 if (r < 0)
379 return r;
380
381 r = socket_add_default_dependencies(s);
382 if (r < 0)
383 return r;
384
385 return 0;
386 }
387
388 static const char *socket_find_symlink_target(Socket *s) {
389 const char *found = NULL;
390 SocketPort *p;
391
392 LIST_FOREACH(port, p, s->ports) {
393 const char *f = NULL;
394
395 switch (p->type) {
396
397 case SOCKET_FIFO:
398 f = p->path;
399 break;
400
401 case SOCKET_SOCKET:
402 f = socket_address_get_path(&p->address);
403 break;
404
405 default:
406 break;
407 }
408
409 if (f) {
410 if (found)
411 return NULL;
412
413 found = f;
414 }
415 }
416
417 return found;
418 }
419
420 static int socket_verify(Socket *s) {
421 assert(s);
422 assert(UNIT(s)->load_state == UNIT_LOADED);
423
424 if (!s->ports) {
425 log_unit_error(UNIT(s), "Unit has no Listen setting (ListenStream=, ListenDatagram=, ListenFIFO=, ...). Refusing.");
426 return -ENOEXEC;
427 }
428
429 if (s->accept && have_non_accept_socket(s)) {
430 log_unit_error(UNIT(s), "Unit configured for accepting sockets, but sockets are non-accepting. Refusing.");
431 return -ENOEXEC;
432 }
433
434 if (s->accept && s->max_connections <= 0) {
435 log_unit_error(UNIT(s), "MaxConnection= setting too small. Refusing.");
436 return -ENOEXEC;
437 }
438
439 if (s->accept && UNIT_DEREF(s->service)) {
440 log_unit_error(UNIT(s), "Explicit service configuration for accepting socket units not supported. Refusing.");
441 return -ENOEXEC;
442 }
443
444 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
445 log_unit_error(UNIT(s), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing.");
446 return -ENOEXEC;
447 }
448
449 if (!strv_isempty(s->symlinks) && !socket_find_symlink_target(s)) {
450 log_unit_error(UNIT(s), "Unit has symlinks set but none or more than one node in the file system. Refusing.");
451 return -ENOEXEC;
452 }
453
454 return 0;
455 }
456
457 static void peer_address_hash_func(const SocketPeer *s, struct siphash *state) {
458 assert(s);
459
460 if (s->peer.sa.sa_family == AF_INET)
461 siphash24_compress(&s->peer.in.sin_addr, sizeof(s->peer.in.sin_addr), state);
462 else if (s->peer.sa.sa_family == AF_INET6)
463 siphash24_compress(&s->peer.in6.sin6_addr, sizeof(s->peer.in6.sin6_addr), state);
464 else if (s->peer.sa.sa_family == AF_VSOCK)
465 siphash24_compress(&s->peer.vm.svm_cid, sizeof(s->peer.vm.svm_cid), state);
466 else
467 assert_not_reached("Unknown address family.");
468 }
469
470 static int peer_address_compare_func(const SocketPeer *x, const SocketPeer *y) {
471 int r;
472
473 r = CMP(x->peer.sa.sa_family, y->peer.sa.sa_family);
474 if (r != 0)
475 return r;
476
477 switch(x->peer.sa.sa_family) {
478 case AF_INET:
479 return memcmp(&x->peer.in.sin_addr, &y->peer.in.sin_addr, sizeof(x->peer.in.sin_addr));
480 case AF_INET6:
481 return memcmp(&x->peer.in6.sin6_addr, &y->peer.in6.sin6_addr, sizeof(x->peer.in6.sin6_addr));
482 case AF_VSOCK:
483 return CMP(x->peer.vm.svm_cid, y->peer.vm.svm_cid);
484 }
485 assert_not_reached("Black sheep in the family!");
486 }
487
488 DEFINE_PRIVATE_HASH_OPS(peer_address_hash_ops, SocketPeer, peer_address_hash_func, peer_address_compare_func);
489
490 static int socket_load(Unit *u) {
491 Socket *s = SOCKET(u);
492 int r;
493
494 assert(u);
495 assert(u->load_state == UNIT_STUB);
496
497 r = set_ensure_allocated(&s->peers_by_address, &peer_address_hash_ops);
498 if (r < 0)
499 return r;
500
501 r = unit_load_fragment_and_dropin(u, true);
502 if (r < 0)
503 return r;
504
505 if (u->load_state != UNIT_LOADED)
506 return 0;
507
508 /* This is a new unit? Then let's add in some extras */
509 r = socket_add_extras(s);
510 if (r < 0)
511 return r;
512
513 return socket_verify(s);
514 }
515
516 static SocketPeer *socket_peer_new(void) {
517 SocketPeer *p;
518
519 p = new0(SocketPeer, 1);
520 if (!p)
521 return NULL;
522
523 p->n_ref = 1;
524
525 return p;
526 }
527
528 static SocketPeer *socket_peer_free(SocketPeer *p) {
529 assert(p);
530
531 if (p->socket)
532 set_remove(p->socket->peers_by_address, p);
533
534 return mfree(p);
535 }
536
537 DEFINE_TRIVIAL_REF_UNREF_FUNC(SocketPeer, socket_peer, socket_peer_free);
538
539 int socket_acquire_peer(Socket *s, int fd, SocketPeer **p) {
540 _cleanup_(socket_peer_unrefp) SocketPeer *remote = NULL;
541 SocketPeer sa = {}, *i;
542 socklen_t salen = sizeof(sa.peer);
543 int r;
544
545 assert(fd >= 0);
546 assert(s);
547
548 r = getpeername(fd, &sa.peer.sa, &salen);
549 if (r < 0)
550 return log_unit_error_errno(UNIT(s), errno, "getpeername failed: %m");
551
552 if (!IN_SET(sa.peer.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
553 *p = NULL;
554 return 0;
555 }
556
557 i = set_get(s->peers_by_address, &sa);
558 if (i) {
559 *p = socket_peer_ref(i);
560 return 1;
561 }
562
563 remote = socket_peer_new();
564 if (!remote)
565 return log_oom();
566
567 remote->peer = sa.peer;
568 remote->peer_salen = salen;
569
570 r = set_put(s->peers_by_address, remote);
571 if (r < 0)
572 return r;
573
574 remote->socket = s;
575
576 *p = TAKE_PTR(remote);
577
578 return 1;
579 }
580
581 _const_ static const char* listen_lookup(int family, int type) {
582
583 if (family == AF_NETLINK)
584 return "ListenNetlink";
585
586 if (type == SOCK_STREAM)
587 return "ListenStream";
588 else if (type == SOCK_DGRAM)
589 return "ListenDatagram";
590 else if (type == SOCK_SEQPACKET)
591 return "ListenSequentialPacket";
592
593 assert_not_reached("Unknown socket type");
594 return NULL;
595 }
596
597 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
598 char time_string[FORMAT_TIMESPAN_MAX];
599 SocketExecCommand c;
600 Socket *s = SOCKET(u);
601 SocketPort *p;
602 const char *prefix2, *str;
603
604 assert(s);
605 assert(f);
606
607 prefix = strempty(prefix);
608 prefix2 = strjoina(prefix, "\t");
609
610 fprintf(f,
611 "%sSocket State: %s\n"
612 "%sResult: %s\n"
613 "%sClean Result: %s\n"
614 "%sBindIPv6Only: %s\n"
615 "%sBacklog: %u\n"
616 "%sSocketMode: %04o\n"
617 "%sDirectoryMode: %04o\n"
618 "%sKeepAlive: %s\n"
619 "%sNoDelay: %s\n"
620 "%sFreeBind: %s\n"
621 "%sTransparent: %s\n"
622 "%sBroadcast: %s\n"
623 "%sPassCredentials: %s\n"
624 "%sPassSecurity: %s\n"
625 "%sPassPacketInfo: %s\n"
626 "%sTCPCongestion: %s\n"
627 "%sRemoveOnStop: %s\n"
628 "%sWritable: %s\n"
629 "%sFileDescriptorName: %s\n"
630 "%sSELinuxContextFromNet: %s\n",
631 prefix, socket_state_to_string(s->state),
632 prefix, socket_result_to_string(s->result),
633 prefix, socket_result_to_string(s->clean_result),
634 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
635 prefix, s->backlog,
636 prefix, s->socket_mode,
637 prefix, s->directory_mode,
638 prefix, yes_no(s->keep_alive),
639 prefix, yes_no(s->no_delay),
640 prefix, yes_no(s->free_bind),
641 prefix, yes_no(s->transparent),
642 prefix, yes_no(s->broadcast),
643 prefix, yes_no(s->pass_cred),
644 prefix, yes_no(s->pass_sec),
645 prefix, yes_no(s->pass_pktinfo),
646 prefix, strna(s->tcp_congestion),
647 prefix, yes_no(s->remove_on_stop),
648 prefix, yes_no(s->writable),
649 prefix, socket_fdname(s),
650 prefix, yes_no(s->selinux_context_from_net));
651
652 if (s->control_pid > 0)
653 fprintf(f,
654 "%sControl PID: "PID_FMT"\n",
655 prefix, s->control_pid);
656
657 if (s->bind_to_device)
658 fprintf(f,
659 "%sBindToDevice: %s\n",
660 prefix, s->bind_to_device);
661
662 if (s->accept)
663 fprintf(f,
664 "%sAccepted: %u\n"
665 "%sNConnections: %u\n"
666 "%sMaxConnections: %u\n"
667 "%sMaxConnectionsPerSource: %u\n",
668 prefix, s->n_accepted,
669 prefix, s->n_connections,
670 prefix, s->max_connections,
671 prefix, s->max_connections_per_source);
672
673 if (s->priority >= 0)
674 fprintf(f,
675 "%sPriority: %i\n",
676 prefix, s->priority);
677
678 if (s->receive_buffer > 0)
679 fprintf(f,
680 "%sReceiveBuffer: %zu\n",
681 prefix, s->receive_buffer);
682
683 if (s->send_buffer > 0)
684 fprintf(f,
685 "%sSendBuffer: %zu\n",
686 prefix, s->send_buffer);
687
688 if (s->ip_tos >= 0)
689 fprintf(f,
690 "%sIPTOS: %i\n",
691 prefix, s->ip_tos);
692
693 if (s->ip_ttl >= 0)
694 fprintf(f,
695 "%sIPTTL: %i\n",
696 prefix, s->ip_ttl);
697
698 if (s->pipe_size > 0)
699 fprintf(f,
700 "%sPipeSize: %zu\n",
701 prefix, s->pipe_size);
702
703 if (s->mark >= 0)
704 fprintf(f,
705 "%sMark: %i\n",
706 prefix, s->mark);
707
708 if (s->mq_maxmsg > 0)
709 fprintf(f,
710 "%sMessageQueueMaxMessages: %li\n",
711 prefix, s->mq_maxmsg);
712
713 if (s->mq_msgsize > 0)
714 fprintf(f,
715 "%sMessageQueueMessageSize: %li\n",
716 prefix, s->mq_msgsize);
717
718 if (s->reuse_port)
719 fprintf(f,
720 "%sReusePort: %s\n",
721 prefix, yes_no(s->reuse_port));
722
723 if (s->smack)
724 fprintf(f,
725 "%sSmackLabel: %s\n",
726 prefix, s->smack);
727
728 if (s->smack_ip_in)
729 fprintf(f,
730 "%sSmackLabelIPIn: %s\n",
731 prefix, s->smack_ip_in);
732
733 if (s->smack_ip_out)
734 fprintf(f,
735 "%sSmackLabelIPOut: %s\n",
736 prefix, s->smack_ip_out);
737
738 if (!isempty(s->user) || !isempty(s->group))
739 fprintf(f,
740 "%sSocketUser: %s\n"
741 "%sSocketGroup: %s\n",
742 prefix, strna(s->user),
743 prefix, strna(s->group));
744
745 if (s->keep_alive_time > 0)
746 fprintf(f,
747 "%sKeepAliveTimeSec: %s\n",
748 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_time, USEC_PER_SEC));
749
750 if (s->keep_alive_interval > 0)
751 fprintf(f,
752 "%sKeepAliveIntervalSec: %s\n",
753 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_interval, USEC_PER_SEC));
754
755 if (s->keep_alive_cnt > 0)
756 fprintf(f,
757 "%sKeepAliveProbes: %u\n",
758 prefix, s->keep_alive_cnt);
759
760 if (s->defer_accept > 0)
761 fprintf(f,
762 "%sDeferAcceptSec: %s\n",
763 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->defer_accept, USEC_PER_SEC));
764
765 LIST_FOREACH(port, p, s->ports) {
766
767 switch (p->type) {
768 case SOCKET_SOCKET: {
769 _cleanup_free_ char *k = NULL;
770 const char *t;
771 int r;
772
773 r = socket_address_print(&p->address, &k);
774 if (r < 0)
775 t = strerror_safe(r);
776 else
777 t = k;
778
779 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
780 break;
781 }
782 case SOCKET_SPECIAL:
783 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
784 break;
785 case SOCKET_USB_FUNCTION:
786 fprintf(f, "%sListenUSBFunction: %s\n", prefix, p->path);
787 break;
788 case SOCKET_MQUEUE:
789 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
790 break;
791 default:
792 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
793 }
794 }
795
796 fprintf(f,
797 "%sTriggerLimitIntervalSec: %s\n"
798 "%sTriggerLimitBurst: %u\n",
799 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->trigger_limit.interval, USEC_PER_SEC),
800 prefix, s->trigger_limit.burst);
801
802 str = ip_protocol_to_name(s->socket_protocol);
803 if (str)
804 fprintf(f, "%sSocketProtocol: %s\n", prefix, str);
805
806 if (!strv_isempty(s->symlinks)) {
807 char **q;
808
809 fprintf(f, "%sSymlinks:", prefix);
810 STRV_FOREACH(q, s->symlinks)
811 fprintf(f, " %s", *q);
812
813 fprintf(f, "\n");
814 }
815
816 fprintf(f,
817 "%sTimeoutSec: %s\n",
818 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->timeout_usec, USEC_PER_SEC));
819
820 exec_context_dump(&s->exec_context, f, prefix);
821 kill_context_dump(&s->kill_context, f, prefix);
822
823 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
824 if (!s->exec_command[c])
825 continue;
826
827 fprintf(f, "%s-> %s:\n",
828 prefix, socket_exec_command_to_string(c));
829
830 exec_command_dump_list(s->exec_command[c], f, prefix2);
831 }
832
833 cgroup_context_dump(UNIT(s), f, prefix);
834 }
835
836 static int instance_from_socket(int fd, unsigned nr, char **instance) {
837 socklen_t l;
838 char *r;
839 union sockaddr_union local, remote;
840
841 assert(fd >= 0);
842 assert(instance);
843
844 l = sizeof(local);
845 if (getsockname(fd, &local.sa, &l) < 0)
846 return -errno;
847
848 l = sizeof(remote);
849 if (getpeername(fd, &remote.sa, &l) < 0)
850 return -errno;
851
852 switch (local.sa.sa_family) {
853
854 case AF_INET: {
855 uint32_t
856 a = be32toh(local.in.sin_addr.s_addr),
857 b = be32toh(remote.in.sin_addr.s_addr);
858
859 if (asprintf(&r,
860 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
861 nr,
862 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
863 be16toh(local.in.sin_port),
864 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
865 be16toh(remote.in.sin_port)) < 0)
866 return -ENOMEM;
867
868 break;
869 }
870
871 case AF_INET6: {
872 static const unsigned char ipv4_prefix[] = {
873 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
874 };
875
876 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
877 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
878 const uint8_t
879 *a = local.in6.sin6_addr.s6_addr+12,
880 *b = remote.in6.sin6_addr.s6_addr+12;
881
882 if (asprintf(&r,
883 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
884 nr,
885 a[0], a[1], a[2], a[3],
886 be16toh(local.in6.sin6_port),
887 b[0], b[1], b[2], b[3],
888 be16toh(remote.in6.sin6_port)) < 0)
889 return -ENOMEM;
890 } else {
891 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
892
893 if (asprintf(&r,
894 "%u-%s:%u-%s:%u",
895 nr,
896 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
897 be16toh(local.in6.sin6_port),
898 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
899 be16toh(remote.in6.sin6_port)) < 0)
900 return -ENOMEM;
901 }
902
903 break;
904 }
905
906 case AF_UNIX: {
907 struct ucred ucred;
908 int k;
909
910 k = getpeercred(fd, &ucred);
911 if (k >= 0) {
912 if (asprintf(&r,
913 "%u-"PID_FMT"-"UID_FMT,
914 nr, ucred.pid, ucred.uid) < 0)
915 return -ENOMEM;
916 } else if (k == -ENODATA) {
917 /* This handles the case where somebody is
918 * connecting from another pid/uid namespace
919 * (e.g. from outside of our container). */
920 if (asprintf(&r,
921 "%u-unknown",
922 nr) < 0)
923 return -ENOMEM;
924 } else
925 return k;
926
927 break;
928 }
929
930 case AF_VSOCK:
931 if (asprintf(&r,
932 "%u-%u:%u-%u:%u",
933 nr,
934 local.vm.svm_cid, local.vm.svm_port,
935 remote.vm.svm_cid, remote.vm.svm_port) < 0)
936 return -ENOMEM;
937
938 break;
939
940 default:
941 assert_not_reached("Unhandled socket type.");
942 }
943
944 *instance = r;
945 return 0;
946 }
947
948 static void socket_close_fds(Socket *s) {
949 SocketPort *p;
950 char **i;
951
952 assert(s);
953
954 LIST_FOREACH(port, p, s->ports) {
955 bool was_open;
956
957 was_open = p->fd >= 0;
958
959 p->event_source = sd_event_source_unref(p->event_source);
960 p->fd = safe_close(p->fd);
961 socket_cleanup_fd_list(p);
962
963 /* One little note: we should normally not delete any sockets in the file system here! After all some
964 * other process we spawned might still have a reference of this fd and wants to continue to use
965 * it. Therefore we normally delete sockets in the file system before we create a new one, not after we
966 * stopped using one! That all said, if the user explicitly requested this, we'll delete them here
967 * anyway, but only then. */
968
969 if (!was_open || !s->remove_on_stop)
970 continue;
971
972 switch (p->type) {
973
974 case SOCKET_FIFO:
975 (void) unlink(p->path);
976 break;
977
978 case SOCKET_MQUEUE:
979 (void) mq_unlink(p->path);
980 break;
981
982 case SOCKET_SOCKET:
983 (void) socket_address_unlink(&p->address);
984 break;
985
986 default:
987 break;
988 }
989 }
990
991 if (s->remove_on_stop)
992 STRV_FOREACH(i, s->symlinks)
993 (void) unlink(*i);
994 }
995
996 static void socket_apply_socket_options(Socket *s, int fd) {
997 int r;
998
999 assert(s);
1000 assert(fd >= 0);
1001
1002 if (s->keep_alive) {
1003 r = setsockopt_int(fd, SOL_SOCKET, SO_KEEPALIVE, true);
1004 if (r < 0)
1005 log_unit_warning_errno(UNIT(s), r, "SO_KEEPALIVE failed: %m");
1006 }
1007
1008 if (s->keep_alive_time > 0) {
1009 r = setsockopt_int(fd, SOL_TCP, TCP_KEEPIDLE, s->keep_alive_time / USEC_PER_SEC);
1010 if (r < 0)
1011 log_unit_warning_errno(UNIT(s), r, "TCP_KEEPIDLE failed: %m");
1012 }
1013
1014 if (s->keep_alive_interval > 0) {
1015 r = setsockopt_int(fd, SOL_TCP, TCP_KEEPINTVL, s->keep_alive_interval / USEC_PER_SEC);
1016 if (r < 0)
1017 log_unit_warning_errno(UNIT(s), r, "TCP_KEEPINTVL failed: %m");
1018 }
1019
1020 if (s->keep_alive_cnt > 0) {
1021 r = setsockopt_int(fd, SOL_TCP, TCP_KEEPCNT, s->keep_alive_cnt);
1022 if (r < 0)
1023 log_unit_warning_errno(UNIT(s), r, "TCP_KEEPCNT failed: %m");
1024 }
1025
1026 if (s->defer_accept > 0) {
1027 r = setsockopt_int(fd, SOL_TCP, TCP_DEFER_ACCEPT, s->defer_accept / USEC_PER_SEC);
1028 if (r < 0)
1029 log_unit_warning_errno(UNIT(s), r, "TCP_DEFER_ACCEPT failed: %m");
1030 }
1031
1032 if (s->no_delay) {
1033 if (s->socket_protocol == IPPROTO_SCTP) {
1034 r = setsockopt_int(fd, SOL_SCTP, SCTP_NODELAY, true);
1035 if (r < 0)
1036 log_unit_warning_errno(UNIT(s), r, "SCTP_NODELAY failed: %m");
1037 } else {
1038 r = setsockopt_int(fd, SOL_TCP, TCP_NODELAY, true);
1039 if (r < 0)
1040 log_unit_warning_errno(UNIT(s), r, "TCP_NODELAY failed: %m");
1041 }
1042 }
1043
1044 if (s->broadcast) {
1045 r = setsockopt_int(fd, SOL_SOCKET, SO_BROADCAST, true);
1046 if (r < 0)
1047 log_unit_warning_errno(UNIT(s), r, "SO_BROADCAST failed: %m");
1048 }
1049
1050 if (s->pass_cred) {
1051 r = setsockopt_int(fd, SOL_SOCKET, SO_PASSCRED, true);
1052 if (r < 0)
1053 log_unit_warning_errno(UNIT(s), r, "SO_PASSCRED failed: %m");
1054 }
1055
1056 if (s->pass_sec) {
1057 r = setsockopt_int(fd, SOL_SOCKET, SO_PASSSEC, true);
1058 if (r < 0)
1059 log_unit_warning_errno(UNIT(s), r, "SO_PASSSEC failed: %m");
1060 }
1061
1062 if (s->pass_pktinfo) {
1063 r = socket_pass_pktinfo(fd, true);
1064 if (r < 0)
1065 log_unit_warning_errno(UNIT(s), r, "Failed to enable packet info socket option: %m");
1066 }
1067
1068 if (s->priority >= 0) {
1069 r = setsockopt_int(fd, SOL_SOCKET, SO_PRIORITY, s->priority);
1070 if (r < 0)
1071 log_unit_warning_errno(UNIT(s), r, "SO_PRIORITY failed: %m");
1072 }
1073
1074 if (s->receive_buffer > 0) {
1075 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
1076 if (setsockopt_int(fd, SOL_SOCKET, SO_RCVBUFFORCE, s->receive_buffer) < 0) {
1077 r = setsockopt_int(fd, SOL_SOCKET, SO_RCVBUF, s->receive_buffer);
1078 if (r < 0)
1079 log_unit_warning_errno(UNIT(s), r, "SO_RCVBUF failed: %m");
1080 }
1081 }
1082
1083 if (s->send_buffer > 0) {
1084 if (setsockopt_int(fd, SOL_SOCKET, SO_SNDBUFFORCE, s->send_buffer) < 0) {
1085 r = setsockopt_int(fd, SOL_SOCKET, SO_SNDBUF, s->send_buffer);
1086 if (r < 0)
1087 log_unit_warning_errno(UNIT(s), r, "SO_SNDBUF failed: %m");
1088 }
1089 }
1090
1091 if (s->mark >= 0) {
1092 r = setsockopt_int(fd, SOL_SOCKET, SO_MARK, s->mark);
1093 if (r < 0)
1094 log_unit_warning_errno(UNIT(s), r, "SO_MARK failed: %m");
1095 }
1096
1097 if (s->ip_tos >= 0) {
1098 r = setsockopt_int(fd, IPPROTO_IP, IP_TOS, s->ip_tos);
1099 if (r < 0)
1100 log_unit_warning_errno(UNIT(s), r, "IP_TOS failed: %m");
1101 }
1102
1103 if (s->ip_ttl >= 0) {
1104 int x;
1105
1106 r = setsockopt_int(fd, IPPROTO_IP, IP_TTL, s->ip_ttl);
1107
1108 if (socket_ipv6_is_supported())
1109 x = setsockopt_int(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, s->ip_ttl);
1110 else
1111 x = -EAFNOSUPPORT;
1112
1113 if (r < 0 && x < 0)
1114 log_unit_warning_errno(UNIT(s), r, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
1115 }
1116
1117 if (s->tcp_congestion)
1118 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
1119 log_unit_warning_errno(UNIT(s), errno, "TCP_CONGESTION failed: %m");
1120
1121 if (s->smack_ip_in) {
1122 r = mac_smack_apply_fd(fd, SMACK_ATTR_IPIN, s->smack_ip_in);
1123 if (r < 0)
1124 log_unit_error_errno(UNIT(s), r, "mac_smack_apply_ip_in_fd: %m");
1125 }
1126
1127 if (s->smack_ip_out) {
1128 r = mac_smack_apply_fd(fd, SMACK_ATTR_IPOUT, s->smack_ip_out);
1129 if (r < 0)
1130 log_unit_error_errno(UNIT(s), r, "mac_smack_apply_ip_out_fd: %m");
1131 }
1132 }
1133
1134 static void socket_apply_fifo_options(Socket *s, int fd) {
1135 int r;
1136
1137 assert(s);
1138 assert(fd >= 0);
1139
1140 if (s->pipe_size > 0)
1141 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
1142 log_unit_warning_errno(UNIT(s), errno, "Setting pipe size failed, ignoring: %m");
1143
1144 if (s->smack) {
1145 r = mac_smack_apply_fd(fd, SMACK_ATTR_ACCESS, s->smack);
1146 if (r < 0)
1147 log_unit_error_errno(UNIT(s), r, "SMACK relabelling failed, ignoring: %m");
1148 }
1149 }
1150
1151 static int fifo_address_create(
1152 const char *path,
1153 mode_t directory_mode,
1154 mode_t socket_mode) {
1155
1156 _cleanup_close_ int fd = -1;
1157 mode_t old_mask;
1158 struct stat st;
1159 int r;
1160
1161 assert(path);
1162
1163 (void) mkdir_parents_label(path, directory_mode);
1164
1165 r = mac_selinux_create_file_prepare(path, S_IFIFO);
1166 if (r < 0)
1167 return r;
1168
1169 /* Enforce the right access mode for the fifo */
1170 old_mask = umask(~socket_mode);
1171
1172 /* Include the original umask in our mask */
1173 (void) umask(~socket_mode | old_mask);
1174
1175 r = mkfifo(path, socket_mode);
1176 (void) umask(old_mask);
1177
1178 if (r < 0 && errno != EEXIST) {
1179 r = -errno;
1180 goto fail;
1181 }
1182
1183 fd = open(path, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK | O_NOFOLLOW);
1184 if (fd < 0) {
1185 r = -errno;
1186 goto fail;
1187 }
1188
1189 mac_selinux_create_file_clear();
1190
1191 if (fstat(fd, &st) < 0) {
1192 r = -errno;
1193 goto fail;
1194 }
1195
1196 if (!S_ISFIFO(st.st_mode) ||
1197 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
1198 st.st_uid != getuid() ||
1199 st.st_gid != getgid()) {
1200 r = -EEXIST;
1201 goto fail;
1202 }
1203
1204 return TAKE_FD(fd);
1205
1206 fail:
1207 mac_selinux_create_file_clear();
1208 return r;
1209 }
1210
1211 static int special_address_create(const char *path, bool writable) {
1212 _cleanup_close_ int fd = -1;
1213 struct stat st;
1214
1215 assert(path);
1216
1217 fd = open(path, (writable ? O_RDWR : O_RDONLY)|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
1218 if (fd < 0)
1219 return -errno;
1220
1221 if (fstat(fd, &st) < 0)
1222 return -errno;
1223
1224 /* Check whether this is a /proc, /sys or /dev file or char device */
1225 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode))
1226 return -EEXIST;
1227
1228 return TAKE_FD(fd);
1229 }
1230
1231 static int usbffs_address_create(const char *path) {
1232 _cleanup_close_ int fd = -1;
1233 struct stat st;
1234
1235 assert(path);
1236
1237 fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
1238 if (fd < 0)
1239 return -errno;
1240
1241 if (fstat(fd, &st) < 0)
1242 return -errno;
1243
1244 /* Check whether this is a regular file (ffs endpoint) */
1245 if (!S_ISREG(st.st_mode))
1246 return -EEXIST;
1247
1248 return TAKE_FD(fd);
1249 }
1250
1251 static int mq_address_create(
1252 const char *path,
1253 mode_t mq_mode,
1254 long maxmsg,
1255 long msgsize) {
1256
1257 _cleanup_close_ int fd = -1;
1258 struct stat st;
1259 mode_t old_mask;
1260 struct mq_attr _attr, *attr = NULL;
1261
1262 assert(path);
1263
1264 if (maxmsg > 0 && msgsize > 0) {
1265 _attr = (struct mq_attr) {
1266 .mq_flags = O_NONBLOCK,
1267 .mq_maxmsg = maxmsg,
1268 .mq_msgsize = msgsize,
1269 };
1270 attr = &_attr;
1271 }
1272
1273 /* Enforce the right access mode for the mq */
1274 old_mask = umask(~mq_mode);
1275
1276 /* Include the original umask in our mask */
1277 (void) umask(~mq_mode | old_mask);
1278 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
1279 (void) umask(old_mask);
1280
1281 if (fd < 0)
1282 return -errno;
1283
1284 if (fstat(fd, &st) < 0)
1285 return -errno;
1286
1287 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
1288 st.st_uid != getuid() ||
1289 st.st_gid != getgid())
1290 return -EEXIST;
1291
1292 return TAKE_FD(fd);
1293 }
1294
1295 static int socket_symlink(Socket *s) {
1296 const char *p;
1297 char **i;
1298 int r;
1299
1300 assert(s);
1301
1302 p = socket_find_symlink_target(s);
1303 if (!p)
1304 return 0;
1305
1306 STRV_FOREACH(i, s->symlinks) {
1307 (void) mkdir_parents_label(*i, s->directory_mode);
1308
1309 r = symlink_idempotent(p, *i, false);
1310
1311 if (r == -EEXIST && s->remove_on_stop) {
1312 /* If there's already something where we want to create the symlink, and the destructive
1313 * RemoveOnStop= mode is set, then we might as well try to remove what already exists and try
1314 * again. */
1315
1316 if (unlink(*i) >= 0)
1317 r = symlink_idempotent(p, *i, false);
1318 }
1319
1320 if (r < 0)
1321 log_unit_warning_errno(UNIT(s), r, "Failed to create symlink %s → %s, ignoring: %m", p, *i);
1322 }
1323
1324 return 0;
1325 }
1326
1327 static int usbffs_write_descs(int fd, Service *s) {
1328 int r;
1329
1330 if (!s->usb_function_descriptors || !s->usb_function_strings)
1331 return -EINVAL;
1332
1333 r = copy_file_fd(s->usb_function_descriptors, fd, 0);
1334 if (r < 0)
1335 return r;
1336
1337 return copy_file_fd(s->usb_function_strings, fd, 0);
1338 }
1339
1340 static int usbffs_select_ep(const struct dirent *d) {
1341 return d->d_name[0] != '.' && !streq(d->d_name, "ep0");
1342 }
1343
1344 static int usbffs_dispatch_eps(SocketPort *p) {
1345 _cleanup_free_ struct dirent **ent = NULL;
1346 size_t n, k, i;
1347 int r;
1348
1349 r = scandir(p->path, &ent, usbffs_select_ep, alphasort);
1350 if (r < 0)
1351 return -errno;
1352
1353 n = (size_t) r;
1354 p->auxiliary_fds = new(int, n);
1355 if (!p->auxiliary_fds) {
1356 r = -ENOMEM;
1357 goto clear;
1358 }
1359
1360 p->n_auxiliary_fds = n;
1361
1362 k = 0;
1363 for (i = 0; i < n; ++i) {
1364 _cleanup_free_ char *ep = NULL;
1365
1366 ep = path_make_absolute(ent[i]->d_name, p->path);
1367 if (!ep) {
1368 r = -ENOMEM;
1369 goto fail;
1370 }
1371
1372 path_simplify(ep, false);
1373
1374 r = usbffs_address_create(ep);
1375 if (r < 0)
1376 goto fail;
1377
1378 p->auxiliary_fds[k++] = r;
1379 }
1380
1381 r = 0;
1382 goto clear;
1383
1384 fail:
1385 close_many(p->auxiliary_fds, k);
1386 p->auxiliary_fds = mfree(p->auxiliary_fds);
1387 p->n_auxiliary_fds = 0;
1388
1389 clear:
1390 for (i = 0; i < n; ++i)
1391 free(ent[i]);
1392
1393 return r;
1394 }
1395
1396 int socket_load_service_unit(Socket *s, int cfd, Unit **ret) {
1397 /* Figure out what the unit that will be used to handle the connections on the socket looks like.
1398 *
1399 * If cfd < 0, then we don't have a connection yet. In case of Accept=yes sockets, use a fake
1400 * instance name.
1401 */
1402
1403 if (UNIT_ISSET(s->service)) {
1404 *ret = UNIT_DEREF(s->service);
1405 return 0;
1406 }
1407
1408 if (!s->accept)
1409 return -ENODATA;
1410
1411 /* Build the instance name and load the unit */
1412 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1413 int r;
1414
1415 r = unit_name_to_prefix(UNIT(s)->id, &prefix);
1416 if (r < 0)
1417 return r;
1418
1419 if (cfd >= 0) {
1420 r = instance_from_socket(cfd, s->n_accepted, &instance);
1421 if (r == -ENOTCONN)
1422 /* ENOTCONN is legitimate if TCP RST was received.
1423 * This connection is over, but the socket unit lives on. */
1424 return log_unit_debug_errno(UNIT(s), r,
1425 "Got ENOTCONN on incoming socket, assuming aborted connection attempt, ignoring.");
1426 if (r < 0)
1427 return r;
1428 }
1429
1430 /* For accepting sockets, we don't know how the instance will be called until we get a connection and
1431 * can figure out what the peer name is. So let's use "internal" as the instance to make it clear
1432 * that this is not an actual peer name. We use "unknown" when we cannot figure out the peer. */
1433 r = unit_name_build(prefix, instance ?: "internal", ".service", &name);
1434 if (r < 0)
1435 return r;
1436
1437 return manager_load_unit(UNIT(s)->manager, name, NULL, NULL, ret);
1438 }
1439
1440 static int socket_determine_selinux_label(Socket *s, char **ret) {
1441 int r;
1442
1443 assert(s);
1444 assert(ret);
1445
1446 if (s->selinux_context_from_net) {
1447 /* If this is requested, get the label from the network label */
1448
1449 r = mac_selinux_get_our_label(ret);
1450 if (r == -EOPNOTSUPP)
1451 goto no_label;
1452
1453 } else {
1454 /* Otherwise, get it from the executable we are about to start. */
1455
1456 Unit *service;
1457 ExecCommand *c;
1458 _cleanup_free_ char *path = NULL;
1459
1460 r = socket_load_service_unit(s, -1, &service);
1461 if (r == -ENODATA)
1462 goto no_label;
1463 if (r < 0)
1464 return r;
1465
1466 c = SERVICE(service)->exec_command[SERVICE_EXEC_START];
1467 if (!c)
1468 goto no_label;
1469
1470 r = chase_symlinks(c->path, SERVICE(service)->exec_context.root_directory, CHASE_PREFIX_ROOT, &path, NULL);
1471 if (r < 0)
1472 goto no_label;
1473
1474 r = mac_selinux_get_create_label_from_exe(path, ret);
1475 if (IN_SET(r, -EPERM, -EOPNOTSUPP))
1476 goto no_label;
1477 }
1478
1479 return r;
1480
1481 no_label:
1482 *ret = NULL;
1483 return 0;
1484 }
1485
1486 static int socket_address_listen_do(
1487 Socket *s,
1488 const SocketAddress *address,
1489 const char *label) {
1490
1491 assert(s);
1492 assert(address);
1493
1494 return socket_address_listen(
1495 address,
1496 SOCK_CLOEXEC|SOCK_NONBLOCK,
1497 s->backlog,
1498 s->bind_ipv6_only,
1499 s->bind_to_device,
1500 s->reuse_port,
1501 s->free_bind,
1502 s->transparent,
1503 s->directory_mode,
1504 s->socket_mode,
1505 label);
1506 }
1507
1508 #define log_address_error_errno(u, address, error, fmt) \
1509 ({ \
1510 _cleanup_free_ char *_t = NULL; \
1511 \
1512 (void) socket_address_print(address, &_t); \
1513 log_unit_error_errno(u, error, fmt, strna(_t)); \
1514 })
1515
1516 static int fork_needed(const SocketAddress *address, const ExecContext *context) {
1517 int r;
1518
1519 assert(address);
1520 assert(context);
1521
1522 /* Check if we need to do the cgroup or netns stuff. If not we can do things much simpler. */
1523
1524 if (IN_SET(address->sockaddr.sa.sa_family, AF_INET, AF_INET6)) {
1525 r = bpf_firewall_supported();
1526 if (r < 0)
1527 return r;
1528 if (r != BPF_FIREWALL_UNSUPPORTED) /* If BPF firewalling isn't supported anyway — there's no point in this forking complexity */
1529 return true;
1530 }
1531
1532 return context->private_network || context->network_namespace_path;
1533 }
1534
1535 static int socket_address_listen_in_cgroup(
1536 Socket *s,
1537 const SocketAddress *address,
1538 const char *label) {
1539
1540 _cleanup_close_pair_ int pair[2] = { -1, -1 };
1541 int fd, r;
1542 pid_t pid;
1543
1544 assert(s);
1545 assert(address);
1546
1547 /* This is a wrapper around socket_address_listen(), that forks off a helper process inside the
1548 * socket's cgroup and network namespace in which the socket is actually created. This way we ensure
1549 * the socket is actually properly attached to the unit's cgroup for the purpose of BPF filtering and
1550 * such. */
1551
1552 r = fork_needed(address, &s->exec_context);
1553 if (r < 0)
1554 return r;
1555 if (r == 0) {
1556 /* Shortcut things... */
1557 fd = socket_address_listen_do(s, address, label);
1558 if (fd < 0)
1559 return log_address_error_errno(UNIT(s), address, fd, "Failed to create listening socket (%s): %m");
1560
1561 return fd;
1562 }
1563
1564 r = unit_setup_exec_runtime(UNIT(s));
1565 if (r < 0)
1566 return log_unit_error_errno(UNIT(s), r, "Failed acquire runtime: %m");
1567
1568 if (s->exec_context.network_namespace_path &&
1569 s->exec_runtime &&
1570 s->exec_runtime->netns_storage_socket[0] >= 0) {
1571 r = open_netns_path(s->exec_runtime->netns_storage_socket, s->exec_context.network_namespace_path);
1572 if (r < 0)
1573 return log_unit_error_errno(UNIT(s), r, "Failed to open network namespace path %s: %m", s->exec_context.network_namespace_path);
1574 }
1575
1576 if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
1577 return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
1578
1579 r = unit_fork_helper_process(UNIT(s), "(sd-listen)", &pid);
1580 if (r < 0)
1581 return log_unit_error_errno(UNIT(s), r, "Failed to fork off listener stub process: %m");
1582 if (r == 0) {
1583 /* Child */
1584
1585 pair[0] = safe_close(pair[0]);
1586
1587 if ((s->exec_context.private_network || s->exec_context.network_namespace_path) &&
1588 s->exec_runtime &&
1589 s->exec_runtime->netns_storage_socket[0] >= 0) {
1590
1591 if (ns_type_supported(NAMESPACE_NET)) {
1592 r = setup_netns(s->exec_runtime->netns_storage_socket);
1593 if (r < 0) {
1594 log_unit_error_errno(UNIT(s), r, "Failed to join network namespace: %m");
1595 _exit(EXIT_NETWORK);
1596 }
1597 } else if (s->exec_context.network_namespace_path) {
1598 log_unit_error(UNIT(s), "Network namespace path configured but network namespaces not supported.");
1599 _exit(EXIT_NETWORK);
1600 } else
1601 log_unit_warning(UNIT(s), "PrivateNetwork=yes is configured, but the kernel does not support network namespaces, ignoring.");
1602 }
1603
1604 fd = socket_address_listen_do(s, address, label);
1605 if (fd < 0) {
1606 log_address_error_errno(UNIT(s), address, fd, "Failed to create listening socket (%s): %m");
1607 _exit(EXIT_FAILURE);
1608 }
1609
1610 r = send_one_fd(pair[1], fd, 0);
1611 if (r < 0) {
1612 log_address_error_errno(UNIT(s), address, r, "Failed to send listening socket (%s) to parent: %m");
1613 _exit(EXIT_FAILURE);
1614 }
1615
1616 _exit(EXIT_SUCCESS);
1617 }
1618
1619 pair[1] = safe_close(pair[1]);
1620 fd = receive_one_fd(pair[0], 0);
1621
1622 /* We synchronously wait for the helper, as it shouldn't be slow */
1623 r = wait_for_terminate_and_check("(sd-listen)", pid, WAIT_LOG_ABNORMAL);
1624 if (r < 0) {
1625 safe_close(fd);
1626 return r;
1627 }
1628
1629 if (fd < 0)
1630 return log_address_error_errno(UNIT(s), address, fd, "Failed to receive listening socket (%s): %m");
1631
1632 return fd;
1633 }
1634
1635 DEFINE_TRIVIAL_CLEANUP_FUNC(Socket *, socket_close_fds);
1636
1637 static int socket_open_fds(Socket *_s) {
1638 _cleanup_(socket_close_fdsp) Socket *s = _s;
1639 _cleanup_(mac_selinux_freep) char *label = NULL;
1640 bool know_label = false;
1641 SocketPort *p;
1642 int r;
1643
1644 assert(s);
1645
1646 LIST_FOREACH(port, p, s->ports) {
1647
1648 if (p->fd >= 0)
1649 continue;
1650
1651 switch (p->type) {
1652
1653 case SOCKET_SOCKET:
1654
1655 if (!know_label) {
1656 /* Figure out the label, if we don't it know yet. We do it once for the first
1657 * socket where we need this and remember it for the rest. */
1658
1659 r = socket_determine_selinux_label(s, &label);
1660 if (r < 0)
1661 return log_unit_error_errno(UNIT(s), r, "Failed to determine SELinux label: %m");
1662
1663 know_label = true;
1664 }
1665
1666 /* Apply the socket protocol */
1667 switch (p->address.type) {
1668
1669 case SOCK_STREAM:
1670 case SOCK_SEQPACKET:
1671 if (s->socket_protocol == IPPROTO_SCTP)
1672 p->address.protocol = s->socket_protocol;
1673 break;
1674
1675 case SOCK_DGRAM:
1676 if (s->socket_protocol == IPPROTO_UDPLITE)
1677 p->address.protocol = s->socket_protocol;
1678 break;
1679 }
1680
1681 p->fd = socket_address_listen_in_cgroup(s, &p->address, label);
1682 if (p->fd < 0)
1683 return p->fd;
1684
1685 socket_apply_socket_options(s, p->fd);
1686 socket_symlink(s);
1687 break;
1688
1689 case SOCKET_SPECIAL:
1690
1691 p->fd = special_address_create(p->path, s->writable);
1692 if (p->fd < 0)
1693 return log_unit_error_errno(UNIT(s), p->fd, "Failed to open special file %s: %m", p->path);
1694 break;
1695
1696 case SOCKET_FIFO:
1697
1698 p->fd = fifo_address_create(
1699 p->path,
1700 s->directory_mode,
1701 s->socket_mode);
1702 if (p->fd < 0)
1703 return log_unit_error_errno(UNIT(s), p->fd, "Failed to open FIFO %s: %m", p->path);
1704
1705 socket_apply_fifo_options(s, p->fd);
1706 socket_symlink(s);
1707 break;
1708
1709 case SOCKET_MQUEUE:
1710
1711 p->fd = mq_address_create(
1712 p->path,
1713 s->socket_mode,
1714 s->mq_maxmsg,
1715 s->mq_msgsize);
1716 if (p->fd < 0)
1717 return log_unit_error_errno(UNIT(s), p->fd, "Failed to open message queue %s: %m", p->path);
1718 break;
1719
1720 case SOCKET_USB_FUNCTION: {
1721 _cleanup_free_ char *ep = NULL;
1722
1723 ep = path_make_absolute("ep0", p->path);
1724
1725 p->fd = usbffs_address_create(ep);
1726 if (p->fd < 0)
1727 return p->fd;
1728
1729 r = usbffs_write_descs(p->fd, SERVICE(UNIT_DEREF(s->service)));
1730 if (r < 0)
1731 return r;
1732
1733 r = usbffs_dispatch_eps(p);
1734 if (r < 0)
1735 return r;
1736
1737 break;
1738 }
1739 default:
1740 assert_not_reached("Unknown port type");
1741 }
1742 }
1743
1744 s = NULL;
1745 return 0;
1746 }
1747
1748 static void socket_unwatch_fds(Socket *s) {
1749 SocketPort *p;
1750 int r;
1751
1752 assert(s);
1753
1754 LIST_FOREACH(port, p, s->ports) {
1755 if (p->fd < 0)
1756 continue;
1757
1758 if (!p->event_source)
1759 continue;
1760
1761 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1762 if (r < 0)
1763 log_unit_debug_errno(UNIT(s), r, "Failed to disable event source: %m");
1764 }
1765 }
1766
1767 static int socket_watch_fds(Socket *s) {
1768 SocketPort *p;
1769 int r;
1770
1771 assert(s);
1772
1773 LIST_FOREACH(port, p, s->ports) {
1774 if (p->fd < 0)
1775 continue;
1776
1777 if (p->event_source) {
1778 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1779 if (r < 0)
1780 goto fail;
1781 } else {
1782 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1783 if (r < 0)
1784 goto fail;
1785
1786 (void) sd_event_source_set_description(p->event_source, "socket-port-io");
1787 }
1788 }
1789
1790 return 0;
1791
1792 fail:
1793 log_unit_warning_errno(UNIT(s), r, "Failed to watch listening fds: %m");
1794 socket_unwatch_fds(s);
1795 return r;
1796 }
1797
1798 enum {
1799 SOCKET_OPEN_NONE,
1800 SOCKET_OPEN_SOME,
1801 SOCKET_OPEN_ALL,
1802 };
1803
1804 static int socket_check_open(Socket *s) {
1805 bool have_open = false, have_closed = false;
1806 SocketPort *p;
1807
1808 assert(s);
1809
1810 LIST_FOREACH(port, p, s->ports) {
1811 if (p->fd < 0)
1812 have_closed = true;
1813 else
1814 have_open = true;
1815
1816 if (have_open && have_closed)
1817 return SOCKET_OPEN_SOME;
1818 }
1819
1820 if (have_open)
1821 return SOCKET_OPEN_ALL;
1822
1823 return SOCKET_OPEN_NONE;
1824 }
1825
1826 static void socket_set_state(Socket *s, SocketState state) {
1827 SocketState old_state;
1828 assert(s);
1829
1830 if (s->state != state)
1831 bus_unit_send_pending_change_signal(UNIT(s), false);
1832
1833 old_state = s->state;
1834 s->state = state;
1835
1836 if (!IN_SET(state,
1837 SOCKET_START_PRE,
1838 SOCKET_START_CHOWN,
1839 SOCKET_START_POST,
1840 SOCKET_STOP_PRE,
1841 SOCKET_STOP_PRE_SIGTERM,
1842 SOCKET_STOP_PRE_SIGKILL,
1843 SOCKET_STOP_POST,
1844 SOCKET_FINAL_SIGTERM,
1845 SOCKET_FINAL_SIGKILL,
1846 SOCKET_CLEANING)) {
1847
1848 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1849 socket_unwatch_control_pid(s);
1850 s->control_command = NULL;
1851 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1852 }
1853
1854 if (state != SOCKET_LISTENING)
1855 socket_unwatch_fds(s);
1856
1857 if (!IN_SET(state,
1858 SOCKET_START_CHOWN,
1859 SOCKET_START_POST,
1860 SOCKET_LISTENING,
1861 SOCKET_RUNNING,
1862 SOCKET_STOP_PRE,
1863 SOCKET_STOP_PRE_SIGTERM,
1864 SOCKET_STOP_PRE_SIGKILL,
1865 SOCKET_CLEANING))
1866 socket_close_fds(s);
1867
1868 if (state != old_state)
1869 log_unit_debug(UNIT(s), "Changed %s -> %s", socket_state_to_string(old_state), socket_state_to_string(state));
1870
1871 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], 0);
1872 }
1873
1874 static int socket_coldplug(Unit *u) {
1875 Socket *s = SOCKET(u);
1876 int r;
1877
1878 assert(s);
1879 assert(s->state == SOCKET_DEAD);
1880
1881 if (s->deserialized_state == s->state)
1882 return 0;
1883
1884 if (s->control_pid > 0 &&
1885 pid_is_unwaited(s->control_pid) &&
1886 IN_SET(s->deserialized_state,
1887 SOCKET_START_PRE,
1888 SOCKET_START_CHOWN,
1889 SOCKET_START_POST,
1890 SOCKET_STOP_PRE,
1891 SOCKET_STOP_PRE_SIGTERM,
1892 SOCKET_STOP_PRE_SIGKILL,
1893 SOCKET_STOP_POST,
1894 SOCKET_FINAL_SIGTERM,
1895 SOCKET_FINAL_SIGKILL,
1896 SOCKET_CLEANING)) {
1897
1898 r = unit_watch_pid(UNIT(s), s->control_pid, false);
1899 if (r < 0)
1900 return r;
1901
1902 r = socket_arm_timer(s, usec_add(u->state_change_timestamp.monotonic, s->timeout_usec));
1903 if (r < 0)
1904 return r;
1905 }
1906
1907 if (IN_SET(s->deserialized_state,
1908 SOCKET_START_CHOWN,
1909 SOCKET_START_POST,
1910 SOCKET_LISTENING,
1911 SOCKET_RUNNING)) {
1912
1913 /* Originally, we used to simply reopen all sockets here that we didn't have file descriptors
1914 * for. However, this is problematic, as we won't traverse through the SOCKET_START_CHOWN state for
1915 * them, and thus the UID/GID wouldn't be right. Hence, instead simply check if we have all fds open,
1916 * and if there's a mismatch, warn loudly. */
1917
1918 r = socket_check_open(s);
1919 if (r == SOCKET_OPEN_NONE)
1920 log_unit_warning(UNIT(s),
1921 "Socket unit configuration has changed while unit has been running, "
1922 "no open socket file descriptor left. "
1923 "The socket unit is not functional until restarted.");
1924 else if (r == SOCKET_OPEN_SOME)
1925 log_unit_warning(UNIT(s),
1926 "Socket unit configuration has changed while unit has been running, "
1927 "and some socket file descriptors have not been opened yet. "
1928 "The socket unit is not fully functional until restarted.");
1929 }
1930
1931 if (s->deserialized_state == SOCKET_LISTENING) {
1932 r = socket_watch_fds(s);
1933 if (r < 0)
1934 return r;
1935 }
1936
1937 if (!IN_SET(s->deserialized_state, SOCKET_DEAD, SOCKET_FAILED, SOCKET_CLEANING)) {
1938 (void) unit_setup_dynamic_creds(u);
1939 (void) unit_setup_exec_runtime(u);
1940 }
1941
1942 socket_set_state(s, s->deserialized_state);
1943 return 0;
1944 }
1945
1946 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1947
1948 _cleanup_(exec_params_clear) ExecParameters exec_params = {
1949 .flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
1950 .stdin_fd = -1,
1951 .stdout_fd = -1,
1952 .stderr_fd = -1,
1953 .exec_fd = -1,
1954 };
1955 pid_t pid;
1956 int r;
1957
1958 assert(s);
1959 assert(c);
1960 assert(_pid);
1961
1962 r = unit_prepare_exec(UNIT(s));
1963 if (r < 0)
1964 return r;
1965
1966 r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
1967 if (r < 0)
1968 return r;
1969
1970 r = unit_set_exec_params(UNIT(s), &exec_params);
1971 if (r < 0)
1972 return r;
1973
1974 r = exec_spawn(UNIT(s),
1975 c,
1976 &s->exec_context,
1977 &exec_params,
1978 s->exec_runtime,
1979 &s->dynamic_creds,
1980 &pid);
1981 if (r < 0)
1982 return r;
1983
1984 r = unit_watch_pid(UNIT(s), pid, true);
1985 if (r < 0)
1986 return r;
1987
1988 *_pid = pid;
1989
1990 return 0;
1991 }
1992
1993 static int socket_chown(Socket *s, pid_t *_pid) {
1994 pid_t pid;
1995 int r;
1996
1997 r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
1998 if (r < 0)
1999 goto fail;
2000
2001 /* We have to resolve the user names out-of-process, hence
2002 * let's fork here. It's messy, but well, what can we do? */
2003
2004 r = unit_fork_helper_process(UNIT(s), "(sd-chown)", &pid);
2005 if (r < 0)
2006 return r;
2007 if (r == 0) {
2008 uid_t uid = UID_INVALID;
2009 gid_t gid = GID_INVALID;
2010 SocketPort *p;
2011
2012 /* Child */
2013
2014 if (!isempty(s->user)) {
2015 const char *user = s->user;
2016
2017 r = get_user_creds(&user, &uid, &gid, NULL, NULL, 0);
2018 if (r < 0) {
2019 log_unit_error_errno(UNIT(s), r, "Failed to resolve user %s: %m", user);
2020 _exit(EXIT_USER);
2021 }
2022 }
2023
2024 if (!isempty(s->group)) {
2025 const char *group = s->group;
2026
2027 r = get_group_creds(&group, &gid, 0);
2028 if (r < 0) {
2029 log_unit_error_errno(UNIT(s), r, "Failed to resolve group %s: %m", group);
2030 _exit(EXIT_GROUP);
2031 }
2032 }
2033
2034 LIST_FOREACH(port, p, s->ports) {
2035 const char *path = NULL;
2036
2037 if (p->type == SOCKET_SOCKET)
2038 path = socket_address_get_path(&p->address);
2039 else if (p->type == SOCKET_FIFO)
2040 path = p->path;
2041
2042 if (!path)
2043 continue;
2044
2045 if (chown(path, uid, gid) < 0) {
2046 log_unit_error_errno(UNIT(s), errno, "Failed to chown(): %m");
2047 _exit(EXIT_CHOWN);
2048 }
2049 }
2050
2051 _exit(EXIT_SUCCESS);
2052 }
2053
2054 r = unit_watch_pid(UNIT(s), pid, true);
2055 if (r < 0)
2056 goto fail;
2057
2058 *_pid = pid;
2059 return 0;
2060
2061 fail:
2062 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
2063 return r;
2064 }
2065
2066 static void socket_enter_dead(Socket *s, SocketResult f) {
2067 assert(s);
2068
2069 if (s->result == SOCKET_SUCCESS)
2070 s->result = f;
2071
2072 if (s->result == SOCKET_SUCCESS)
2073 unit_log_success(UNIT(s));
2074 else
2075 unit_log_failure(UNIT(s), socket_result_to_string(s->result));
2076
2077 unit_warn_leftover_processes(UNIT(s), unit_log_leftover_process_stop);
2078
2079 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
2080
2081 s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
2082
2083 unit_destroy_runtime_directory(UNIT(s), &s->exec_context);
2084
2085 unit_unref_uid_gid(UNIT(s), true);
2086
2087 dynamic_creds_destroy(&s->dynamic_creds);
2088 }
2089
2090 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
2091
2092 static void socket_enter_stop_post(Socket *s, SocketResult f) {
2093 int r;
2094 assert(s);
2095
2096 if (s->result == SOCKET_SUCCESS)
2097 s->result = f;
2098
2099 socket_unwatch_control_pid(s);
2100 s->control_command_id = SOCKET_EXEC_STOP_POST;
2101 s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST];
2102
2103 if (s->control_command) {
2104 r = socket_spawn(s, s->control_command, &s->control_pid);
2105 if (r < 0)
2106 goto fail;
2107
2108 socket_set_state(s, SOCKET_STOP_POST);
2109 } else
2110 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
2111
2112 return;
2113
2114 fail:
2115 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
2116 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
2117 }
2118
2119 static int state_to_kill_operation(Socket *s, SocketState state) {
2120 if (state == SOCKET_STOP_PRE_SIGTERM && unit_has_job_type(UNIT(s), JOB_RESTART))
2121 return KILL_RESTART;
2122
2123 if (state == SOCKET_FINAL_SIGTERM)
2124 return KILL_TERMINATE;
2125
2126 return KILL_KILL;
2127 }
2128
2129 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
2130 int r;
2131
2132 assert(s);
2133
2134 if (s->result == SOCKET_SUCCESS)
2135 s->result = f;
2136
2137 r = unit_kill_context(
2138 UNIT(s),
2139 &s->kill_context,
2140 state_to_kill_operation(s, state),
2141 -1,
2142 s->control_pid,
2143 false);
2144 if (r < 0)
2145 goto fail;
2146
2147 if (r > 0) {
2148 r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
2149 if (r < 0)
2150 goto fail;
2151
2152 socket_set_state(s, state);
2153 } else if (state == SOCKET_STOP_PRE_SIGTERM)
2154 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
2155 else if (state == SOCKET_STOP_PRE_SIGKILL)
2156 socket_enter_stop_post(s, SOCKET_SUCCESS);
2157 else if (state == SOCKET_FINAL_SIGTERM)
2158 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
2159 else
2160 socket_enter_dead(s, SOCKET_SUCCESS);
2161
2162 return;
2163
2164 fail:
2165 log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
2166
2167 if (IN_SET(state, SOCKET_STOP_PRE_SIGTERM, SOCKET_STOP_PRE_SIGKILL))
2168 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
2169 else
2170 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
2171 }
2172
2173 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
2174 int r;
2175 assert(s);
2176
2177 if (s->result == SOCKET_SUCCESS)
2178 s->result = f;
2179
2180 socket_unwatch_control_pid(s);
2181 s->control_command_id = SOCKET_EXEC_STOP_PRE;
2182 s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE];
2183
2184 if (s->control_command) {
2185 r = socket_spawn(s, s->control_command, &s->control_pid);
2186 if (r < 0)
2187 goto fail;
2188
2189 socket_set_state(s, SOCKET_STOP_PRE);
2190 } else
2191 socket_enter_stop_post(s, SOCKET_SUCCESS);
2192
2193 return;
2194
2195 fail:
2196 log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-pre' task: %m");
2197 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
2198 }
2199
2200 static void socket_enter_listening(Socket *s) {
2201 int r;
2202 assert(s);
2203
2204 r = socket_watch_fds(s);
2205 if (r < 0) {
2206 log_unit_warning_errno(UNIT(s), r, "Failed to watch sockets: %m");
2207 goto fail;
2208 }
2209
2210 socket_set_state(s, SOCKET_LISTENING);
2211 return;
2212
2213 fail:
2214 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2215 }
2216
2217 static void socket_enter_start_post(Socket *s) {
2218 int r;
2219 assert(s);
2220
2221 socket_unwatch_control_pid(s);
2222 s->control_command_id = SOCKET_EXEC_START_POST;
2223 s->control_command = s->exec_command[SOCKET_EXEC_START_POST];
2224
2225 if (s->control_command) {
2226 r = socket_spawn(s, s->control_command, &s->control_pid);
2227 if (r < 0) {
2228 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
2229 goto fail;
2230 }
2231
2232 socket_set_state(s, SOCKET_START_POST);
2233 } else
2234 socket_enter_listening(s);
2235
2236 return;
2237
2238 fail:
2239 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2240 }
2241
2242 static void socket_enter_start_chown(Socket *s) {
2243 int r;
2244
2245 assert(s);
2246
2247 r = socket_open_fds(s);
2248 if (r < 0) {
2249 log_unit_warning_errno(UNIT(s), r, "Failed to listen on sockets: %m");
2250 goto fail;
2251 }
2252
2253 if (!isempty(s->user) || !isempty(s->group)) {
2254
2255 socket_unwatch_control_pid(s);
2256 s->control_command_id = SOCKET_EXEC_START_CHOWN;
2257 s->control_command = NULL;
2258
2259 r = socket_chown(s, &s->control_pid);
2260 if (r < 0) {
2261 log_unit_warning_errno(UNIT(s), r, "Failed to fork 'start-chown' task: %m");
2262 goto fail;
2263 }
2264
2265 socket_set_state(s, SOCKET_START_CHOWN);
2266 } else
2267 socket_enter_start_post(s);
2268
2269 return;
2270
2271 fail:
2272 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2273 }
2274
2275 static void socket_enter_start_pre(Socket *s) {
2276 int r;
2277 assert(s);
2278
2279 socket_unwatch_control_pid(s);
2280
2281 unit_warn_leftover_processes(UNIT(s), unit_log_leftover_process_start);
2282
2283 s->control_command_id = SOCKET_EXEC_START_PRE;
2284 s->control_command = s->exec_command[SOCKET_EXEC_START_PRE];
2285
2286 if (s->control_command) {
2287 r = socket_spawn(s, s->control_command, &s->control_pid);
2288 if (r < 0) {
2289 log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
2290 goto fail;
2291 }
2292
2293 socket_set_state(s, SOCKET_START_PRE);
2294 } else
2295 socket_enter_start_chown(s);
2296
2297 return;
2298
2299 fail:
2300 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
2301 }
2302
2303 static void flush_ports(Socket *s) {
2304 SocketPort *p;
2305
2306 /* Flush all incoming traffic, regardless if actual bytes or new connections, so that this socket isn't busy
2307 * anymore */
2308
2309 LIST_FOREACH(port, p, s->ports) {
2310 if (p->fd < 0)
2311 continue;
2312
2313 (void) flush_accept(p->fd);
2314 (void) flush_fd(p->fd);
2315 }
2316 }
2317
2318 static void socket_enter_running(Socket *s, int cfd) {
2319 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2320 int r;
2321
2322 /* Note that this call takes possession of the connection fd passed. It either has to assign it somewhere or
2323 * close it. */
2324
2325 assert(s);
2326
2327 /* We don't take connections anymore if we are supposed to shut down anyway */
2328 if (unit_stop_pending(UNIT(s))) {
2329
2330 log_unit_debug(UNIT(s), "Suppressing connection request since unit stop is scheduled.");
2331
2332 if (cfd >= 0)
2333 goto refuse;
2334 else
2335 flush_ports(s);
2336
2337 return;
2338 }
2339
2340 if (!ratelimit_below(&s->trigger_limit)) {
2341 log_unit_warning(UNIT(s), "Trigger limit hit, refusing further activation.");
2342 socket_enter_stop_pre(s, SOCKET_FAILURE_TRIGGER_LIMIT_HIT);
2343 goto refuse;
2344 }
2345
2346 if (cfd < 0) {
2347 bool pending = false;
2348 Unit *other;
2349 Iterator i;
2350 void *v;
2351
2352 /* If there's already a start pending don't bother to
2353 * do anything */
2354 HASHMAP_FOREACH_KEY(v, other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
2355 if (unit_active_or_pending(other)) {
2356 pending = true;
2357 break;
2358 }
2359
2360 if (!pending) {
2361 if (!UNIT_ISSET(s->service)) {
2362 log_unit_error(UNIT(s), "Service to activate vanished, refusing activation.");
2363 r = -ENOENT;
2364 goto fail;
2365 }
2366
2367 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, NULL, &error, NULL);
2368 if (r < 0)
2369 goto fail;
2370 }
2371
2372 socket_set_state(s, SOCKET_RUNNING);
2373 } else {
2374 _cleanup_(socket_peer_unrefp) SocketPeer *p = NULL;
2375 Service *service;
2376
2377 if (s->n_connections >= s->max_connections) {
2378 log_unit_warning(UNIT(s), "Too many incoming connections (%u), dropping connection.",
2379 s->n_connections);
2380 goto refuse;
2381 }
2382
2383 if (s->max_connections_per_source > 0) {
2384 r = socket_acquire_peer(s, cfd, &p);
2385 if (r < 0)
2386 goto refuse;
2387 if (r > 0 && p->n_ref > s->max_connections_per_source) {
2388 _cleanup_free_ char *t = NULL;
2389
2390 (void) sockaddr_pretty(&p->peer.sa, p->peer_salen, true, false, &t);
2391
2392 log_unit_warning(UNIT(s),
2393 "Too many incoming connections (%u) from source %s, dropping connection.",
2394 p->n_ref, strnull(t));
2395 goto refuse;
2396 }
2397 }
2398
2399 r = socket_instantiate_service(s, cfd);
2400 if (r < 0)
2401 goto fail;
2402
2403 service = SERVICE(UNIT_DEREF(s->service));
2404 unit_ref_unset(&s->service);
2405
2406 s->n_accepted++;
2407
2408 r = service_set_socket_fd(service, cfd, s, s->selinux_context_from_net);
2409 if (r < 0)
2410 goto fail;
2411
2412 TAKE_FD(cfd); /* We passed ownership of the fd to the service now. Forget it here. */
2413 s->n_connections++;
2414
2415 service->peer = TAKE_PTR(p); /* Pass ownership of the peer reference */
2416
2417 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, NULL, &error, NULL);
2418 if (r < 0) {
2419 /* We failed to activate the new service, but it still exists. Let's make sure the
2420 * service closes and forgets the connection fd again, immediately. */
2421 service_close_socket_fd(service);
2422 goto fail;
2423 }
2424
2425 /* Notify clients about changed counters */
2426 unit_add_to_dbus_queue(UNIT(s));
2427 }
2428
2429 return;
2430
2431 refuse:
2432 s->n_refused++;
2433 safe_close(cfd);
2434 return;
2435
2436 fail:
2437 log_unit_warning(UNIT(s), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
2438 cfd >= 0 ? "template" : "non-template",
2439 bus_error_message(&error, r));
2440
2441 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2442 safe_close(cfd);
2443 }
2444
2445 static void socket_run_next(Socket *s) {
2446 int r;
2447
2448 assert(s);
2449 assert(s->control_command);
2450 assert(s->control_command->command_next);
2451
2452 socket_unwatch_control_pid(s);
2453
2454 s->control_command = s->control_command->command_next;
2455
2456 r = socket_spawn(s, s->control_command, &s->control_pid);
2457 if (r < 0)
2458 goto fail;
2459
2460 return;
2461
2462 fail:
2463 log_unit_warning_errno(UNIT(s), r, "Failed to run next task: %m");
2464
2465 if (s->state == SOCKET_START_POST)
2466 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2467 else if (s->state == SOCKET_STOP_POST)
2468 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
2469 else
2470 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
2471 }
2472
2473 static int socket_start(Unit *u) {
2474 Socket *s = SOCKET(u);
2475 int r;
2476
2477 assert(s);
2478
2479 /* We cannot fulfill this request right now, try again later
2480 * please! */
2481 if (IN_SET(s->state,
2482 SOCKET_STOP_PRE,
2483 SOCKET_STOP_PRE_SIGKILL,
2484 SOCKET_STOP_PRE_SIGTERM,
2485 SOCKET_STOP_POST,
2486 SOCKET_FINAL_SIGTERM,
2487 SOCKET_FINAL_SIGKILL,
2488 SOCKET_CLEANING))
2489 return -EAGAIN;
2490
2491 /* Already on it! */
2492 if (IN_SET(s->state,
2493 SOCKET_START_PRE,
2494 SOCKET_START_CHOWN,
2495 SOCKET_START_POST))
2496 return 0;
2497
2498 /* Cannot run this without the service being around */
2499 if (UNIT_ISSET(s->service)) {
2500 Service *service;
2501
2502 service = SERVICE(UNIT_DEREF(s->service));
2503
2504 if (UNIT(service)->load_state != UNIT_LOADED) {
2505 log_unit_error(u, "Socket service %s not loaded, refusing.", UNIT(service)->id);
2506 return -ENOENT;
2507 }
2508
2509 /* If the service is already active we cannot start the
2510 * socket */
2511 if (!IN_SET(service->state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
2512 log_unit_error(u, "Socket service %s already active, refusing.", UNIT(service)->id);
2513 return -EBUSY;
2514 }
2515 }
2516
2517 assert(IN_SET(s->state, SOCKET_DEAD, SOCKET_FAILED));
2518
2519 r = unit_test_start_limit(u);
2520 if (r < 0) {
2521 socket_enter_dead(s, SOCKET_FAILURE_START_LIMIT_HIT);
2522 return r;
2523 }
2524
2525 r = unit_acquire_invocation_id(u);
2526 if (r < 0)
2527 return r;
2528
2529 s->result = SOCKET_SUCCESS;
2530 exec_command_reset_status_list_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
2531
2532 u->reset_accounting = true;
2533
2534 socket_enter_start_pre(s);
2535 return 1;
2536 }
2537
2538 static int socket_stop(Unit *u) {
2539 Socket *s = SOCKET(u);
2540
2541 assert(s);
2542
2543 /* Already on it */
2544 if (IN_SET(s->state,
2545 SOCKET_STOP_PRE,
2546 SOCKET_STOP_PRE_SIGTERM,
2547 SOCKET_STOP_PRE_SIGKILL,
2548 SOCKET_STOP_POST,
2549 SOCKET_FINAL_SIGTERM,
2550 SOCKET_FINAL_SIGKILL))
2551 return 0;
2552
2553 /* If there's already something running we go directly into
2554 * kill mode. */
2555 if (IN_SET(s->state,
2556 SOCKET_START_PRE,
2557 SOCKET_START_CHOWN,
2558 SOCKET_START_POST)) {
2559 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
2560 return -EAGAIN;
2561 }
2562
2563 /* If we are currently cleaning, then abort it, brutally. */
2564 if (s->state == SOCKET_CLEANING) {
2565 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
2566 return 0;
2567 }
2568
2569 assert(IN_SET(s->state, SOCKET_LISTENING, SOCKET_RUNNING));
2570
2571 socket_enter_stop_pre(s, SOCKET_SUCCESS);
2572 return 1;
2573 }
2574
2575 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
2576 Socket *s = SOCKET(u);
2577 SocketPort *p;
2578 int r;
2579
2580 assert(u);
2581 assert(f);
2582 assert(fds);
2583
2584 (void) serialize_item(f, "state", socket_state_to_string(s->state));
2585 (void) serialize_item(f, "result", socket_result_to_string(s->result));
2586 (void) serialize_item_format(f, "n-accepted", "%u", s->n_accepted);
2587 (void) serialize_item_format(f, "n-refused", "%u", s->n_refused);
2588
2589 if (s->control_pid > 0)
2590 (void) serialize_item_format(f, "control-pid", PID_FMT, s->control_pid);
2591
2592 if (s->control_command_id >= 0)
2593 (void) serialize_item(f, "control-command", socket_exec_command_to_string(s->control_command_id));
2594
2595 LIST_FOREACH(port, p, s->ports) {
2596 int copy;
2597
2598 if (p->fd < 0)
2599 continue;
2600
2601 copy = fdset_put_dup(fds, p->fd);
2602 if (copy < 0)
2603 return log_unit_warning_errno(u, copy, "Failed to serialize socket fd: %m");
2604
2605 if (p->type == SOCKET_SOCKET) {
2606 _cleanup_free_ char *t = NULL;
2607
2608 r = socket_address_print(&p->address, &t);
2609 if (r < 0)
2610 return log_unit_error_errno(u, r, "Failed to format socket address: %m");
2611
2612 if (socket_address_family(&p->address) == AF_NETLINK)
2613 (void) serialize_item_format(f, "netlink", "%i %s", copy, t);
2614 else
2615 (void) serialize_item_format(f, "socket", "%i %i %s", copy, p->address.type, t);
2616 } else if (p->type == SOCKET_SPECIAL)
2617 (void) serialize_item_format(f, "special", "%i %s", copy, p->path);
2618 else if (p->type == SOCKET_MQUEUE)
2619 (void) serialize_item_format(f, "mqueue", "%i %s", copy, p->path);
2620 else if (p->type == SOCKET_USB_FUNCTION)
2621 (void) serialize_item_format(f, "ffs", "%i %s", copy, p->path);
2622 else {
2623 assert(p->type == SOCKET_FIFO);
2624 (void) serialize_item_format(f, "fifo", "%i %s", copy, p->path);
2625 }
2626 }
2627
2628 return 0;
2629 }
2630
2631 static void socket_port_take_fd(SocketPort *p, FDSet *fds, int fd) {
2632 assert(p);
2633
2634 safe_close(p->fd);
2635 p->fd = fdset_remove(fds, fd);
2636 }
2637
2638 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2639 Socket *s = SOCKET(u);
2640
2641 assert(u);
2642 assert(key);
2643 assert(value);
2644
2645 if (streq(key, "state")) {
2646 SocketState state;
2647
2648 state = socket_state_from_string(value);
2649 if (state < 0)
2650 log_unit_debug(u, "Failed to parse state value: %s", value);
2651 else
2652 s->deserialized_state = state;
2653 } else if (streq(key, "result")) {
2654 SocketResult f;
2655
2656 f = socket_result_from_string(value);
2657 if (f < 0)
2658 log_unit_debug(u, "Failed to parse result value: %s", value);
2659 else if (f != SOCKET_SUCCESS)
2660 s->result = f;
2661
2662 } else if (streq(key, "n-accepted")) {
2663 unsigned k;
2664
2665 if (safe_atou(value, &k) < 0)
2666 log_unit_debug(u, "Failed to parse n-accepted value: %s", value);
2667 else
2668 s->n_accepted += k;
2669 } else if (streq(key, "n-refused")) {
2670 unsigned k;
2671
2672 if (safe_atou(value, &k) < 0)
2673 log_unit_debug(u, "Failed to parse n-refused value: %s", value);
2674 else
2675 s->n_refused += k;
2676 } else if (streq(key, "control-pid")) {
2677 pid_t pid;
2678
2679 if (parse_pid(value, &pid) < 0)
2680 log_unit_debug(u, "Failed to parse control-pid value: %s", value);
2681 else
2682 s->control_pid = pid;
2683 } else if (streq(key, "control-command")) {
2684 SocketExecCommand id;
2685
2686 id = socket_exec_command_from_string(value);
2687 if (id < 0)
2688 log_unit_debug(u, "Failed to parse exec-command value: %s", value);
2689 else {
2690 s->control_command_id = id;
2691 s->control_command = s->exec_command[id];
2692 }
2693 } else if (streq(key, "fifo")) {
2694 int fd, skip = 0;
2695 SocketPort *p;
2696
2697 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2698 log_unit_debug(u, "Failed to parse fifo value: %s", value);
2699 else
2700 LIST_FOREACH(port, p, s->ports)
2701 if (p->type == SOCKET_FIFO &&
2702 path_equal_or_files_same(p->path, value+skip, 0)) {
2703 socket_port_take_fd(p, fds, fd);
2704 break;
2705 }
2706
2707 } else if (streq(key, "special")) {
2708 int fd, skip = 0;
2709 SocketPort *p;
2710
2711 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2712 log_unit_debug(u, "Failed to parse special value: %s", value);
2713 else
2714 LIST_FOREACH(port, p, s->ports)
2715 if (p->type == SOCKET_SPECIAL &&
2716 path_equal_or_files_same(p->path, value+skip, 0)) {
2717 socket_port_take_fd(p, fds, fd);
2718 break;
2719 }
2720
2721 } else if (streq(key, "mqueue")) {
2722 int fd, skip = 0;
2723 SocketPort *p;
2724
2725 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2726 log_unit_debug(u, "Failed to parse mqueue value: %s", value);
2727 else
2728 LIST_FOREACH(port, p, s->ports)
2729 if (p->type == SOCKET_MQUEUE &&
2730 streq(p->path, value+skip)) {
2731 socket_port_take_fd(p, fds, fd);
2732 break;
2733 }
2734
2735 } else if (streq(key, "socket")) {
2736 int fd, type, skip = 0;
2737 SocketPort *p;
2738
2739 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
2740 log_unit_debug(u, "Failed to parse socket value: %s", value);
2741 else
2742 LIST_FOREACH(port, p, s->ports)
2743 if (socket_address_is(&p->address, value+skip, type)) {
2744 socket_port_take_fd(p, fds, fd);
2745 break;
2746 }
2747
2748 } else if (streq(key, "netlink")) {
2749 int fd, skip = 0;
2750 SocketPort *p;
2751
2752 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2753 log_unit_debug(u, "Failed to parse socket value: %s", value);
2754 else
2755 LIST_FOREACH(port, p, s->ports)
2756 if (socket_address_is_netlink(&p->address, value+skip)) {
2757 socket_port_take_fd(p, fds, fd);
2758 break;
2759 }
2760
2761 } else if (streq(key, "ffs")) {
2762 int fd, skip = 0;
2763 SocketPort *p;
2764
2765 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2766 log_unit_debug(u, "Failed to parse ffs value: %s", value);
2767 else
2768 LIST_FOREACH(port, p, s->ports)
2769 if (p->type == SOCKET_USB_FUNCTION &&
2770 path_equal_or_files_same(p->path, value+skip, 0)) {
2771 socket_port_take_fd(p, fds, fd);
2772 break;
2773 }
2774
2775 } else
2776 log_unit_debug(UNIT(s), "Unknown serialization key: %s", key);
2777
2778 return 0;
2779 }
2780
2781 static void socket_distribute_fds(Unit *u, FDSet *fds) {
2782 Socket *s = SOCKET(u);
2783 SocketPort *p;
2784
2785 assert(u);
2786
2787 LIST_FOREACH(port, p, s->ports) {
2788 Iterator i;
2789 int fd;
2790
2791 if (p->type != SOCKET_SOCKET)
2792 continue;
2793
2794 if (p->fd >= 0)
2795 continue;
2796
2797 FDSET_FOREACH(fd, fds, i) {
2798 if (socket_address_matches_fd(&p->address, fd)) {
2799 p->fd = fdset_remove(fds, fd);
2800 s->deserialized_state = SOCKET_LISTENING;
2801 break;
2802 }
2803 }
2804 }
2805 }
2806
2807 _pure_ static UnitActiveState socket_active_state(Unit *u) {
2808 assert(u);
2809
2810 return state_translation_table[SOCKET(u)->state];
2811 }
2812
2813 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
2814 assert(u);
2815
2816 return socket_state_to_string(SOCKET(u)->state);
2817 }
2818
2819 const char* socket_port_type_to_string(SocketPort *p) {
2820
2821 assert(p);
2822
2823 switch (p->type) {
2824
2825 case SOCKET_SOCKET:
2826
2827 switch (p->address.type) {
2828
2829 case SOCK_STREAM:
2830 return "Stream";
2831
2832 case SOCK_DGRAM:
2833 return "Datagram";
2834
2835 case SOCK_SEQPACKET:
2836 return "SequentialPacket";
2837
2838 case SOCK_RAW:
2839 if (socket_address_family(&p->address) == AF_NETLINK)
2840 return "Netlink";
2841
2842 _fallthrough_;
2843 default:
2844 return NULL;
2845 }
2846
2847 case SOCKET_SPECIAL:
2848 return "Special";
2849
2850 case SOCKET_MQUEUE:
2851 return "MessageQueue";
2852
2853 case SOCKET_FIFO:
2854 return "FIFO";
2855
2856 case SOCKET_USB_FUNCTION:
2857 return "USBFunction";
2858
2859 default:
2860 return NULL;
2861 }
2862 }
2863
2864 SocketType socket_port_type_from_string(const char *s) {
2865 assert(s);
2866
2867 if (STR_IN_SET(s, "Stream", "Datagram", "SequentialPacket", "Netlink"))
2868 return SOCKET_SOCKET;
2869 else if (streq(s, "Special"))
2870 return SOCKET_SPECIAL;
2871 else if (streq(s, "MessageQueue"))
2872 return SOCKET_MQUEUE;
2873 else if (streq(s, "FIFO"))
2874 return SOCKET_FIFO;
2875 else if (streq(s, "USBFunction"))
2876 return SOCKET_USB_FUNCTION;
2877 else
2878 return _SOCKET_TYPE_INVALID;
2879 }
2880
2881 _pure_ static bool socket_may_gc(Unit *u) {
2882 Socket *s = SOCKET(u);
2883
2884 assert(u);
2885
2886 return s->n_connections == 0;
2887 }
2888
2889 static int socket_accept_do(Socket *s, int fd) {
2890 int cfd;
2891
2892 assert(s);
2893 assert(fd >= 0);
2894
2895 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
2896 if (cfd < 0)
2897 /* Convert transient network errors into clean and well-defined EAGAIN */
2898 return ERRNO_IS_ACCEPT_AGAIN(errno) ? -EAGAIN : -errno;
2899
2900 return cfd;
2901 }
2902
2903 static int socket_accept_in_cgroup(Socket *s, SocketPort *p, int fd) {
2904 _cleanup_close_pair_ int pair[2] = { -1, -1 };
2905 int cfd, r;
2906 pid_t pid;
2907
2908 assert(s);
2909 assert(p);
2910 assert(fd >= 0);
2911
2912 /* Similar to socket_address_listen_in_cgroup(), but for accept() rather than socket(): make sure that any
2913 * connection socket is also properly associated with the cgroup. */
2914
2915 if (!IN_SET(p->address.sockaddr.sa.sa_family, AF_INET, AF_INET6))
2916 goto shortcut;
2917
2918 r = bpf_firewall_supported();
2919 if (r < 0)
2920 return r;
2921 if (r == BPF_FIREWALL_UNSUPPORTED)
2922 goto shortcut;
2923
2924 if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
2925 return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
2926
2927 r = unit_fork_helper_process(UNIT(s), "(sd-accept)", &pid);
2928 if (r < 0)
2929 return log_unit_error_errno(UNIT(s), r, "Failed to fork off accept stub process: %m");
2930 if (r == 0) {
2931 /* Child */
2932
2933 pair[0] = safe_close(pair[0]);
2934
2935 cfd = socket_accept_do(s, fd);
2936 if (cfd == -EAGAIN) /* spurious accept() */
2937 _exit(EXIT_SUCCESS);
2938 if (cfd < 0) {
2939 log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
2940 _exit(EXIT_FAILURE);
2941 }
2942
2943 r = send_one_fd(pair[1], cfd, 0);
2944 if (r < 0) {
2945 log_unit_error_errno(UNIT(s), r, "Failed to send connection socket to parent: %m");
2946 _exit(EXIT_FAILURE);
2947 }
2948
2949 _exit(EXIT_SUCCESS);
2950 }
2951
2952 pair[1] = safe_close(pair[1]);
2953 cfd = receive_one_fd(pair[0], 0);
2954
2955 /* We synchronously wait for the helper, as it shouldn't be slow */
2956 r = wait_for_terminate_and_check("(sd-accept)", pid, WAIT_LOG_ABNORMAL);
2957 if (r < 0) {
2958 safe_close(cfd);
2959 return r;
2960 }
2961
2962 /* If we received no fd, we got EIO here. If this happens with a process exit code of EXIT_SUCCESS
2963 * this is a spurious accept(), let's convert that back to EAGAIN here. */
2964 if (cfd == -EIO)
2965 return -EAGAIN;
2966 if (cfd < 0)
2967 return log_unit_error_errno(UNIT(s), cfd, "Failed to receive connection socket: %m");
2968
2969 return cfd;
2970
2971 shortcut:
2972 cfd = socket_accept_do(s, fd);
2973 if (cfd == -EAGAIN) /* spurious accept(), skip it silently */
2974 return -EAGAIN;
2975 if (cfd < 0)
2976 return log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
2977
2978 return cfd;
2979 }
2980
2981 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2982 SocketPort *p = userdata;
2983 int cfd = -1;
2984
2985 assert(p);
2986 assert(fd >= 0);
2987
2988 if (p->socket->state != SOCKET_LISTENING)
2989 return 0;
2990
2991 log_unit_debug(UNIT(p->socket), "Incoming traffic");
2992
2993 if (revents != EPOLLIN) {
2994 if (revents & EPOLLHUP)
2995 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.");
2996 else
2997 log_unit_error(UNIT(p->socket), "Got unexpected poll event (0x%x) on socket.", revents);
2998 goto fail;
2999 }
3000
3001 if (p->socket->accept &&
3002 p->type == SOCKET_SOCKET &&
3003 socket_address_can_accept(&p->address)) {
3004
3005 cfd = socket_accept_in_cgroup(p->socket, p, fd);
3006 if (cfd == -EAGAIN) /* Spurious accept() */
3007 return 0;
3008 if (cfd < 0)
3009 goto fail;
3010
3011 socket_apply_socket_options(p->socket, cfd);
3012 }
3013
3014 socket_enter_running(p->socket, cfd);
3015 return 0;
3016
3017 fail:
3018 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
3019 return 0;
3020 }
3021
3022 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
3023 Socket *s = SOCKET(u);
3024 SocketResult f;
3025
3026 assert(s);
3027 assert(pid >= 0);
3028
3029 if (pid != s->control_pid)
3030 return;
3031
3032 s->control_pid = 0;
3033
3034 if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
3035 f = SOCKET_SUCCESS;
3036 else if (code == CLD_EXITED)
3037 f = SOCKET_FAILURE_EXIT_CODE;
3038 else if (code == CLD_KILLED)
3039 f = SOCKET_FAILURE_SIGNAL;
3040 else if (code == CLD_DUMPED)
3041 f = SOCKET_FAILURE_CORE_DUMP;
3042 else
3043 assert_not_reached("Unknown sigchld code");
3044
3045 if (s->control_command) {
3046 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
3047
3048 if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
3049 f = SOCKET_SUCCESS;
3050 }
3051
3052 unit_log_process_exit(
3053 u,
3054 "Control process",
3055 socket_exec_command_to_string(s->control_command_id),
3056 f == SOCKET_SUCCESS,
3057 code, status);
3058
3059 if (s->result == SOCKET_SUCCESS)
3060 s->result = f;
3061
3062 if (s->control_command &&
3063 s->control_command->command_next &&
3064 f == SOCKET_SUCCESS) {
3065
3066 log_unit_debug(u, "Running next command for state %s", socket_state_to_string(s->state));
3067 socket_run_next(s);
3068 } else {
3069 s->control_command = NULL;
3070 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
3071
3072 /* No further commands for this step, so let's figure
3073 * out what to do next */
3074
3075 log_unit_debug(u, "Got final SIGCHLD for state %s", socket_state_to_string(s->state));
3076
3077 switch (s->state) {
3078
3079 case SOCKET_START_PRE:
3080 if (f == SOCKET_SUCCESS)
3081 socket_enter_start_chown(s);
3082 else
3083 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
3084 break;
3085
3086 case SOCKET_START_CHOWN:
3087 if (f == SOCKET_SUCCESS)
3088 socket_enter_start_post(s);
3089 else
3090 socket_enter_stop_pre(s, f);
3091 break;
3092
3093 case SOCKET_START_POST:
3094 if (f == SOCKET_SUCCESS)
3095 socket_enter_listening(s);
3096 else
3097 socket_enter_stop_pre(s, f);
3098 break;
3099
3100 case SOCKET_STOP_PRE:
3101 case SOCKET_STOP_PRE_SIGTERM:
3102 case SOCKET_STOP_PRE_SIGKILL:
3103 socket_enter_stop_post(s, f);
3104 break;
3105
3106 case SOCKET_STOP_POST:
3107 case SOCKET_FINAL_SIGTERM:
3108 case SOCKET_FINAL_SIGKILL:
3109 socket_enter_dead(s, f);
3110 break;
3111
3112 case SOCKET_CLEANING:
3113
3114 if (s->clean_result == SOCKET_SUCCESS)
3115 s->clean_result = f;
3116
3117 socket_enter_dead(s, SOCKET_SUCCESS);
3118 break;
3119
3120 default:
3121 assert_not_reached("Uh, control process died at wrong time.");
3122 }
3123 }
3124
3125 /* Notify clients about changed exit status */
3126 unit_add_to_dbus_queue(u);
3127 }
3128
3129 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3130 Socket *s = SOCKET(userdata);
3131
3132 assert(s);
3133 assert(s->timer_event_source == source);
3134
3135 switch (s->state) {
3136
3137 case SOCKET_START_PRE:
3138 log_unit_warning(UNIT(s), "Starting timed out. Terminating.");
3139 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
3140 break;
3141
3142 case SOCKET_START_CHOWN:
3143 case SOCKET_START_POST:
3144 log_unit_warning(UNIT(s), "Starting timed out. Stopping.");
3145 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
3146 break;
3147
3148 case SOCKET_STOP_PRE:
3149 log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
3150 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
3151 break;
3152
3153 case SOCKET_STOP_PRE_SIGTERM:
3154 if (s->kill_context.send_sigkill) {
3155 log_unit_warning(UNIT(s), "Stopping timed out. Killing.");
3156 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
3157 } else {
3158 log_unit_warning(UNIT(s), "Stopping timed out. Skipping SIGKILL. Ignoring.");
3159 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
3160 }
3161 break;
3162
3163 case SOCKET_STOP_PRE_SIGKILL:
3164 log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
3165 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
3166 break;
3167
3168 case SOCKET_STOP_POST:
3169 log_unit_warning(UNIT(s), "Stopping timed out (2). Terminating.");
3170 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
3171 break;
3172
3173 case SOCKET_FINAL_SIGTERM:
3174 if (s->kill_context.send_sigkill) {
3175 log_unit_warning(UNIT(s), "Stopping timed out (2). Killing.");
3176 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
3177 } else {
3178 log_unit_warning(UNIT(s), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
3179 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
3180 }
3181 break;
3182
3183 case SOCKET_FINAL_SIGKILL:
3184 log_unit_warning(UNIT(s), "Still around after SIGKILL (2). Entering failed mode.");
3185 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
3186 break;
3187
3188 case SOCKET_CLEANING:
3189 log_unit_warning(UNIT(s), "Cleaning timed out. killing.");
3190
3191 if (s->clean_result == SOCKET_SUCCESS)
3192 s->clean_result = SOCKET_FAILURE_TIMEOUT;
3193
3194 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, 0);
3195 break;
3196
3197 default:
3198 assert_not_reached("Timeout at wrong time.");
3199 }
3200
3201 return 0;
3202 }
3203
3204 int socket_collect_fds(Socket *s, int **fds) {
3205 size_t k = 0, n = 0;
3206 SocketPort *p;
3207 int *rfds;
3208
3209 assert(s);
3210 assert(fds);
3211
3212 /* Called from the service code for requesting our fds */
3213
3214 LIST_FOREACH(port, p, s->ports) {
3215 if (p->fd >= 0)
3216 n++;
3217 n += p->n_auxiliary_fds;
3218 }
3219
3220 if (n <= 0) {
3221 *fds = NULL;
3222 return 0;
3223 }
3224
3225 rfds = new(int, n);
3226 if (!rfds)
3227 return -ENOMEM;
3228
3229 LIST_FOREACH(port, p, s->ports) {
3230 size_t i;
3231
3232 if (p->fd >= 0)
3233 rfds[k++] = p->fd;
3234 for (i = 0; i < p->n_auxiliary_fds; ++i)
3235 rfds[k++] = p->auxiliary_fds[i];
3236 }
3237
3238 assert(k == n);
3239
3240 *fds = rfds;
3241 return (int) n;
3242 }
3243
3244 static void socket_reset_failed(Unit *u) {
3245 Socket *s = SOCKET(u);
3246
3247 assert(s);
3248
3249 if (s->state == SOCKET_FAILED)
3250 socket_set_state(s, SOCKET_DEAD);
3251
3252 s->result = SOCKET_SUCCESS;
3253 s->clean_result = SOCKET_SUCCESS;
3254 }
3255
3256 void socket_connection_unref(Socket *s) {
3257 assert(s);
3258
3259 /* The service is dead. Yay!
3260 *
3261 * This is strictly for one-instance-per-connection
3262 * services. */
3263
3264 assert(s->n_connections > 0);
3265 s->n_connections--;
3266
3267 log_unit_debug(UNIT(s), "One connection closed, %u left.", s->n_connections);
3268 }
3269
3270 static void socket_trigger_notify(Unit *u, Unit *other) {
3271 Socket *s = SOCKET(u);
3272
3273 assert(u);
3274 assert(other);
3275
3276 /* Filter out invocations with bogus state */
3277 if (!IN_SET(other->load_state,
3278 UNIT_LOADED,
3279 UNIT_NOT_FOUND,
3280 UNIT_BAD_SETTING,
3281 UNIT_ERROR,
3282 UNIT_MASKED) || other->type != UNIT_SERVICE)
3283 return;
3284
3285 /* Don't propagate state changes from the service if we are already down */
3286 if (!IN_SET(s->state, SOCKET_RUNNING, SOCKET_LISTENING))
3287 return;
3288
3289 /* We don't care for the service state if we are in Accept=yes mode */
3290 if (s->accept)
3291 return;
3292
3293 /* Propagate start limit hit state */
3294 if (other->start_limit_hit) {
3295 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_START_LIMIT_HIT);
3296 return;
3297 }
3298
3299 /* Don't propagate anything if there's still a job queued */
3300 if (other->job)
3301 return;
3302
3303 if (IN_SET(SERVICE(other)->state,
3304 SERVICE_DEAD, SERVICE_FAILED,
3305 SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
3306 SERVICE_AUTO_RESTART))
3307 socket_enter_listening(s);
3308
3309 if (SERVICE(other)->state == SERVICE_RUNNING)
3310 socket_set_state(s, SOCKET_RUNNING);
3311 }
3312
3313 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3314 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
3315 }
3316
3317 static int socket_get_timeout(Unit *u, usec_t *timeout) {
3318 Socket *s = SOCKET(u);
3319 usec_t t;
3320 int r;
3321
3322 if (!s->timer_event_source)
3323 return 0;
3324
3325 r = sd_event_source_get_time(s->timer_event_source, &t);
3326 if (r < 0)
3327 return r;
3328 if (t == USEC_INFINITY)
3329 return 0;
3330
3331 *timeout = t;
3332 return 1;
3333 }
3334
3335 char *socket_fdname(Socket *s) {
3336 assert(s);
3337
3338 /* Returns the name to use for $LISTEN_NAMES. If the user
3339 * didn't specify anything specifically, use the socket unit's
3340 * name as fallback. */
3341
3342 return s->fdname ?: UNIT(s)->id;
3343 }
3344
3345 static int socket_control_pid(Unit *u) {
3346 Socket *s = SOCKET(u);
3347
3348 assert(s);
3349
3350 return s->control_pid;
3351 }
3352
3353 static int socket_clean(Unit *u, ExecCleanMask mask) {
3354 _cleanup_strv_free_ char **l = NULL;
3355 Socket *s = SOCKET(u);
3356 int r;
3357
3358 assert(s);
3359 assert(mask != 0);
3360
3361 if (s->state != SOCKET_DEAD)
3362 return -EBUSY;
3363
3364 r = exec_context_get_clean_directories(&s->exec_context, u->manager->prefix, mask, &l);
3365 if (r < 0)
3366 return r;
3367
3368 if (strv_isempty(l))
3369 return -EUNATCH;
3370
3371 socket_unwatch_control_pid(s);
3372 s->clean_result = SOCKET_SUCCESS;
3373 s->control_command = NULL;
3374 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
3375
3376 r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->exec_context.timeout_clean_usec));
3377 if (r < 0)
3378 goto fail;
3379
3380 r = unit_fork_and_watch_rm_rf(u, l, &s->control_pid);
3381 if (r < 0)
3382 goto fail;
3383
3384 socket_set_state(s, SOCKET_CLEANING);
3385
3386 return 0;
3387
3388 fail:
3389 log_unit_warning_errno(u, r, "Failed to initiate cleaning: %m");
3390 s->clean_result = SOCKET_FAILURE_RESOURCES;
3391 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
3392 return r;
3393 }
3394
3395 static int socket_can_clean(Unit *u, ExecCleanMask *ret) {
3396 Socket *s = SOCKET(u);
3397
3398 assert(s);
3399
3400 return exec_context_get_clean_mask(&s->exec_context, ret);
3401 }
3402
3403 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
3404 [SOCKET_EXEC_START_PRE] = "ExecStartPre",
3405 [SOCKET_EXEC_START_CHOWN] = "ExecStartChown",
3406 [SOCKET_EXEC_START_POST] = "ExecStartPost",
3407 [SOCKET_EXEC_STOP_PRE] = "ExecStopPre",
3408 [SOCKET_EXEC_STOP_POST] = "ExecStopPost"
3409 };
3410
3411 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
3412
3413 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
3414 [SOCKET_SUCCESS] = "success",
3415 [SOCKET_FAILURE_RESOURCES] = "resources",
3416 [SOCKET_FAILURE_TIMEOUT] = "timeout",
3417 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
3418 [SOCKET_FAILURE_SIGNAL] = "signal",
3419 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
3420 [SOCKET_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
3421 [SOCKET_FAILURE_TRIGGER_LIMIT_HIT] = "trigger-limit-hit",
3422 [SOCKET_FAILURE_SERVICE_START_LIMIT_HIT] = "service-start-limit-hit"
3423 };
3424
3425 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
3426
3427 const UnitVTable socket_vtable = {
3428 .object_size = sizeof(Socket),
3429 .exec_context_offset = offsetof(Socket, exec_context),
3430 .cgroup_context_offset = offsetof(Socket, cgroup_context),
3431 .kill_context_offset = offsetof(Socket, kill_context),
3432 .exec_runtime_offset = offsetof(Socket, exec_runtime),
3433 .dynamic_creds_offset = offsetof(Socket, dynamic_creds),
3434
3435 .sections =
3436 "Unit\0"
3437 "Socket\0"
3438 "Install\0",
3439 .private_section = "Socket",
3440
3441 .can_transient = true,
3442 .can_trigger = true,
3443 .can_fail = true,
3444
3445 .init = socket_init,
3446 .done = socket_done,
3447 .load = socket_load,
3448
3449 .coldplug = socket_coldplug,
3450
3451 .dump = socket_dump,
3452
3453 .start = socket_start,
3454 .stop = socket_stop,
3455
3456 .kill = socket_kill,
3457 .clean = socket_clean,
3458 .can_clean = socket_can_clean,
3459
3460 .get_timeout = socket_get_timeout,
3461
3462 .serialize = socket_serialize,
3463 .deserialize_item = socket_deserialize_item,
3464 .distribute_fds = socket_distribute_fds,
3465
3466 .active_state = socket_active_state,
3467 .sub_state_to_string = socket_sub_state_to_string,
3468
3469 .will_restart = unit_will_restart_default,
3470
3471 .may_gc = socket_may_gc,
3472
3473 .sigchld_event = socket_sigchld_event,
3474
3475 .trigger_notify = socket_trigger_notify,
3476
3477 .reset_failed = socket_reset_failed,
3478
3479 .control_pid = socket_control_pid,
3480
3481 .bus_set_property = bus_socket_set_property,
3482 .bus_commit_properties = bus_socket_commit_properties,
3483
3484 .status_message_formats = {
3485 /*.starting_stopping = {
3486 [0] = "Starting socket %s...",
3487 [1] = "Stopping socket %s...",
3488 },*/
3489 .finished_start_job = {
3490 [JOB_DONE] = "Listening on %s.",
3491 [JOB_FAILED] = "Failed to listen on %s.",
3492 [JOB_TIMEOUT] = "Timed out starting %s.",
3493 },
3494 .finished_stop_job = {
3495 [JOB_DONE] = "Closed %s.",
3496 [JOB_FAILED] = "Failed stopping %s.",
3497 [JOB_TIMEOUT] = "Timed out stopping %s.",
3498 },
3499 },
3500 };
Unnamed repository; edit this file 'description' to name the repository.