]> 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
sd-event: rework API to support CLOCK_REALTIME_ALARM and CLOCK_BOOTTIME_ALARM, too
[thirdparty/systemd.git] / src / core / socket.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <sys/epoll.h>
28 #include <signal.h>
29 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
31 #include <mqueue.h>
32 #ifdef HAVE_XATTR
33 #include <attr/xattr.h>
34 #endif
35
36 #include "sd-event.h"
37 #include "log.h"
38 #include "load-dropin.h"
39 #include "load-fragment.h"
40 #include "strv.h"
41 #include "mkdir.h"
42 #include "path-util.h"
43 #include "unit-name.h"
44 #include "unit-printf.h"
45 #include "missing.h"
46 #include "special.h"
47 #include "label.h"
48 #include "exit-status.h"
49 #include "def.h"
50 #include "smack-util.h"
51 #include "bus-util.h"
52 #include "bus-error.h"
53 #include "dbus-socket.h"
54 #include "unit.h"
55 #include "socket.h"
56
57 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
58 [SOCKET_DEAD] = UNIT_INACTIVE,
59 [SOCKET_START_PRE] = 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 };
71
72 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
73 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
74
75 static void socket_init(Unit *u) {
76 Socket *s = SOCKET(u);
77
78 assert(u);
79 assert(u->load_state == UNIT_STUB);
80
81 s->backlog = SOMAXCONN;
82 s->timeout_usec = u->manager->default_timeout_start_usec;
83 s->directory_mode = 0755;
84 s->socket_mode = 0666;
85
86 s->max_connections = 64;
87
88 s->priority = -1;
89 s->ip_tos = -1;
90 s->ip_ttl = -1;
91 s->mark = -1;
92
93 s->exec_context.std_output = u->manager->default_std_output;
94 s->exec_context.std_error = u->manager->default_std_error;
95
96 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
97 }
98
99 static void socket_unwatch_control_pid(Socket *s) {
100 assert(s);
101
102 if (s->control_pid <= 0)
103 return;
104
105 unit_unwatch_pid(UNIT(s), s->control_pid);
106 s->control_pid = 0;
107 }
108
109 void socket_free_ports(Socket *s) {
110 SocketPort *p;
111
112 assert(s);
113
114 while ((p = s->ports)) {
115 LIST_REMOVE(port, s->ports, p);
116
117 sd_event_source_unref(p->event_source);
118
119 safe_close(p->fd);
120 free(p->path);
121 free(p);
122 }
123 }
124
125 static void socket_done(Unit *u) {
126 Socket *s = SOCKET(u);
127
128 assert(s);
129
130 socket_free_ports(s);
131
132 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
133 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
134 s->control_command = NULL;
135
136 socket_unwatch_control_pid(s);
137
138 unit_ref_unset(&s->service);
139
140 free(s->tcp_congestion);
141 s->tcp_congestion = NULL;
142
143 free(s->bind_to_device);
144 s->bind_to_device = NULL;
145
146 free(s->smack);
147 free(s->smack_ip_in);
148 free(s->smack_ip_out);
149
150 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
151 }
152
153 static int socket_arm_timer(Socket *s) {
154 int r;
155
156 assert(s);
157
158 if (s->timeout_usec <= 0) {
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
160 return 0;
161 }
162
163 if (s->timer_event_source) {
164 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
165 if (r < 0)
166 return r;
167
168 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
169 }
170
171 return sd_event_add_time(
172 UNIT(s)->manager->event,
173 &s->timer_event_source,
174 CLOCK_MONOTONIC,
175 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
176 socket_dispatch_timer, s);
177 }
178
179 static int socket_instantiate_service(Socket *s) {
180 _cleanup_free_ char *prefix = NULL;
181 _cleanup_free_ char *name = NULL;
182 int r;
183 Unit *u;
184
185 assert(s);
186
187 /* This fills in s->service if it isn't filled in yet. For
188 * Accept=yes sockets we create the next connection service
189 * here. For Accept=no this is mostly a NOP since the service
190 * is figured out at load time anyway. */
191
192 if (UNIT_DEREF(s->service))
193 return 0;
194
195 assert(s->accept);
196
197 prefix = unit_name_to_prefix(UNIT(s)->id);
198 if (!prefix)
199 return -ENOMEM;
200
201 if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
202 return -ENOMEM;
203
204 r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
205 if (r < 0)
206 return r;
207
208 #ifdef HAVE_SYSV_COMPAT
209 if (SERVICE(u)->is_sysv) {
210 log_error("Using SysV services for socket activation is not supported. Refusing.");
211 return -ENOENT;
212 }
213 #endif
214
215 u->no_gc = true;
216 unit_ref_set(&s->service, u);
217
218 return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
219 }
220
221 static bool have_non_accept_socket(Socket *s) {
222 SocketPort *p;
223
224 assert(s);
225
226 if (!s->accept)
227 return true;
228
229 LIST_FOREACH(port, p, s->ports) {
230
231 if (p->type != SOCKET_SOCKET)
232 return true;
233
234 if (!socket_address_can_accept(&p->address))
235 return true;
236 }
237
238 return false;
239 }
240
241 static int socket_add_mount_links(Socket *s) {
242 SocketPort *p;
243 int r;
244
245 assert(s);
246
247 LIST_FOREACH(port, p, s->ports) {
248 const char *path = NULL;
249
250 if (p->type == SOCKET_SOCKET)
251 path = socket_address_get_path(&p->address);
252 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
253 path = p->path;
254
255 if (!path)
256 continue;
257
258 r = unit_require_mounts_for(UNIT(s), path);
259 if (r < 0)
260 return r;
261 }
262
263 return 0;
264 }
265
266 static int socket_add_device_link(Socket *s) {
267 char *t;
268
269 assert(s);
270
271 if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
272 return 0;
273
274 t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
275 return unit_add_node_link(UNIT(s), t, false);
276 }
277
278 static int socket_add_default_dependencies(Socket *s) {
279 int r;
280 assert(s);
281
282 r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
283 if (r < 0)
284 return r;
285
286 if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
287 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
288 if (r < 0)
289 return r;
290 }
291
292 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
293 }
294
295 _pure_ static bool socket_has_exec(Socket *s) {
296 unsigned i;
297 assert(s);
298
299 for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
300 if (s->exec_command[i])
301 return true;
302
303 return false;
304 }
305
306 static int socket_add_extras(Socket *s) {
307 Unit *u = UNIT(s);
308 int r;
309
310 assert(s);
311
312 if (have_non_accept_socket(s)) {
313
314 if (!UNIT_DEREF(s->service)) {
315 Unit *x;
316
317 r = unit_load_related_unit(u, ".service", &x);
318 if (r < 0)
319 return r;
320
321 unit_ref_set(&s->service, x);
322 }
323
324 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
325 if (r < 0)
326 return r;
327 }
328
329 r = socket_add_mount_links(s);
330 if (r < 0)
331 return r;
332
333 r = socket_add_device_link(s);
334 if (r < 0)
335 return r;
336
337 r = unit_patch_contexts(u);
338 if (r < 0)
339 return r;
340
341 if (socket_has_exec(s)) {
342 r = unit_add_exec_dependencies(u, &s->exec_context);
343 if (r < 0)
344 return r;
345
346 r = unit_add_default_slice(u, &s->cgroup_context);
347 if (r < 0)
348 return r;
349 }
350
351 if (u->default_dependencies) {
352 r = socket_add_default_dependencies(s);
353 if (r < 0)
354 return r;
355 }
356
357 return 0;
358 }
359
360 static int socket_verify(Socket *s) {
361 assert(s);
362
363 if (UNIT(s)->load_state != UNIT_LOADED)
364 return 0;
365
366 if (!s->ports) {
367 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
368 return -EINVAL;
369 }
370
371 if (s->accept && have_non_accept_socket(s)) {
372 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
373 UNIT(s)->id);
374 return -EINVAL;
375 }
376
377 if (s->accept && s->max_connections <= 0) {
378 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
379 return -EINVAL;
380 }
381
382 if (s->accept && UNIT_DEREF(s->service)) {
383 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
384 return -EINVAL;
385 }
386
387 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
388 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
389 return -EINVAL;
390 }
391
392 return 0;
393 }
394
395 static int socket_load(Unit *u) {
396 Socket *s = SOCKET(u);
397 int r;
398
399 assert(u);
400 assert(u->load_state == UNIT_STUB);
401
402 r = unit_load_fragment_and_dropin(u);
403 if (r < 0)
404 return r;
405
406 if (u->load_state == UNIT_LOADED) {
407 /* This is a new unit? Then let's add in some extras */
408 r = socket_add_extras(s);
409 if (r < 0)
410 return r;
411 }
412
413 return socket_verify(s);
414 }
415
416 _const_ static const char* listen_lookup(int family, int type) {
417
418 if (family == AF_NETLINK)
419 return "ListenNetlink";
420
421 if (type == SOCK_STREAM)
422 return "ListenStream";
423 else if (type == SOCK_DGRAM)
424 return "ListenDatagram";
425 else if (type == SOCK_SEQPACKET)
426 return "ListenSequentialPacket";
427
428 assert_not_reached("Unknown socket type");
429 return NULL;
430 }
431
432 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
433 SocketExecCommand c;
434 Socket *s = SOCKET(u);
435 SocketPort *p;
436 const char *prefix2;
437
438 assert(s);
439 assert(f);
440
441 prefix2 = strappenda(prefix, "\t");
442
443 fprintf(f,
444 "%sSocket State: %s\n"
445 "%sResult: %s\n"
446 "%sBindIPv6Only: %s\n"
447 "%sBacklog: %u\n"
448 "%sSocketMode: %04o\n"
449 "%sDirectoryMode: %04o\n"
450 "%sKeepAlive: %s\n"
451 "%sFreeBind: %s\n"
452 "%sTransparent: %s\n"
453 "%sBroadcast: %s\n"
454 "%sPassCredentials: %s\n"
455 "%sPassSecurity: %s\n"
456 "%sTCPCongestion: %s\n",
457 prefix, socket_state_to_string(s->state),
458 prefix, socket_result_to_string(s->result),
459 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
460 prefix, s->backlog,
461 prefix, s->socket_mode,
462 prefix, s->directory_mode,
463 prefix, yes_no(s->keep_alive),
464 prefix, yes_no(s->free_bind),
465 prefix, yes_no(s->transparent),
466 prefix, yes_no(s->broadcast),
467 prefix, yes_no(s->pass_cred),
468 prefix, yes_no(s->pass_sec),
469 prefix, strna(s->tcp_congestion));
470
471 if (s->control_pid > 0)
472 fprintf(f,
473 "%sControl PID: %lu\n",
474 prefix, (unsigned long) s->control_pid);
475
476 if (s->bind_to_device)
477 fprintf(f,
478 "%sBindToDevice: %s\n",
479 prefix, s->bind_to_device);
480
481 if (s->accept)
482 fprintf(f,
483 "%sAccepted: %u\n"
484 "%sNConnections: %u\n"
485 "%sMaxConnections: %u\n",
486 prefix, s->n_accepted,
487 prefix, s->n_connections,
488 prefix, s->max_connections);
489
490 if (s->priority >= 0)
491 fprintf(f,
492 "%sPriority: %i\n",
493 prefix, s->priority);
494
495 if (s->receive_buffer > 0)
496 fprintf(f,
497 "%sReceiveBuffer: %zu\n",
498 prefix, s->receive_buffer);
499
500 if (s->send_buffer > 0)
501 fprintf(f,
502 "%sSendBuffer: %zu\n",
503 prefix, s->send_buffer);
504
505 if (s->ip_tos >= 0)
506 fprintf(f,
507 "%sIPTOS: %i\n",
508 prefix, s->ip_tos);
509
510 if (s->ip_ttl >= 0)
511 fprintf(f,
512 "%sIPTTL: %i\n",
513 prefix, s->ip_ttl);
514
515 if (s->pipe_size > 0)
516 fprintf(f,
517 "%sPipeSize: %zu\n",
518 prefix, s->pipe_size);
519
520 if (s->mark >= 0)
521 fprintf(f,
522 "%sMark: %i\n",
523 prefix, s->mark);
524
525 if (s->mq_maxmsg > 0)
526 fprintf(f,
527 "%sMessageQueueMaxMessages: %li\n",
528 prefix, s->mq_maxmsg);
529
530 if (s->mq_msgsize > 0)
531 fprintf(f,
532 "%sMessageQueueMessageSize: %li\n",
533 prefix, s->mq_msgsize);
534
535 if (s->reuse_port)
536 fprintf(f,
537 "%sReusePort: %s\n",
538 prefix, yes_no(s->reuse_port));
539
540 if (s->smack)
541 fprintf(f,
542 "%sSmackLabel: %s\n",
543 prefix, s->smack);
544
545 if (s->smack_ip_in)
546 fprintf(f,
547 "%sSmackLabelIPIn: %s\n",
548 prefix, s->smack_ip_in);
549
550 if (s->smack_ip_out)
551 fprintf(f,
552 "%sSmackLabelIPOut: %s\n",
553 prefix, s->smack_ip_out);
554
555 LIST_FOREACH(port, p, s->ports) {
556
557 if (p->type == SOCKET_SOCKET) {
558 const char *t;
559 int r;
560 char *k = NULL;
561
562 if ((r = socket_address_print(&p->address, &k)) < 0)
563 t = strerror(-r);
564 else
565 t = k;
566
567 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
568 free(k);
569 } else if (p->type == SOCKET_SPECIAL)
570 fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
571 else if (p->type == SOCKET_MQUEUE)
572 fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
573 else
574 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
575 }
576
577 exec_context_dump(&s->exec_context, f, prefix);
578 kill_context_dump(&s->kill_context, f, prefix);
579
580 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
581 if (!s->exec_command[c])
582 continue;
583
584 fprintf(f, "%s-> %s:\n",
585 prefix, socket_exec_command_to_string(c));
586
587 exec_command_dump_list(s->exec_command[c], f, prefix2);
588 }
589 }
590
591 static int instance_from_socket(int fd, unsigned nr, char **instance) {
592 socklen_t l;
593 char *r;
594 union sockaddr_union local, remote;
595
596 assert(fd >= 0);
597 assert(instance);
598
599 l = sizeof(local);
600 if (getsockname(fd, &local.sa, &l) < 0)
601 return -errno;
602
603 l = sizeof(remote);
604 if (getpeername(fd, &remote.sa, &l) < 0)
605 return -errno;
606
607 switch (local.sa.sa_family) {
608
609 case AF_INET: {
610 uint32_t
611 a = ntohl(local.in.sin_addr.s_addr),
612 b = ntohl(remote.in.sin_addr.s_addr);
613
614 if (asprintf(&r,
615 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
616 nr,
617 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
618 ntohs(local.in.sin_port),
619 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
620 ntohs(remote.in.sin_port)) < 0)
621 return -ENOMEM;
622
623 break;
624 }
625
626 case AF_INET6: {
627 static const unsigned char ipv4_prefix[] = {
628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
629 };
630
631 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
632 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
633 const uint8_t
634 *a = local.in6.sin6_addr.s6_addr+12,
635 *b = remote.in6.sin6_addr.s6_addr+12;
636
637 if (asprintf(&r,
638 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
639 nr,
640 a[0], a[1], a[2], a[3],
641 ntohs(local.in6.sin6_port),
642 b[0], b[1], b[2], b[3],
643 ntohs(remote.in6.sin6_port)) < 0)
644 return -ENOMEM;
645 } else {
646 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
647
648 if (asprintf(&r,
649 "%u-%s:%u-%s:%u",
650 nr,
651 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
652 ntohs(local.in6.sin6_port),
653 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
654 ntohs(remote.in6.sin6_port)) < 0)
655 return -ENOMEM;
656 }
657
658 break;
659 }
660
661 case AF_UNIX: {
662 struct ucred ucred;
663 int k;
664
665 k = getpeercred(fd, &ucred);
666 if (k < 0)
667 return k;
668
669 if (asprintf(&r,
670 "%u-%lu-%lu",
671 nr,
672 (unsigned long) ucred.pid,
673 (unsigned long) ucred.uid) < 0)
674 return -ENOMEM;
675
676 break;
677 }
678
679 default:
680 assert_not_reached("Unhandled socket type.");
681 }
682
683 *instance = r;
684 return 0;
685 }
686
687 static void socket_close_fds(Socket *s) {
688 SocketPort *p;
689
690 assert(s);
691
692 LIST_FOREACH(port, p, s->ports) {
693
694 p->event_source = sd_event_source_unref(p->event_source);
695
696 if (p->fd < 0)
697 continue;
698
699 p->fd = safe_close(p->fd);
700
701 /* One little note: we should never delete any sockets
702 * in the file system here! After all some other
703 * process we spawned might still have a reference of
704 * this fd and wants to continue to use it. Therefore
705 * we delete sockets in the file system before we
706 * create a new one, not after we stopped using
707 * one! */
708 }
709 }
710
711 static void socket_apply_socket_options(Socket *s, int fd) {
712 assert(s);
713 assert(fd >= 0);
714
715 if (s->keep_alive) {
716 int b = s->keep_alive;
717 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
718 log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
719 }
720
721 if (s->broadcast) {
722 int one = 1;
723 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
724 log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
725 }
726
727 if (s->pass_cred) {
728 int one = 1;
729 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
730 log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
731 }
732
733 if (s->pass_sec) {
734 int one = 1;
735 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
736 log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
737 }
738
739 if (s->priority >= 0)
740 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
741 log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
742
743 if (s->receive_buffer > 0) {
744 int value = (int) s->receive_buffer;
745
746 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
747
748 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
749 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
750 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
751 }
752
753 if (s->send_buffer > 0) {
754 int value = (int) s->send_buffer;
755 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
756 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
757 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
758 }
759
760 if (s->mark >= 0)
761 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
762 log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
763
764 if (s->ip_tos >= 0)
765 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
766 log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
767
768 if (s->ip_ttl >= 0) {
769 int r, x;
770
771 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
772
773 if (socket_ipv6_is_supported())
774 x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
775 else {
776 x = -1;
777 errno = EAFNOSUPPORT;
778 }
779
780 if (r < 0 && x < 0)
781 log_warning_unit(UNIT(s)->id,
782 "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
783 }
784
785 if (s->tcp_congestion)
786 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
787 log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
788
789 if (s->reuse_port) {
790 int b = s->reuse_port;
791 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
792 log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
793 }
794
795 if (s->smack_ip_in)
796 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
797 log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
798
799 if (s->smack_ip_out)
800 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
801 log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
802 }
803
804 static void socket_apply_fifo_options(Socket *s, int fd) {
805 assert(s);
806 assert(fd >= 0);
807
808 if (s->pipe_size > 0)
809 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
810 log_warning_unit(UNIT(s)->id,
811 "F_SETPIPE_SZ: %m");
812
813 if (s->smack)
814 if (smack_label_fd(fd, s->smack) < 0)
815 log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
816 }
817
818 static int fifo_address_create(
819 const char *path,
820 mode_t directory_mode,
821 mode_t socket_mode,
822 int *_fd) {
823
824 int fd = -1, r = 0;
825 struct stat st;
826 mode_t old_mask;
827
828 assert(path);
829 assert(_fd);
830
831 mkdir_parents_label(path, directory_mode);
832
833 r = label_context_set(path, S_IFIFO);
834 if (r < 0)
835 goto fail;
836
837 /* Enforce the right access mode for the fifo */
838 old_mask = umask(~ socket_mode);
839
840 /* Include the original umask in our mask */
841 umask(~socket_mode | old_mask);
842
843 r = mkfifo(path, socket_mode);
844 umask(old_mask);
845
846 if (r < 0 && errno != EEXIST) {
847 r = -errno;
848 goto fail;
849 }
850
851 if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
852 r = -errno;
853 goto fail;
854 }
855
856 label_context_clear();
857
858 if (fstat(fd, &st) < 0) {
859 r = -errno;
860 goto fail;
861 }
862
863 if (!S_ISFIFO(st.st_mode) ||
864 (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
865 st.st_uid != getuid() ||
866 st.st_gid != getgid()) {
867
868 r = -EEXIST;
869 goto fail;
870 }
871
872 *_fd = fd;
873 return 0;
874
875 fail:
876 label_context_clear();
877 safe_close(fd);
878
879 return r;
880 }
881
882 static int special_address_create(
883 const char *path,
884 int *_fd) {
885
886 int fd = -1, r = 0;
887 struct stat st;
888
889 assert(path);
890 assert(_fd);
891
892 if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
893 r = -errno;
894 goto fail;
895 }
896
897 if (fstat(fd, &st) < 0) {
898 r = -errno;
899 goto fail;
900 }
901
902 /* Check whether this is a /proc, /sys or /dev file or char device */
903 if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
904 r = -EEXIST;
905 goto fail;
906 }
907
908 *_fd = fd;
909 return 0;
910
911 fail:
912 safe_close(fd);
913
914 return r;
915 }
916
917 static int mq_address_create(
918 const char *path,
919 mode_t mq_mode,
920 long maxmsg,
921 long msgsize,
922 int *_fd) {
923
924 int fd = -1, r = 0;
925 struct stat st;
926 mode_t old_mask;
927 struct mq_attr _attr, *attr = NULL;
928
929 assert(path);
930 assert(_fd);
931
932 if (maxmsg > 0 && msgsize > 0) {
933 zero(_attr);
934 _attr.mq_flags = O_NONBLOCK;
935 _attr.mq_maxmsg = maxmsg;
936 _attr.mq_msgsize = msgsize;
937 attr = &_attr;
938 }
939
940 /* Enforce the right access mode for the mq */
941 old_mask = umask(~ mq_mode);
942
943 /* Include the original umask in our mask */
944 umask(~mq_mode | old_mask);
945
946 fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
947 umask(old_mask);
948
949 if (fd < 0) {
950 r = -errno;
951 goto fail;
952 }
953
954 if (fstat(fd, &st) < 0) {
955 r = -errno;
956 goto fail;
957 }
958
959 if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
960 st.st_uid != getuid() ||
961 st.st_gid != getgid()) {
962
963 r = -EEXIST;
964 goto fail;
965 }
966
967 *_fd = fd;
968 return 0;
969
970 fail:
971 safe_close(fd);
972 return r;
973 }
974
975 static int socket_open_fds(Socket *s) {
976 SocketPort *p;
977 int r;
978 char *label = NULL;
979 bool know_label = false;
980
981 assert(s);
982
983 LIST_FOREACH(port, p, s->ports) {
984
985 if (p->fd >= 0)
986 continue;
987
988 if (p->type == SOCKET_SOCKET) {
989
990 if (!know_label) {
991
992 if ((r = socket_instantiate_service(s)) < 0)
993 return r;
994
995 if (UNIT_ISSET(s->service) &&
996 SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
997 r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
998
999 if (r < 0) {
1000 if (r != -EPERM)
1001 return r;
1002 }
1003 }
1004
1005 know_label = true;
1006 }
1007
1008 r = socket_address_listen(
1009 &p->address,
1010 SOCK_CLOEXEC|SOCK_NONBLOCK,
1011 s->backlog,
1012 s->bind_ipv6_only,
1013 s->bind_to_device,
1014 s->free_bind,
1015 s->transparent,
1016 s->directory_mode,
1017 s->socket_mode,
1018 label);
1019 if (r < 0)
1020 goto rollback;
1021
1022 p->fd = r;
1023 socket_apply_socket_options(s, p->fd);
1024
1025 } else if (p->type == SOCKET_SPECIAL) {
1026
1027 r = special_address_create(
1028 p->path,
1029 &p->fd);
1030 if (r < 0)
1031 goto rollback;
1032
1033 } else if (p->type == SOCKET_FIFO) {
1034
1035 r = fifo_address_create(
1036 p->path,
1037 s->directory_mode,
1038 s->socket_mode,
1039 &p->fd);
1040 if (r < 0)
1041 goto rollback;
1042
1043 socket_apply_fifo_options(s, p->fd);
1044 } else if (p->type == SOCKET_MQUEUE) {
1045
1046 r = mq_address_create(
1047 p->path,
1048 s->socket_mode,
1049 s->mq_maxmsg,
1050 s->mq_msgsize,
1051 &p->fd);
1052 if (r < 0)
1053 goto rollback;
1054 } else
1055 assert_not_reached("Unknown port type");
1056 }
1057
1058 label_free(label);
1059 return 0;
1060
1061 rollback:
1062 socket_close_fds(s);
1063 label_free(label);
1064 return r;
1065 }
1066
1067 static void socket_unwatch_fds(Socket *s) {
1068 SocketPort *p;
1069 int r;
1070
1071 assert(s);
1072
1073 LIST_FOREACH(port, p, s->ports) {
1074 if (p->fd < 0)
1075 continue;
1076
1077 if (p->event_source) {
1078 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1079 if (r < 0)
1080 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1081 }
1082 }
1083 }
1084
1085 static int socket_watch_fds(Socket *s) {
1086 SocketPort *p;
1087 int r;
1088
1089 assert(s);
1090
1091 LIST_FOREACH(port, p, s->ports) {
1092 if (p->fd < 0)
1093 continue;
1094
1095 if (p->event_source)
1096 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1097 else
1098 r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1099
1100 if (r < 0) {
1101 log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1102 goto fail;
1103 }
1104 }
1105
1106 return 0;
1107
1108 fail:
1109 socket_unwatch_fds(s);
1110 return r;
1111 }
1112
1113 static void socket_set_state(Socket *s, SocketState state) {
1114 SocketState old_state;
1115 assert(s);
1116
1117 old_state = s->state;
1118 s->state = state;
1119
1120 if (state != SOCKET_START_PRE &&
1121 state != SOCKET_START_POST &&
1122 state != SOCKET_STOP_PRE &&
1123 state != SOCKET_STOP_PRE_SIGTERM &&
1124 state != SOCKET_STOP_PRE_SIGKILL &&
1125 state != SOCKET_STOP_POST &&
1126 state != SOCKET_FINAL_SIGTERM &&
1127 state != SOCKET_FINAL_SIGKILL) {
1128
1129 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1130 socket_unwatch_control_pid(s);
1131 s->control_command = NULL;
1132 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1133 }
1134
1135 if (state != SOCKET_LISTENING)
1136 socket_unwatch_fds(s);
1137
1138 if (state != SOCKET_START_POST &&
1139 state != SOCKET_LISTENING &&
1140 state != SOCKET_RUNNING &&
1141 state != SOCKET_STOP_PRE &&
1142 state != SOCKET_STOP_PRE_SIGTERM &&
1143 state != SOCKET_STOP_PRE_SIGKILL)
1144 socket_close_fds(s);
1145
1146 if (state != old_state)
1147 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1148 UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1149
1150 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1151 }
1152
1153 static int socket_coldplug(Unit *u) {
1154 Socket *s = SOCKET(u);
1155 int r;
1156
1157 assert(s);
1158 assert(s->state == SOCKET_DEAD);
1159
1160 if (s->deserialized_state == s->state)
1161 return 0;
1162
1163 if (s->deserialized_state == SOCKET_START_PRE ||
1164 s->deserialized_state == SOCKET_START_POST ||
1165 s->deserialized_state == SOCKET_STOP_PRE ||
1166 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1167 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1168 s->deserialized_state == SOCKET_STOP_POST ||
1169 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1170 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1171
1172 if (s->control_pid <= 0)
1173 return -EBADMSG;
1174
1175 r = unit_watch_pid(UNIT(s), s->control_pid);
1176 if (r < 0)
1177 return r;
1178
1179 r = socket_arm_timer(s);
1180 if (r < 0)
1181 return r;
1182 }
1183
1184 if (s->deserialized_state == SOCKET_START_POST ||
1185 s->deserialized_state == SOCKET_LISTENING ||
1186 s->deserialized_state == SOCKET_RUNNING ||
1187 s->deserialized_state == SOCKET_STOP_PRE ||
1188 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1189 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1190 r = socket_open_fds(s);
1191 if (r < 0)
1192 return r;
1193 }
1194
1195 if (s->deserialized_state == SOCKET_LISTENING) {
1196 r = socket_watch_fds(s);
1197 if (r < 0)
1198 return r;
1199 }
1200
1201 socket_set_state(s, s->deserialized_state);
1202 return 0;
1203 }
1204
1205 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1206 pid_t pid;
1207 int r;
1208 char **argv;
1209
1210 assert(s);
1211 assert(c);
1212 assert(_pid);
1213
1214 unit_realize_cgroup(UNIT(s));
1215
1216 r = unit_setup_exec_runtime(UNIT(s));
1217 if (r < 0)
1218 goto fail;
1219
1220 r = socket_arm_timer(s);
1221 if (r < 0)
1222 goto fail;
1223
1224 r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1225 if (r < 0)
1226 goto fail;
1227
1228 r = exec_spawn(c,
1229 argv,
1230 &s->exec_context,
1231 NULL, 0,
1232 UNIT(s)->manager->environment,
1233 true,
1234 true,
1235 true,
1236 UNIT(s)->manager->confirm_spawn,
1237 UNIT(s)->manager->cgroup_supported,
1238 UNIT(s)->cgroup_path,
1239 manager_get_runtime_prefix(UNIT(s)->manager),
1240 UNIT(s)->id,
1241 0,
1242 NULL,
1243 s->exec_runtime,
1244 &pid);
1245
1246 strv_free(argv);
1247 if (r < 0)
1248 goto fail;
1249
1250 r = unit_watch_pid(UNIT(s), pid);
1251 if (r < 0)
1252 /* FIXME: we need to do something here */
1253 goto fail;
1254
1255 *_pid = pid;
1256
1257 return 0;
1258
1259 fail:
1260 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1261
1262 return r;
1263 }
1264
1265 static void socket_enter_dead(Socket *s, SocketResult f) {
1266 assert(s);
1267
1268 if (f != SOCKET_SUCCESS)
1269 s->result = f;
1270
1271 exec_runtime_destroy(s->exec_runtime);
1272 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1273
1274 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1275
1276 socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1277 }
1278
1279 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1280
1281 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1282 int r;
1283 assert(s);
1284
1285 if (f != SOCKET_SUCCESS)
1286 s->result = f;
1287
1288 socket_unwatch_control_pid(s);
1289
1290 s->control_command_id = SOCKET_EXEC_STOP_POST;
1291
1292 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1293 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1294 goto fail;
1295
1296 socket_set_state(s, SOCKET_STOP_POST);
1297 } else
1298 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1299
1300 return;
1301
1302 fail:
1303 log_warning_unit(UNIT(s)->id,
1304 "%s failed to run 'stop-post' task: %s",
1305 UNIT(s)->id, strerror(-r));
1306 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1307 }
1308
1309 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1310 int r;
1311
1312 assert(s);
1313
1314 if (f != SOCKET_SUCCESS)
1315 s->result = f;
1316
1317 r = unit_kill_context(
1318 UNIT(s),
1319 &s->kill_context,
1320 state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1321 -1,
1322 s->control_pid,
1323 false);
1324 if (r < 0)
1325 goto fail;
1326
1327 if (r > 0) {
1328 r = socket_arm_timer(s);
1329 if (r < 0)
1330 goto fail;
1331
1332 socket_set_state(s, state);
1333 } else if (state == SOCKET_STOP_PRE_SIGTERM)
1334 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1335 else if (state == SOCKET_STOP_PRE_SIGKILL)
1336 socket_enter_stop_post(s, SOCKET_SUCCESS);
1337 else if (state == SOCKET_FINAL_SIGTERM)
1338 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1339 else
1340 socket_enter_dead(s, SOCKET_SUCCESS);
1341
1342 return;
1343
1344 fail:
1345 log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1346
1347 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1348 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1349 else
1350 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1351 }
1352
1353 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1354 int r;
1355 assert(s);
1356
1357 if (f != SOCKET_SUCCESS)
1358 s->result = f;
1359
1360 socket_unwatch_control_pid(s);
1361
1362 s->control_command_id = SOCKET_EXEC_STOP_PRE;
1363
1364 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1365 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1366 goto fail;
1367
1368 socket_set_state(s, SOCKET_STOP_PRE);
1369 } else
1370 socket_enter_stop_post(s, SOCKET_SUCCESS);
1371
1372 return;
1373
1374 fail:
1375 log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1376 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1377 }
1378
1379 static void socket_enter_listening(Socket *s) {
1380 int r;
1381 assert(s);
1382
1383 r = socket_watch_fds(s);
1384 if (r < 0) {
1385 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1386 goto fail;
1387 }
1388
1389 socket_set_state(s, SOCKET_LISTENING);
1390 return;
1391
1392 fail:
1393 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1394 }
1395
1396 static void socket_enter_start_post(Socket *s) {
1397 int r;
1398 assert(s);
1399
1400 r = socket_open_fds(s);
1401 if (r < 0) {
1402 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1403 goto fail;
1404 }
1405
1406 socket_unwatch_control_pid(s);
1407
1408 s->control_command_id = SOCKET_EXEC_START_POST;
1409
1410 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1411 r = socket_spawn(s, s->control_command, &s->control_pid);
1412 if (r < 0) {
1413 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1414 goto fail;
1415 }
1416
1417 socket_set_state(s, SOCKET_START_POST);
1418 } else
1419 socket_enter_listening(s);
1420
1421 return;
1422
1423 fail:
1424 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1425 }
1426
1427 static void socket_enter_start_pre(Socket *s) {
1428 int r;
1429 assert(s);
1430
1431 socket_unwatch_control_pid(s);
1432
1433 s->control_command_id = SOCKET_EXEC_START_PRE;
1434
1435 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1436 r = socket_spawn(s, s->control_command, &s->control_pid);
1437 if (r < 0)
1438 goto fail;
1439
1440 socket_set_state(s, SOCKET_START_PRE);
1441 } else
1442 socket_enter_start_post(s);
1443
1444 return;
1445
1446 fail:
1447 log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1448 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1449 }
1450
1451 static void socket_enter_running(Socket *s, int cfd) {
1452 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1453 int r;
1454
1455 assert(s);
1456
1457 /* We don't take connections anymore if we are supposed to
1458 * shut down anyway */
1459 if (unit_stop_pending(UNIT(s))) {
1460
1461 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1462
1463 if (cfd >= 0)
1464 safe_close(cfd);
1465 else {
1466 /* Flush all sockets by closing and reopening them */
1467 socket_close_fds(s);
1468
1469 r = socket_open_fds(s);
1470 if (r < 0) {
1471 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1472 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1473 return;
1474 }
1475
1476 r = socket_watch_fds(s);
1477 if (r < 0) {
1478 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1479 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1480 }
1481 }
1482
1483 return;
1484 }
1485
1486 if (cfd < 0) {
1487 Iterator i;
1488 Unit *other;
1489 bool pending = false;
1490
1491 /* If there's already a start pending don't bother to
1492 * do anything */
1493 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1494 if (unit_active_or_pending(other)) {
1495 pending = true;
1496 break;
1497 }
1498
1499 if (!pending) {
1500 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1501 if (r < 0)
1502 goto fail;
1503 }
1504
1505 socket_set_state(s, SOCKET_RUNNING);
1506 } else {
1507 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1508 Service *service;
1509
1510 if (s->n_connections >= s->max_connections) {
1511 log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1512 safe_close(cfd);
1513 return;
1514 }
1515
1516 r = socket_instantiate_service(s);
1517 if (r < 0)
1518 goto fail;
1519
1520 r = instance_from_socket(cfd, s->n_accepted, &instance);
1521 if (r < 0) {
1522 if (r != -ENOTCONN)
1523 goto fail;
1524
1525 /* ENOTCONN is legitimate if TCP RST was received.
1526 * This connection is over, but the socket unit lives on. */
1527 safe_close(cfd);
1528 return;
1529 }
1530
1531 prefix = unit_name_to_prefix(UNIT(s)->id);
1532 if (!prefix) {
1533 r = -ENOMEM;
1534 goto fail;
1535 }
1536
1537 name = unit_name_build(prefix, instance, ".service");
1538 if (!name) {
1539 r = -ENOMEM;
1540 goto fail;
1541 }
1542
1543 r = unit_add_name(UNIT_DEREF(s->service), name);
1544 if (r < 0)
1545 goto fail;
1546
1547 service = SERVICE(UNIT_DEREF(s->service));
1548 unit_ref_unset(&s->service);
1549 s->n_accepted ++;
1550
1551 UNIT(service)->no_gc = false;
1552
1553 unit_choose_id(UNIT(service), name);
1554
1555 r = service_set_socket_fd(service, cfd, s);
1556 if (r < 0)
1557 goto fail;
1558
1559 cfd = -1;
1560 s->n_connections ++;
1561
1562 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1563 if (r < 0)
1564 goto fail;
1565
1566 /* Notify clients about changed counters */
1567 unit_add_to_dbus_queue(UNIT(s));
1568 }
1569
1570 return;
1571
1572 fail:
1573 log_warning_unit(UNIT(s)->id, "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1574 UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1575 bus_error_message(&error, r));
1576
1577 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1578 safe_close(cfd);
1579 }
1580
1581 static void socket_run_next(Socket *s) {
1582 int r;
1583
1584 assert(s);
1585 assert(s->control_command);
1586 assert(s->control_command->command_next);
1587
1588 socket_unwatch_control_pid(s);
1589
1590 s->control_command = s->control_command->command_next;
1591
1592 r = socket_spawn(s, s->control_command, &s->control_pid);
1593 if (r < 0)
1594 goto fail;
1595
1596 return;
1597
1598 fail:
1599 log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1600
1601 if (s->state == SOCKET_START_POST)
1602 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1603 else if (s->state == SOCKET_STOP_POST)
1604 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1605 else
1606 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1607 }
1608
1609 static int socket_start(Unit *u) {
1610 Socket *s = SOCKET(u);
1611
1612 assert(s);
1613
1614 /* We cannot fulfill this request right now, try again later
1615 * please! */
1616 if (s->state == SOCKET_STOP_PRE ||
1617 s->state == SOCKET_STOP_PRE_SIGKILL ||
1618 s->state == SOCKET_STOP_PRE_SIGTERM ||
1619 s->state == SOCKET_STOP_POST ||
1620 s->state == SOCKET_FINAL_SIGTERM ||
1621 s->state == SOCKET_FINAL_SIGKILL)
1622 return -EAGAIN;
1623
1624 if (s->state == SOCKET_START_PRE ||
1625 s->state == SOCKET_START_POST)
1626 return 0;
1627
1628 /* Cannot run this without the service being around */
1629 if (UNIT_ISSET(s->service)) {
1630 Service *service;
1631
1632 service = SERVICE(UNIT_DEREF(s->service));
1633
1634 if (UNIT(service)->load_state != UNIT_LOADED) {
1635 log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1636 return -ENOENT;
1637 }
1638
1639 /* If the service is already active we cannot start the
1640 * socket */
1641 if (service->state != SERVICE_DEAD &&
1642 service->state != SERVICE_FAILED &&
1643 service->state != SERVICE_AUTO_RESTART) {
1644 log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1645 return -EBUSY;
1646 }
1647
1648 #ifdef HAVE_SYSV_COMPAT
1649 if (service->is_sysv) {
1650 log_error_unit(u->id,
1651 "Using SysV services for socket activation is not supported. Refusing.");
1652 return -ENOENT;
1653 }
1654 #endif
1655 }
1656
1657 assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1658
1659 s->result = SOCKET_SUCCESS;
1660 socket_enter_start_pre(s);
1661
1662 return 0;
1663 }
1664
1665 static int socket_stop(Unit *u) {
1666 Socket *s = SOCKET(u);
1667
1668 assert(s);
1669
1670 /* Already on it */
1671 if (s->state == SOCKET_STOP_PRE ||
1672 s->state == SOCKET_STOP_PRE_SIGTERM ||
1673 s->state == SOCKET_STOP_PRE_SIGKILL ||
1674 s->state == SOCKET_STOP_POST ||
1675 s->state == SOCKET_FINAL_SIGTERM ||
1676 s->state == SOCKET_FINAL_SIGKILL)
1677 return 0;
1678
1679 /* If there's already something running we go directly into
1680 * kill mode. */
1681 if (s->state == SOCKET_START_PRE ||
1682 s->state == SOCKET_START_POST) {
1683 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1684 return -EAGAIN;
1685 }
1686
1687 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1688
1689 socket_enter_stop_pre(s, SOCKET_SUCCESS);
1690 return 0;
1691 }
1692
1693 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1694 Socket *s = SOCKET(u);
1695 SocketPort *p;
1696 int r;
1697
1698 assert(u);
1699 assert(f);
1700 assert(fds);
1701
1702 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1703 unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1704 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1705
1706 if (s->control_pid > 0)
1707 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1708
1709 if (s->control_command_id >= 0)
1710 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1711
1712 LIST_FOREACH(port, p, s->ports) {
1713 int copy;
1714
1715 if (p->fd < 0)
1716 continue;
1717
1718 copy = fdset_put_dup(fds, p->fd);
1719 if (copy < 0)
1720 return copy;
1721
1722 if (p->type == SOCKET_SOCKET) {
1723 _cleanup_free_ char *t = NULL;
1724
1725 r = socket_address_print(&p->address, &t);
1726 if (r < 0)
1727 return r;
1728
1729 if (socket_address_family(&p->address) == AF_NETLINK)
1730 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1731 else
1732 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1733
1734 } else if (p->type == SOCKET_SPECIAL)
1735 unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1736 else if (p->type == SOCKET_MQUEUE)
1737 unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1738 else {
1739 assert(p->type == SOCKET_FIFO);
1740 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1741 }
1742 }
1743
1744 return 0;
1745 }
1746
1747 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1748 Socket *s = SOCKET(u);
1749
1750 assert(u);
1751 assert(key);
1752 assert(value);
1753
1754 if (streq(key, "state")) {
1755 SocketState state;
1756
1757 state = socket_state_from_string(value);
1758 if (state < 0)
1759 log_debug_unit(u->id, "Failed to parse state value %s", value);
1760 else
1761 s->deserialized_state = state;
1762 } else if (streq(key, "result")) {
1763 SocketResult f;
1764
1765 f = socket_result_from_string(value);
1766 if (f < 0)
1767 log_debug_unit(u->id, "Failed to parse result value %s", value);
1768 else if (f != SOCKET_SUCCESS)
1769 s->result = f;
1770
1771 } else if (streq(key, "n-accepted")) {
1772 unsigned k;
1773
1774 if (safe_atou(value, &k) < 0)
1775 log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1776 else
1777 s->n_accepted += k;
1778 } else if (streq(key, "control-pid")) {
1779 pid_t pid;
1780
1781 if (parse_pid(value, &pid) < 0)
1782 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1783 else
1784 s->control_pid = pid;
1785 } else if (streq(key, "control-command")) {
1786 SocketExecCommand id;
1787
1788 id = socket_exec_command_from_string(value);
1789 if (id < 0)
1790 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1791 else {
1792 s->control_command_id = id;
1793 s->control_command = s->exec_command[id];
1794 }
1795 } else if (streq(key, "fifo")) {
1796 int fd, skip = 0;
1797 SocketPort *p;
1798
1799 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1800 log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1801 else {
1802
1803 LIST_FOREACH(port, p, s->ports)
1804 if (p->type == SOCKET_FIFO &&
1805 streq_ptr(p->path, value+skip))
1806 break;
1807
1808 if (p) {
1809 safe_close(p->fd);
1810 p->fd = fdset_remove(fds, fd);
1811 }
1812 }
1813
1814 } else if (streq(key, "special")) {
1815 int fd, skip = 0;
1816 SocketPort *p;
1817
1818 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1819 log_debug_unit(u->id, "Failed to parse special value %s", value);
1820 else {
1821
1822 LIST_FOREACH(port, p, s->ports)
1823 if (p->type == SOCKET_SPECIAL &&
1824 streq_ptr(p->path, value+skip))
1825 break;
1826
1827 if (p) {
1828 safe_close(p->fd);
1829 p->fd = fdset_remove(fds, fd);
1830 }
1831 }
1832
1833 } else if (streq(key, "mqueue")) {
1834 int fd, skip = 0;
1835 SocketPort *p;
1836
1837 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1838 log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
1839 else {
1840
1841 LIST_FOREACH(port, p, s->ports)
1842 if (p->type == SOCKET_MQUEUE &&
1843 streq_ptr(p->path, value+skip))
1844 break;
1845
1846 if (p) {
1847 safe_close(p->fd);
1848 p->fd = fdset_remove(fds, fd);
1849 }
1850 }
1851
1852 } else if (streq(key, "socket")) {
1853 int fd, type, skip = 0;
1854 SocketPort *p;
1855
1856 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1857 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1858 else {
1859
1860 LIST_FOREACH(port, p, s->ports)
1861 if (socket_address_is(&p->address, value+skip, type))
1862 break;
1863
1864 if (p) {
1865 safe_close(p->fd);
1866 p->fd = fdset_remove(fds, fd);
1867 }
1868 }
1869
1870 } else if (streq(key, "netlink")) {
1871 int fd, skip = 0;
1872 SocketPort *p;
1873
1874 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1875 log_debug_unit(u->id, "Failed to parse socket value %s", value);
1876 else {
1877
1878 LIST_FOREACH(port, p, s->ports)
1879 if (socket_address_is_netlink(&p->address, value+skip))
1880 break;
1881
1882 if (p) {
1883 safe_close(p->fd);
1884 p->fd = fdset_remove(fds, fd);
1885 }
1886 }
1887 } else
1888 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1889
1890 return 0;
1891 }
1892
1893 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1894 Socket *s = SOCKET(u);
1895 SocketPort *p;
1896
1897 assert(u);
1898
1899 LIST_FOREACH(port, p, s->ports) {
1900 Iterator i;
1901 int fd;
1902
1903 if (p->type != SOCKET_SOCKET)
1904 continue;
1905
1906 if (p->fd >= 0)
1907 continue;
1908
1909 FDSET_FOREACH(fd, fds, i) {
1910 if (socket_address_matches_fd(&p->address, fd)) {
1911 p->fd = fdset_remove(fds, fd);
1912 s->deserialized_state = SOCKET_LISTENING;
1913 break;
1914 }
1915 }
1916 }
1917
1918 return 0;
1919 }
1920
1921 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1922 assert(u);
1923
1924 return state_translation_table[SOCKET(u)->state];
1925 }
1926
1927 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1928 assert(u);
1929
1930 return socket_state_to_string(SOCKET(u)->state);
1931 }
1932
1933 const char* socket_port_type_to_string(SocketPort *p) {
1934
1935 assert(p);
1936
1937 switch (p->type) {
1938
1939 case SOCKET_SOCKET:
1940
1941 switch (p->address.type) {
1942
1943 case SOCK_STREAM:
1944 return "Stream";
1945
1946 case SOCK_DGRAM:
1947 return "Datagram";
1948
1949 case SOCK_SEQPACKET:
1950 return "SequentialPacket";
1951
1952 case SOCK_RAW:
1953 if (socket_address_family(&p->address) == AF_NETLINK)
1954 return "Netlink";
1955
1956 default:
1957 return NULL;
1958 }
1959
1960 case SOCKET_SPECIAL:
1961 return "Special";
1962
1963 case SOCKET_MQUEUE:
1964 return "MessageQueue";
1965
1966 case SOCKET_FIFO:
1967 return "FIFO";
1968
1969 default:
1970 return NULL;
1971 }
1972 }
1973
1974 _pure_ static bool socket_check_gc(Unit *u) {
1975 Socket *s = SOCKET(u);
1976
1977 assert(u);
1978
1979 return s->n_connections > 0;
1980 }
1981
1982 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1983 SocketPort *p = userdata;
1984 int cfd = -1;
1985
1986 assert(p);
1987 assert(fd >= 0);
1988
1989 if (p->socket->state != SOCKET_LISTENING)
1990 return 0;
1991
1992 log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
1993
1994 if (revents != EPOLLIN) {
1995
1996 if (revents & EPOLLHUP)
1997 log_error_unit(UNIT(p->socket)->id, "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
1998 UNIT(p->socket)->id);
1999 else
2000 log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2001 UNIT(p->socket)->id, revents);
2002
2003 goto fail;
2004 }
2005
2006 if (p->socket->accept &&
2007 p->type == SOCKET_SOCKET &&
2008 socket_address_can_accept(&p->address)) {
2009
2010 for (;;) {
2011
2012 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2013 if (cfd < 0) {
2014
2015 if (errno == EINTR)
2016 continue;
2017
2018 log_error_unit(UNIT(p->socket)->id,
2019 "Failed to accept socket: %m");
2020 goto fail;
2021 }
2022
2023 break;
2024 }
2025
2026 socket_apply_socket_options(p->socket, cfd);
2027 }
2028
2029 socket_enter_running(p->socket, cfd);
2030 return 0;
2031
2032 fail:
2033 socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2034 return 0;
2035 }
2036
2037 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2038 Socket *s = SOCKET(u);
2039 SocketResult f;
2040
2041 assert(s);
2042 assert(pid >= 0);
2043
2044 if (pid != s->control_pid)
2045 return;
2046
2047 s->control_pid = 0;
2048
2049 if (is_clean_exit(code, status, NULL))
2050 f = SOCKET_SUCCESS;
2051 else if (code == CLD_EXITED)
2052 f = SOCKET_FAILURE_EXIT_CODE;
2053 else if (code == CLD_KILLED)
2054 f = SOCKET_FAILURE_SIGNAL;
2055 else if (code == CLD_DUMPED)
2056 f = SOCKET_FAILURE_CORE_DUMP;
2057 else
2058 assert_not_reached("Unknown code");
2059
2060 if (s->control_command) {
2061 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2062
2063 if (s->control_command->ignore)
2064 f = SOCKET_SUCCESS;
2065 }
2066
2067 log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2068 u->id,
2069 "%s control process exited, code=%s status=%i",
2070 u->id, sigchld_code_to_string(code), status);
2071
2072 if (f != SOCKET_SUCCESS)
2073 s->result = f;
2074
2075 if (s->control_command &&
2076 s->control_command->command_next &&
2077 f == SOCKET_SUCCESS) {
2078
2079 log_debug_unit(u->id,
2080 "%s running next command for state %s",
2081 u->id, socket_state_to_string(s->state));
2082 socket_run_next(s);
2083 } else {
2084 s->control_command = NULL;
2085 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2086
2087 /* No further commands for this step, so let's figure
2088 * out what to do next */
2089
2090 log_debug_unit(u->id,
2091 "%s got final SIGCHLD for state %s",
2092 u->id, socket_state_to_string(s->state));
2093
2094 switch (s->state) {
2095
2096 case SOCKET_START_PRE:
2097 if (f == SOCKET_SUCCESS)
2098 socket_enter_start_post(s);
2099 else
2100 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2101 break;
2102
2103 case SOCKET_START_POST:
2104 if (f == SOCKET_SUCCESS)
2105 socket_enter_listening(s);
2106 else
2107 socket_enter_stop_pre(s, f);
2108 break;
2109
2110 case SOCKET_STOP_PRE:
2111 case SOCKET_STOP_PRE_SIGTERM:
2112 case SOCKET_STOP_PRE_SIGKILL:
2113 socket_enter_stop_post(s, f);
2114 break;
2115
2116 case SOCKET_STOP_POST:
2117 case SOCKET_FINAL_SIGTERM:
2118 case SOCKET_FINAL_SIGKILL:
2119 socket_enter_dead(s, f);
2120 break;
2121
2122 default:
2123 assert_not_reached("Uh, control process died at wrong time.");
2124 }
2125 }
2126
2127 /* Notify clients about changed exit status */
2128 unit_add_to_dbus_queue(u);
2129 }
2130
2131 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2132 Socket *s = SOCKET(userdata);
2133
2134 assert(s);
2135 assert(s->timer_event_source == source);
2136
2137 switch (s->state) {
2138
2139 case SOCKET_START_PRE:
2140 log_warning_unit(UNIT(s)->id,
2141 "%s starting timed out. Terminating.", UNIT(s)->id);
2142 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2143 break;
2144
2145 case SOCKET_START_POST:
2146 log_warning_unit(UNIT(s)->id,
2147 "%s starting timed out. Stopping.", UNIT(s)->id);
2148 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2149 break;
2150
2151 case SOCKET_STOP_PRE:
2152 log_warning_unit(UNIT(s)->id,
2153 "%s stopping timed out. Terminating.", UNIT(s)->id);
2154 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2155 break;
2156
2157 case SOCKET_STOP_PRE_SIGTERM:
2158 if (s->kill_context.send_sigkill) {
2159 log_warning_unit(UNIT(s)->id,
2160 "%s stopping timed out. Killing.", UNIT(s)->id);
2161 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2162 } else {
2163 log_warning_unit(UNIT(s)->id,
2164 "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2165 UNIT(s)->id);
2166 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2167 }
2168 break;
2169
2170 case SOCKET_STOP_PRE_SIGKILL:
2171 log_warning_unit(UNIT(s)->id,
2172 "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2173 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2174 break;
2175
2176 case SOCKET_STOP_POST:
2177 log_warning_unit(UNIT(s)->id,
2178 "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2179 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2180 break;
2181
2182 case SOCKET_FINAL_SIGTERM:
2183 if (s->kill_context.send_sigkill) {
2184 log_warning_unit(UNIT(s)->id,
2185 "%s stopping timed out (2). Killing.", UNIT(s)->id);
2186 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2187 } else {
2188 log_warning_unit(UNIT(s)->id,
2189 "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2190 UNIT(s)->id);
2191 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2192 }
2193 break;
2194
2195 case SOCKET_FINAL_SIGKILL:
2196 log_warning_unit(UNIT(s)->id,
2197 "%s still around after SIGKILL (2). Entering failed mode.",
2198 UNIT(s)->id);
2199 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2200 break;
2201
2202 default:
2203 assert_not_reached("Timeout at wrong time.");
2204 }
2205
2206 return 0;
2207 }
2208
2209 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2210 int *rfds;
2211 unsigned rn_fds, k;
2212 SocketPort *p;
2213
2214 assert(s);
2215 assert(fds);
2216 assert(n_fds);
2217
2218 /* Called from the service code for requesting our fds */
2219
2220 rn_fds = 0;
2221 LIST_FOREACH(port, p, s->ports)
2222 if (p->fd >= 0)
2223 rn_fds++;
2224
2225 if (rn_fds <= 0) {
2226 *fds = NULL;
2227 *n_fds = 0;
2228 return 0;
2229 }
2230
2231 if (!(rfds = new(int, rn_fds)))
2232 return -ENOMEM;
2233
2234 k = 0;
2235 LIST_FOREACH(port, p, s->ports)
2236 if (p->fd >= 0)
2237 rfds[k++] = p->fd;
2238
2239 assert(k == rn_fds);
2240
2241 *fds = rfds;
2242 *n_fds = rn_fds;
2243
2244 return 0;
2245 }
2246
2247 static void socket_reset_failed(Unit *u) {
2248 Socket *s = SOCKET(u);
2249
2250 assert(s);
2251
2252 if (s->state == SOCKET_FAILED)
2253 socket_set_state(s, SOCKET_DEAD);
2254
2255 s->result = SOCKET_SUCCESS;
2256 }
2257
2258 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2259 assert(s);
2260
2261 /* The service is dead. Dang!
2262 *
2263 * This is strictly for one-instance-for-all-connections
2264 * services. */
2265
2266 if (s->state == SOCKET_RUNNING) {
2267 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2268 if (failed_permanent)
2269 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2270 else
2271 socket_enter_listening(s);
2272 }
2273 }
2274
2275 void socket_connection_unref(Socket *s) {
2276 assert(s);
2277
2278 /* The service is dead. Yay!
2279 *
2280 * This is strictly for one-instance-per-connection
2281 * services. */
2282
2283 assert(s->n_connections > 0);
2284 s->n_connections--;
2285
2286 log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2287 }
2288
2289 static void socket_trigger_notify(Unit *u, Unit *other) {
2290 Socket *s = SOCKET(u);
2291 Service *se;
2292
2293 assert(u);
2294 assert(other);
2295
2296 /* Don't propagate state changes from the service if we are
2297 already down or accepting connections */
2298 if ((s->state != SOCKET_RUNNING &&
2299 s->state != SOCKET_LISTENING) ||
2300 s->accept)
2301 return;
2302
2303 if (other->load_state != UNIT_LOADED ||
2304 other->type != UNIT_SERVICE)
2305 return;
2306
2307 se = SERVICE(other);
2308
2309 if (se->state == SERVICE_FAILED)
2310 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2311
2312 if (se->state == SERVICE_DEAD ||
2313 se->state == SERVICE_STOP ||
2314 se->state == SERVICE_STOP_SIGTERM ||
2315 se->state == SERVICE_STOP_SIGKILL ||
2316 se->state == SERVICE_STOP_POST ||
2317 se->state == SERVICE_FINAL_SIGTERM ||
2318 se->state == SERVICE_FINAL_SIGKILL ||
2319 se->state == SERVICE_AUTO_RESTART)
2320 socket_notify_service_dead(s, false);
2321
2322 if (se->state == SERVICE_RUNNING)
2323 socket_set_state(s, SOCKET_RUNNING);
2324 }
2325
2326 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2327 return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2328 }
2329
2330 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2331 Socket *s = SOCKET(u);
2332 int r;
2333
2334 if (!s->timer_event_source)
2335 return 0;
2336
2337 r = sd_event_source_get_time(s->timer_event_source, timeout);
2338 if (r < 0)
2339 return r;
2340
2341 return 1;
2342 }
2343
2344 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2345 [SOCKET_DEAD] = "dead",
2346 [SOCKET_START_PRE] = "start-pre",
2347 [SOCKET_START_POST] = "start-post",
2348 [SOCKET_LISTENING] = "listening",
2349 [SOCKET_RUNNING] = "running",
2350 [SOCKET_STOP_PRE] = "stop-pre",
2351 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2352 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2353 [SOCKET_STOP_POST] = "stop-post",
2354 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2355 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2356 [SOCKET_FAILED] = "failed"
2357 };
2358
2359 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2360
2361 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2362 [SOCKET_EXEC_START_PRE] = "StartPre",
2363 [SOCKET_EXEC_START_POST] = "StartPost",
2364 [SOCKET_EXEC_STOP_PRE] = "StopPre",
2365 [SOCKET_EXEC_STOP_POST] = "StopPost"
2366 };
2367
2368 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2369
2370 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2371 [SOCKET_SUCCESS] = "success",
2372 [SOCKET_FAILURE_RESOURCES] = "resources",
2373 [SOCKET_FAILURE_TIMEOUT] = "timeout",
2374 [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2375 [SOCKET_FAILURE_SIGNAL] = "signal",
2376 [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2377 [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2378 };
2379
2380 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2381
2382 const UnitVTable socket_vtable = {
2383 .object_size = sizeof(Socket),
2384 .exec_context_offset = offsetof(Socket, exec_context),
2385 .cgroup_context_offset = offsetof(Socket, cgroup_context),
2386 .kill_context_offset = offsetof(Socket, kill_context),
2387 .exec_runtime_offset = offsetof(Socket, exec_runtime),
2388
2389 .sections =
2390 "Unit\0"
2391 "Socket\0"
2392 "Install\0",
2393 .private_section = "Socket",
2394
2395 .init = socket_init,
2396 .done = socket_done,
2397 .load = socket_load,
2398
2399 .coldplug = socket_coldplug,
2400
2401 .dump = socket_dump,
2402
2403 .start = socket_start,
2404 .stop = socket_stop,
2405
2406 .kill = socket_kill,
2407
2408 .get_timeout = socket_get_timeout,
2409
2410 .serialize = socket_serialize,
2411 .deserialize_item = socket_deserialize_item,
2412 .distribute_fds = socket_distribute_fds,
2413
2414 .active_state = socket_active_state,
2415 .sub_state_to_string = socket_sub_state_to_string,
2416
2417 .check_gc = socket_check_gc,
2418
2419 .sigchld_event = socket_sigchld_event,
2420
2421 .trigger_notify = socket_trigger_notify,
2422
2423 .reset_failed = socket_reset_failed,
2424
2425 .bus_interface = "org.freedesktop.systemd1.Socket",
2426 .bus_vtable = bus_socket_vtable,
2427 .bus_set_property = bus_socket_set_property,
2428 .bus_commit_properties = bus_socket_commit_properties,
2429
2430 .status_message_formats = {
2431 /*.starting_stopping = {
2432 [0] = "Starting socket %s...",
2433 [1] = "Stopping socket %s...",
2434 },*/
2435 .finished_start_job = {
2436 [JOB_DONE] = "Listening on %s.",
2437 [JOB_FAILED] = "Failed to listen on %s.",
2438 [JOB_DEPENDENCY] = "Dependency failed for %s.",
2439 [JOB_TIMEOUT] = "Timed out starting %s.",
2440 },
2441 .finished_stop_job = {
2442 [JOB_DONE] = "Closed %s.",
2443 [JOB_FAILED] = "Failed stopping %s.",
2444 [JOB_TIMEOUT] = "Timed out stopping %s.",
2445 },
2446 },
2447 };
Unnamed repository; edit this file 'description' to name the repository.