]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/socket.c
projects / thirdparty / systemd.git / blob
? search:


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