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