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