]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/socket.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
systemctl: fix detection of active units
[thirdparty/systemd.git] / src / socket.c
CommitLineData
5cb5a6ff
LP		 1/*-*- Mode: C; c-basic-offset: 8 -*-*/
2
a7334b09
LP		 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 General Public License as published by
10 the Free Software Foundation; either version 2 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 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
83c60c9f
LP		 22#include <sys/types.h>
23#include <sys/stat.h>
24#include <unistd.h>
25#include <errno.h>
26#include <fcntl.h>
f94ea366 27#include <sys/epoll.h>
034c6ed7 28#include <signal.h>
4f2d528d 29#include <arpa/inet.h>
83c60c9f 30
87f0e418 31#include "unit.h"
5cb5a6ff 32#include "socket.h"
83c60c9f 33#include "log.h"
23a177ef
LP		 34#include "load-dropin.h"
35#include "load-fragment.h"
9e2f7c11 36#include "strv.h"
4f2d528d 37#include "unit-name.h"
4139c1b2 38#include "dbus-socket.h"
4fd5948e 39#include "missing.h"
83c60c9f 40
acbb0225 41static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
87f0e418
LP		 42 [SOCKET_DEAD] = UNIT_INACTIVE,
43 [SOCKET_START_PRE] = UNIT_ACTIVATING,
44 [SOCKET_START_POST] = UNIT_ACTIVATING,
45 [SOCKET_LISTENING] = UNIT_ACTIVE,
46 [SOCKET_RUNNING] = UNIT_ACTIVE,
47 [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
48 [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
49 [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
50 [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
80876c20
LP		 51 [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
52 [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
032ff4af 53 [SOCKET_MAINTENANCE] = UNIT_MAINTENANCE
83c60c9f 54};
5cb5a6ff 55
a16e1123
LP		 56static void socket_init(Unit *u) {
57 Socket *s = SOCKET(u);
58
59 assert(u);
60 assert(u->meta.load_state == UNIT_STUB);
61
a16e1123
LP		 62 s->backlog = SOMAXCONN;
63 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
64 s->directory_mode = 0755;
65 s->socket_mode = 0666;
66
6cf6bbc2
LP		 67 s->max_connections = 64;
68
4fd5948e
LP		 69 s->keep_alive = false;
70 s->priority = -1;
71 s->receive_buffer = 0;
72 s->send_buffer = 0;
73 s->ip_tos = -1;
74 s->ip_ttl = -1;
75 s->pipe_size = 0;
76 s->mark = -1;
77 s->free_bind = false;
78
a16e1123
LP		 79 exec_context_init(&s->exec_context);
80
81 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
82}
acbb0225 83
5e94833f
LP		 84static void socket_unwatch_control_pid(Socket *s) {
85 assert(s);
86
87 if (s->control_pid <= 0)
88 return;
89
90 unit_unwatch_pid(UNIT(s), s->control_pid);
91 s->control_pid = 0;
92}
93
87f0e418
LP		 94static void socket_done(Unit *u) {
95 Socket *s = SOCKET(u);
034c6ed7 96 SocketPort *p;
6cf6bbc2 97 Meta *i;
034c6ed7
LP		 98
99 assert(s);
100
101 while ((p = s->ports)) {
102 LIST_REMOVE(SocketPort, port, s->ports, p);
103
a16e1123
LP		 104 if (p->fd >= 0) {
105 unit_unwatch_fd(UNIT(s), &p->fd_watch);
106 close_nointr_nofail(p->fd);
107 }
108
034c6ed7
LP		 109 free(p->path);
110 free(p);
111 }
112
113 exec_context_done(&s->exec_context);
e537352b 114 exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
034c6ed7
LP		 115 s->control_command = NULL;
116
5e94833f 117 socket_unwatch_control_pid(s);
034c6ed7
LP		 118
119 s->service = NULL;
120
acbb0225 121 free(s->bind_to_device);
e537352b 122 s->bind_to_device = NULL;
acbb0225
LP		 123
124 unit_unwatch_timer(u, &s->timer_watch);
6cf6bbc2
LP		 125
126 /* Make sure no service instance refers to us anymore. */
127 LIST_FOREACH(units_per_type, i, u->meta.manager->units_per_type[UNIT_SERVICE]) {
128 Service *service = (Service *) i;
129
130 if (service->socket == s)
131 service->socket = NULL;
132 }
5cb5a6ff
LP		 133}
134
4f2d528d
LP		 135static bool have_non_accept_socket(Socket *s) {
136 SocketPort *p;
137
138 assert(s);
139
140 if (!s->accept)
141 return true;
142
dd5ad9d4
LP		 143 LIST_FOREACH(port, p, s->ports) {
144
145 if (p->type != SOCKET_SOCKET)
146 return true;
147
4f2d528d
LP		 148 if (!socket_address_can_accept(&p->address))
149 return true;
dd5ad9d4 150 }
4f2d528d
LP		 151
152 return false;
153}
154
155static int socket_verify(Socket *s) {
156 assert(s);
157
4cd1fbcc 158 if (s->meta.load_state != UNIT_LOADED)
4f2d528d
LP		 159 return 0;
160
161 if (!s->ports) {
4cd1fbcc 162 log_error("%s lacks Listen setting. Refusing.", s->meta.id);
4f2d528d
LP		 163 return -EINVAL;
164 }
165
6cf6bbc2 166 if (s->accept && s->max_connections <= 0) {
4d0e5dbd
LP		 167 log_error("%s's MaxConnection setting too small. Refusing.", s->meta.id);
168 return -EINVAL;
169 }
170
171 if (s->exec_context.pam_name && s->kill_mode != KILL_CONTROL_GROUP) {
172 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", s->meta.id);
6cf6bbc2
LP		 173 return -EINVAL;
174 }
175
4f2d528d
LP		 176 return 0;
177}
178
6e2ef85b
LP		 179static bool socket_needs_mount(Socket *s, const char *prefix) {
180 SocketPort *p;
181
182 assert(s);
183
184 LIST_FOREACH(port, p, s->ports) {
185
186 if (p->type == SOCKET_SOCKET) {
187 if (socket_address_needs_mount(&p->address, prefix))
188 return true;
189 } else {
190 assert(p->type == SOCKET_FIFO);
191 if (path_startswith(p->path, prefix))
192 return true;
193 }
194 }
195
196 return false;
197}
198
199int socket_add_one_mount_link(Socket *s, Mount *m) {
200 int r;
201
202 assert(s);
203 assert(m);
204
205 if (s->meta.load_state != UNIT_LOADED ||
206 m->meta.load_state != UNIT_LOADED)
207 return 0;
208
209 if (!socket_needs_mount(s, m->where))
210 return 0;
211
212 if ((r = unit_add_dependency(UNIT(m), UNIT_BEFORE, UNIT(s), true)) < 0)
213 return r;
214
215 if ((r = unit_add_dependency(UNIT(s), UNIT_REQUIRES, UNIT(m), true)) < 0)
216 return r;
217
218 return 0;
219}
220
221static int socket_add_mount_links(Socket *s) {
222 Meta *other;
223 int r;
224
225 assert(s);
226
227 LIST_FOREACH(units_per_type, other, s->meta.manager->units_per_type[UNIT_MOUNT])
228 if ((r = socket_add_one_mount_link(s, (Mount*) other)) < 0)
229 return r;
230
231 return 0;
232}
233
234static int socket_add_device_link(Socket *s) {
235 char *t;
236 int r;
237
238 assert(s);
239
240 if (!s->bind_to_device)
241 return 0;
242
243 if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
244 return -ENOMEM;
245
246 r = unit_add_node_link(UNIT(s), t, false);
247 free(t);
248
249 return r;
250}
251
e537352b
LP		 252static int socket_load(Unit *u) {
253 Socket *s = SOCKET(u);
254 int r;
44d8db9e 255
e537352b
LP		 256 assert(u);
257 assert(u->meta.load_state == UNIT_STUB);
44d8db9e 258
e537352b 259 if ((r = unit_load_fragment_and_dropin(u)) < 0)
23a177ef 260 return r;
44d8db9e 261
23a177ef 262 /* This is a new unit? Then let's add in some extras */
e537352b 263 if (u->meta.load_state == UNIT_LOADED) {
44d8db9e 264
4f2d528d
LP		 265 if (have_non_accept_socket(s)) {
266 if ((r = unit_load_related_unit(u, ".service", (Unit**) &s->service)))
267 return r;
23a177ef 268
701cc384 269 if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service), true)) < 0)
4f2d528d
LP		 270 return r;
271 }
44d8db9e 272
6e2ef85b
LP		 273 if ((r = socket_add_mount_links(s)) < 0)
274 return r;
275
276 if ((r = socket_add_device_link(s)) < 0)
277 return r;
278
23a177ef
LP		 279 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
280 return r;
281
282 if ((r = unit_add_default_cgroup(u)) < 0)
283 return r;
284 }
285
4f2d528d 286 return socket_verify(s);
44d8db9e
LP		 287}
288
542563ba
LP		 289static const char* listen_lookup(int type) {
290
291 if (type == SOCK_STREAM)
292 return "ListenStream";
293 else if (type == SOCK_DGRAM)
294 return "ListenDatagram";
295 else if (type == SOCK_SEQPACKET)
296 return "ListenSequentialPacket";
297
034c6ed7 298 assert_not_reached("Unknown socket type");
542563ba
LP		 299 return NULL;
300}
301
87f0e418 302static void socket_dump(Unit *u, FILE *f, const char *prefix) {
5cb5a6ff 303
5cb5a6ff 304 SocketExecCommand c;
87f0e418 305 Socket *s = SOCKET(u);
542563ba 306 SocketPort *p;
82ba9f08
LP		 307 const char *prefix2;
308 char *p2;
5cb5a6ff
LP		 309
310 assert(s);
fa068367 311 assert(f);
5cb5a6ff 312
82ba9f08
LP		 313 p2 = strappend(prefix, "\t");
314 prefix2 = p2 ? p2 : prefix;
c43d20a0 315
5cb5a6ff
LP		 316 fprintf(f,
317 "%sSocket State: %s\n"
542563ba 318 "%sBindIPv6Only: %s\n"
b5a0699f 319 "%sBacklog: %u\n"
50159e6a 320 "%sKillMode: %s\n"
b5a0699f 321 "%sSocketMode: %04o\n"
4fd5948e
LP		 322 "%sDirectoryMode: %04o\n"
323 "%sKeepAlive: %s\n"
324 "%sFreeBind: %s\n",
a16e1123 325 prefix, socket_state_to_string(s->state),
c0120d99 326 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
b5a0699f 327 prefix, s->backlog,
50159e6a 328 prefix, kill_mode_to_string(s->kill_mode),
b5a0699f 329 prefix, s->socket_mode,
4fd5948e
LP		 330 prefix, s->directory_mode,
331 prefix, yes_no(s->keep_alive),
332 prefix, yes_no(s->free_bind));
542563ba 333
70123e68
LP		 334 if (s->control_pid > 0)
335 fprintf(f,
bb00e604
LP		 336 "%sControl PID: %lu\n",
337 prefix, (unsigned long) s->control_pid);
70123e68 338
acbb0225
LP		 339 if (s->bind_to_device)
340 fprintf(f,
341 "%sBindToDevice: %s\n",
342 prefix, s->bind_to_device);
343
4f2d528d
LP		 344 if (s->accept)
345 fprintf(f,
6cf6bbc2
LP		 346 "%sAccepted: %u\n"
347 "%sNConnections: %u\n"
348 "%sMaxConnections: %u\n",
349 prefix, s->n_accepted,
350 prefix, s->n_connections,
351 prefix, s->max_connections);
4f2d528d 352
4fd5948e
LP		 353 if (s->priority >= 0)
354 fprintf(f,
355 "%sPriority: %i\n",
356 prefix, s->priority);
357
358 if (s->receive_buffer > 0)
359 fprintf(f,
360 "%sReceiveBuffer: %zu\n",
361 prefix, s->receive_buffer);
362
363 if (s->send_buffer > 0)
364 fprintf(f,
365 "%sSendBuffer: %zu\n",
366 prefix, s->send_buffer);
367
368 if (s->ip_tos >= 0)
369 fprintf(f,
370 "%sIPTOS: %i\n",
371 prefix, s->ip_tos);
372
373 if (s->ip_ttl >= 0)
374 fprintf(f,
375 "%sIPTTL: %i\n",
376 prefix, s->ip_ttl);
377
378 if (s->pipe_size > 0)
379 fprintf(f,
380 "%sPipeSize: %zu\n",
381 prefix, s->pipe_size);
382
383 if (s->mark >= 0)
384 fprintf(f,
385 "%sMark: %i\n",
386 prefix, s->mark);
387
034c6ed7 388 LIST_FOREACH(port, p, s->ports) {
5cb5a6ff 389
542563ba
LP		 390 if (p->type == SOCKET_SOCKET) {
391 const char *t;
392 int r;
393 char *k;
394
395 if ((r = socket_address_print(&p->address, &k)) < 0)
396 t = strerror(-r);
397 else
398 t = k;
399
400 fprintf(f, "%s%s: %s\n", prefix, listen_lookup(p->address.type), k);
401 free(k);
402 } else
403 fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
404 }
5cb5a6ff
LP		 405
406 exec_context_dump(&s->exec_context, f, prefix);
407
e537352b 408 for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
c43d20a0
LP		 409 if (!s->exec_command[c])
410 continue;
5cb5a6ff 411
40d50879 412 fprintf(f, "%s-> %s:\n",
a16e1123 413 prefix, socket_exec_command_to_string(c));
c43d20a0
LP		 414
415 exec_command_dump_list(s->exec_command[c], f, prefix2);
5cb5a6ff 416 }
c43d20a0 417
82ba9f08 418 free(p2);
5cb5a6ff
LP		 419}
420
4f2d528d
LP		 421static int instance_from_socket(int fd, unsigned nr, char **instance) {
422 socklen_t l;
423 char *r;
424 union {
425 struct sockaddr sa;
426 struct sockaddr_un un;
427 struct sockaddr_in in;
428 struct sockaddr_in6 in6;
429 struct sockaddr_storage storage;
430 } local, remote;
431
432 assert(fd >= 0);
433 assert(instance);
434
435 l = sizeof(local);
436 if (getsockname(fd, &local.sa, &l) < 0)
437 return -errno;
438
439 l = sizeof(remote);
440 if (getpeername(fd, &remote.sa, &l) < 0)
441 return -errno;
442
443 switch (local.sa.sa_family) {
444
445 case AF_INET: {
446 uint32_t
447 a = ntohl(local.in.sin_addr.s_addr),
448 b = ntohl(remote.in.sin_addr.s_addr);
449
450 if (asprintf(&r,
a16e1123 451 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
4f2d528d
LP		 452 nr,
453 a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
454 ntohs(local.in.sin_port),
455 b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
456 ntohs(remote.in.sin_port)) < 0)
457 return -ENOMEM;
458
459 break;
460 }
461
462 case AF_INET6: {
2b061f5a
LP		 463 static const char ipv4_prefix[] = {
464 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
465 };
466
467 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
468 memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
469 const uint8_t
470 *a = local.in6.sin6_addr.s6_addr+12,
471 *b = remote.in6.sin6_addr.s6_addr+12;
472
473 if (asprintf(&r,
474 "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
475 nr,
476 a[0], a[1], a[2], a[3],
477 ntohs(local.in6.sin6_port),
478 b[0], b[1], b[2], b[3],
479 ntohs(remote.in6.sin6_port)) < 0)
480 return -ENOMEM;
481 } else {
482 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
483
484 if (asprintf(&r,
485 "%u-%s:%u-%s:%u",
486 nr,
487 inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
488 ntohs(local.in6.sin6_port),
489 inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
490 ntohs(remote.in6.sin6_port)) < 0)
491 return -ENOMEM;
492 }
4f2d528d
LP		 493
494 break;
495 }
496
497 case AF_UNIX: {
498 struct ucred ucred;
499
500 l = sizeof(ucred);
501 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
502 return -errno;
503
504 if (asprintf(&r,
bb00e604 505 "%u-%lu-%lu",
4f2d528d 506 nr,
bb00e604
LP		 507 (unsigned long) ucred.pid,
508 (unsigned long) ucred.uid) < 0)
4f2d528d
LP		 509 return -ENOMEM;
510
511 break;
512 }
513
514 default:
515 assert_not_reached("Unhandled socket type.");
516 }
517
518 *instance = r;
519 return 0;
520}
521
034c6ed7 522static void socket_close_fds(Socket *s) {
83c60c9f
LP		 523 SocketPort *p;
524
525 assert(s);
526
034c6ed7 527 LIST_FOREACH(port, p, s->ports) {
83c60c9f
LP		 528 if (p->fd < 0)
529 continue;
530
acbb0225 531 unit_unwatch_fd(UNIT(s), &p->fd_watch);
a16e1123
LP		 532 close_nointr_nofail(p->fd);
533
534 /* One little note: we should never delete any sockets
535 * in the file system here! After all some other
536 * process we spawned might still have a reference of
537 * this fd and wants to continue to use it. Therefore
538 * we delete sockets in the file system before we
539 * create a new one, not after we stopped using
540 * one! */
9152c765 541
83c60c9f
LP		 542 p->fd = -1;
543 }
544}
545
4fd5948e
LP		 546static void socket_apply_socket_options(Socket *s, int fd) {
547 assert(s);
548 assert(fd >= 0);
549
550 if (s->keep_alive) {
551 int b = s->keep_alive;
552 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
553 log_warning("SO_KEEPALIVE failed: %m");
554 }
555
556 if (s->priority >= 0)
557 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
558 log_warning("SO_PRIORITY failed: %m");
559
560 if (s->receive_buffer > 0) {
561 int value = (int) s->receive_buffer;
562 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
563 log_warning("SO_RCVBUF failed: %m");
564 }
565
566 if (s->send_buffer > 0) {
567 int value = (int) s->send_buffer;
568 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
569 log_warning("SO_SNDBUF failed: %m");
570 }
571
572 if (s->mark >= 0)
573 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
574 log_warning("SO_MARK failed: %m");
575
576 if (s->ip_tos >= 0)
577 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
578 log_warning("IP_TOS failed: %m");
579
580 if (s->ip_ttl >= 0)
581 if (setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl)) < 0)
582 log_warning("IP_TTL failed: %m");
583}
584
585static void socket_apply_pipe_options(Socket *s, int fd) {
586 assert(s);
587 assert(fd >= 0);
588
589 if (s->pipe_size > 0)
590 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
591 log_warning("F_SETPIPE_SZ: %m");
592}
593
034c6ed7 594static int socket_open_fds(Socket *s) {
83c60c9f
LP		 595 SocketPort *p;
596 int r;
597
598 assert(s);
599
034c6ed7 600 LIST_FOREACH(port, p, s->ports) {
83c60c9f 601
034c6ed7
LP		 602 if (p->fd >= 0)
603 continue;
83c60c9f
LP		 604
605 if (p->type == SOCKET_SOCKET) {
606
b5a0699f
LP		 607 if ((r = socket_address_listen(
608 &p->address,
609 s->backlog,
610 s->bind_ipv6_only,
611 s->bind_to_device,
4fd5948e 612 s->free_bind,
b5a0699f
LP		 613 s->directory_mode,
614 s->socket_mode,
615 &p->fd)) < 0)
83c60c9f
LP		 616 goto rollback;
617
4fd5948e
LP		 618 socket_apply_socket_options(s, p->fd);
619
83c60c9f
LP		 620 } else {
621 struct stat st;
622 assert(p->type == SOCKET_FIFO);
623
8cb45bf8
LP		 624 mkdir_parents(p->path, s->directory_mode);
625
626 if (mkfifo(p->path, s->socket_mode) < 0 && errno != EEXIST) {
83c60c9f
LP		 627 r = -errno;
628 goto rollback;
629 }
630
631 if ((p->fd = open(p->path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
632 r = -errno;
633 goto rollback;
634 }
635
636 if (fstat(p->fd, &st) < 0) {
637 r = -errno;
638 goto rollback;
639 }
640
641 /* FIXME verify user, access mode */
642
643 if (!S_ISFIFO(st.st_mode)) {
644 r = -EEXIST;
645 goto rollback;
646 }
4fd5948e
LP		 647
648 socket_apply_pipe_options(s, p->fd);
83c60c9f 649 }
034c6ed7
LP		 650 }
651
652 return 0;
653
654rollback:
655 socket_close_fds(s);
656 return r;
657}
658
659static void socket_unwatch_fds(Socket *s) {
660 SocketPort *p;
9152c765 661
034c6ed7
LP		 662 assert(s);
663
664 LIST_FOREACH(port, p, s->ports) {
665 if (p->fd < 0)
666 continue;
667
acbb0225 668 unit_unwatch_fd(UNIT(s), &p->fd_watch);
83c60c9f 669 }
034c6ed7
LP		 670}
671
672static int socket_watch_fds(Socket *s) {
673 SocketPort *p;
674 int r;
675
676 assert(s);
83c60c9f 677
034c6ed7
LP		 678 LIST_FOREACH(port, p, s->ports) {
679 if (p->fd < 0)
680 continue;
681
cabab516 682 p->fd_watch.socket_accept =
4f2d528d 683 s->accept &&
dd5ad9d4 684 p->type == SOCKET_SOCKET &&
4f2d528d
LP		 685 socket_address_can_accept(&p->address);
686
f94ea366 687 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
034c6ed7
LP		 688 goto fail;
689 }
83c60c9f 690
542563ba 691 return 0;
83c60c9f 692
034c6ed7
LP		 693fail:
694 socket_unwatch_fds(s);
695 return r;
696}
697
698static void socket_set_state(Socket *s, SocketState state) {
699 SocketState old_state;
700 assert(s);
701
702 old_state = s->state;
703 s->state = state;
704
705 if (state != SOCKET_START_PRE &&
706 state != SOCKET_START_POST &&
707 state != SOCKET_STOP_PRE &&
708 state != SOCKET_STOP_PRE_SIGTERM &&
709 state != SOCKET_STOP_PRE_SIGKILL &&
710 state != SOCKET_STOP_POST &&
80876c20
LP		 711 state != SOCKET_FINAL_SIGTERM &&
712 state != SOCKET_FINAL_SIGKILL) {
acbb0225 713 unit_unwatch_timer(UNIT(s), &s->timer_watch);
5e94833f 714 socket_unwatch_control_pid(s);
034c6ed7 715 s->control_command = NULL;
a16e1123 716 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
e537352b 717 }
034c6ed7 718
a16e1123
LP		 719 if (state != SOCKET_LISTENING)
720 socket_unwatch_fds(s);
721
034c6ed7
LP		 722 if (state != SOCKET_START_POST &&
723 state != SOCKET_LISTENING &&
724 state != SOCKET_RUNNING &&
725 state != SOCKET_STOP_PRE &&
726 state != SOCKET_STOP_PRE_SIGTERM &&
727 state != SOCKET_STOP_PRE_SIGKILL)
728 socket_close_fds(s);
729
e537352b 730 if (state != old_state)
40d50879 731 log_debug("%s changed %s -> %s",
a16e1123
LP		 732 s->meta.id,
733 socket_state_to_string(old_state),
734 socket_state_to_string(state));
acbb0225
LP		 735
736 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]);
034c6ed7
LP		 737}
738
a16e1123
LP		 739static int socket_coldplug(Unit *u) {
740 Socket *s = SOCKET(u);
741 int r;
742
743 assert(s);
744 assert(s->state == SOCKET_DEAD);
745
746 if (s->deserialized_state != s->state) {
747
748 if (s->deserialized_state == SOCKET_START_PRE ||
749 s->deserialized_state == SOCKET_START_POST ||
750 s->deserialized_state == SOCKET_STOP_PRE ||
751 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
752 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
753 s->deserialized_state == SOCKET_STOP_POST ||
754 s->deserialized_state == SOCKET_FINAL_SIGTERM ||
755 s->deserialized_state == SOCKET_FINAL_SIGKILL) {
756
757 if (s->control_pid <= 0)
758 return -EBADMSG;
759
760 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
761 return r;
762
763 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
764 return r;
765 }
766
767 if (s->deserialized_state == SOCKET_START_POST ||
768 s->deserialized_state == SOCKET_LISTENING ||
769 s->deserialized_state == SOCKET_RUNNING ||
770 s->deserialized_state == SOCKET_STOP_PRE ||
771 s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
772 s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
773 if ((r = socket_open_fds(s)) < 0)
774 return r;
775
776 if (s->deserialized_state == SOCKET_LISTENING)
777 if ((r = socket_watch_fds(s)) < 0)
778 return r;
779
780 socket_set_state(s, s->deserialized_state);
781 }
782
783 return 0;
784}
785
e537352b 786static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
034c6ed7
LP		 787 pid_t pid;
788 int r;
9e2f7c11 789 char **argv;
034c6ed7
LP		 790
791 assert(s);
792 assert(c);
793 assert(_pid);
794
e537352b
LP		 795 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
796 goto fail;
034c6ed7 797
9e2f7c11
LP		 798 if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
799 r = -ENOMEM;
800 goto fail;
801 }
802
803 r = exec_spawn(c,
804 argv,
805 &s->exec_context,
806 NULL, 0,
1137a57c 807 s->meta.manager->environment,
9e2f7c11
LP		 808 true,
809 true,
4cd1fbcc
LP		 810 s->meta.manager->confirm_spawn,
811 s->meta.cgroup_bondings,
9e2f7c11
LP		 812 &pid);
813
814 strv_free(argv);
815 if (r < 0)
034c6ed7
LP		 816 goto fail;
817
87f0e418 818 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
034c6ed7
LP		 819 /* FIXME: we need to do something here */
820 goto fail;
83c60c9f 821
034c6ed7
LP		 822 *_pid = pid;
823
824 return 0;
825
826fail:
e537352b 827 unit_unwatch_timer(UNIT(s), &s->timer_watch);
83c60c9f
LP		 828
829 return r;
542563ba
LP		 830}
831
034c6ed7
LP		 832static void socket_enter_dead(Socket *s, bool success) {
833 assert(s);
834
835 if (!success)
836 s->failure = true;
837
18c78fb1 838 socket_set_state(s, s->failure ? SOCKET_MAINTENANCE : SOCKET_DEAD);
034c6ed7
LP		 839}
840
80876c20
LP		 841static void socket_enter_signal(Socket *s, SocketState state, bool success);
842
034c6ed7
LP		 843static void socket_enter_stop_post(Socket *s, bool success) {
844 int r;
845 assert(s);
846
847 if (!success)
848 s->failure = true;
849
5e94833f
LP		 850 socket_unwatch_control_pid(s);
851
a16e1123
LP		 852 s->control_command_id = SOCKET_EXEC_STOP_POST;
853
80876c20 854 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
e537352b 855 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 856 goto fail;
857
80876c20
LP		 858 socket_set_state(s, SOCKET_STOP_POST);
859 } else
860 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, true);
034c6ed7
LP		 861
862 return;
863
864fail:
6cf6bbc2 865 log_warning("%s failed to run 'stop-post' task: %s", s->meta.id, strerror(-r));
80876c20 866 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
034c6ed7
LP		 867}
868
869static void socket_enter_signal(Socket *s, SocketState state, bool success) {
870 int r;
80876c20 871 bool sent = false;
034c6ed7
LP		 872
873 assert(s);
874
875 if (!success)
876 s->failure = true;
877
80876c20
LP		 878 if (s->kill_mode != KILL_NONE) {
879 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
034c6ed7 880
50159e6a
LP		 881 if (s->kill_mode == KILL_CONTROL_GROUP) {
882
4cd1fbcc 883 if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig)) < 0) {
50159e6a
LP		 884 if (r != -EAGAIN && r != -ESRCH)
885 goto fail;
886 } else
887 sent = true;
034c6ed7 888 }
50159e6a 889
80876c20 890 if (!sent && s->control_pid > 0)
50159e6a
LP		 891 if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH) {
892 r = -errno;
893 goto fail;
894 }
d6ea93e3 895 }
034c6ed7 896
e93bc5a6 897 if (sent && s->control_pid > 0) {
80876c20
LP		 898 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
899 goto fail;
d6ea93e3 900
80876c20
LP		 901 socket_set_state(s, state);
902 } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
903 socket_enter_stop_post(s, true);
904 else
034c6ed7
LP		 905 socket_enter_dead(s, true);
906
907 return;
908
909fail:
9e2f7c11 910 log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r));
034c6ed7
LP		 911
912 if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
913 socket_enter_stop_post(s, false);
914 else
915 socket_enter_dead(s, false);
916}
917
918static void socket_enter_stop_pre(Socket *s, bool success) {
919 int r;
920 assert(s);
921
922 if (!success)
923 s->failure = true;
924
5e94833f
LP		 925 socket_unwatch_control_pid(s);
926
a16e1123
LP		 927 s->control_command_id = SOCKET_EXEC_STOP_PRE;
928
80876c20 929 if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
e537352b 930 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 931 goto fail;
932
80876c20
LP		 933 socket_set_state(s, SOCKET_STOP_PRE);
934 } else
034c6ed7
LP		 935 socket_enter_stop_post(s, true);
936
937 return;
938
939fail:
6cf6bbc2 940 log_warning("%s failed to run 'stop-pre' task: %s", s->meta.id, strerror(-r));
034c6ed7
LP		 941 socket_enter_stop_post(s, false);
942}
943
e9af15c3
LP		 944static void socket_enter_listening(Socket *s) {
945 int r;
946 assert(s);
947
948 if ((r = socket_watch_fds(s)) < 0) {
9e2f7c11 949 log_warning("%s failed to watch sockets: %s", s->meta.id, strerror(-r));
e9af15c3
LP		 950 goto fail;
951 }
952
953 socket_set_state(s, SOCKET_LISTENING);
954 return;
955
956fail:
957 socket_enter_stop_pre(s, false);
958}
959
034c6ed7
LP		 960static void socket_enter_start_post(Socket *s) {
961 int r;
962 assert(s);
963
e9af15c3 964 if ((r = socket_open_fds(s)) < 0) {
9e2f7c11 965 log_warning("%s failed to listen on sockets: %s", s->meta.id, strerror(-r));
034c6ed7
LP		 966 goto fail;
967 }
968
5e94833f
LP		 969 socket_unwatch_control_pid(s);
970
a16e1123
LP		 971 s->control_command_id = SOCKET_EXEC_START_POST;
972
80876c20 973 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
e537352b 974 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) {
6cf6bbc2 975 log_warning("%s failed to run 'start-post' task: %s", s->meta.id, strerror(-r));
034c6ed7
LP		 976 goto fail;
977 }
978
80876c20
LP		 979 socket_set_state(s, SOCKET_START_POST);
980 } else
e9af15c3 981 socket_enter_listening(s);
034c6ed7
LP		 982
983 return;
984
985fail:
986 socket_enter_stop_pre(s, false);
987}
988
989static void socket_enter_start_pre(Socket *s) {
990 int r;
991 assert(s);
992
5e94833f
LP		 993 socket_unwatch_control_pid(s);
994
a16e1123
LP		 995 s->control_command_id = SOCKET_EXEC_START_PRE;
996
80876c20 997 if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
e537352b 998 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 999 goto fail;
1000
80876c20
LP		 1001 socket_set_state(s, SOCKET_START_PRE);
1002 } else
034c6ed7
LP		 1003 socket_enter_start_post(s);
1004
1005 return;
1006
1007fail:
6cf6bbc2 1008 log_warning("%s failed to run 'start-pre' task: %s", s->meta.id, strerror(-r));
034c6ed7
LP		 1009 socket_enter_dead(s, false);
1010}
1011
4f2d528d 1012static void socket_enter_running(Socket *s, int cfd) {
034c6ed7
LP		 1013 int r;
1014
1015 assert(s);
1016
4f2d528d 1017 if (cfd < 0) {
4cd1fbcc 1018 if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, NULL)) < 0)
4f2d528d
LP		 1019 goto fail;
1020
1021 socket_set_state(s, SOCKET_RUNNING);
1022 } else {
1023 Unit *u;
1024 char *prefix, *instance, *name;
1025
6cf6bbc2
LP		 1026 if (s->n_connections >= s->max_connections) {
1027 log_warning("Too many incoming connections (%u)", s->n_connections);
1028 close_nointr_nofail(cfd);
1029 return;
1030 }
1031
b6dbbe1c 1032 if ((r = instance_from_socket(cfd, s->n_accepted++, &instance)) < 0)
4f2d528d
LP		 1033 goto fail;
1034
4cd1fbcc 1035 if (!(prefix = unit_name_to_prefix(s->meta.id))) {
4f2d528d
LP		 1036 free(instance);
1037 r = -ENOMEM;
1038 goto fail;
1039 }
1040
1041 name = unit_name_build(prefix, instance, ".service");
1042 free(prefix);
1043 free(instance);
1044
b6dbbe1c 1045 if (!name) {
4f2d528d 1046 r = -ENOMEM;
b6dbbe1c
LP		 1047 goto fail;
1048 }
4f2d528d 1049
4cd1fbcc 1050 r = manager_load_unit(s->meta.manager, name, NULL, &u);
4f2d528d
LP		 1051 free(name);
1052
1053 if (r < 0)
1054 goto fail;
1055
6cf6bbc2 1056 if ((r = service_set_socket_fd(SERVICE(u), cfd, s)) < 0)
4f2d528d
LP		 1057 goto fail;
1058
1059 cfd = -1;
1060
6cf6bbc2
LP		 1061 s->n_connections ++;
1062
4f2d528d
LP		 1063 if ((r = manager_add_job(u->meta.manager, JOB_START, u, JOB_REPLACE, true, NULL)) < 0)
1064 goto fail;
1065 }
034c6ed7 1066
034c6ed7
LP		 1067 return;
1068
1069fail:
9e2f7c11 1070 log_warning("%s failed to queue socket startup job: %s", s->meta.id, strerror(-r));
80876c20 1071 socket_enter_stop_pre(s, false);
4f2d528d
LP		 1072
1073 if (cfd >= 0)
1074 close_nointr_nofail(cfd);
034c6ed7
LP		 1075}
1076
1077static void socket_run_next(Socket *s, bool success) {
1078 int r;
1079
1080 assert(s);
1081 assert(s->control_command);
1082 assert(s->control_command->command_next);
1083
1084 if (!success)
1085 s->failure = true;
1086
5e94833f
LP		 1087 socket_unwatch_control_pid(s);
1088
034c6ed7
LP		 1089 s->control_command = s->control_command->command_next;
1090
e537352b 1091 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
034c6ed7
LP		 1092 goto fail;
1093
1094 return;
1095
1096fail:
6cf6bbc2 1097 log_warning("%s failed to run next task: %s", s->meta.id, strerror(-r));
80876c20
LP		 1098
1099 if (s->state == SOCKET_START_POST)
1100 socket_enter_stop_pre(s, false);
034c6ed7
LP		 1101 else if (s->state == SOCKET_STOP_POST)
1102 socket_enter_dead(s, false);
1103 else
80876c20 1104 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
034c6ed7
LP		 1105}
1106
87f0e418
LP		 1107static int socket_start(Unit *u) {
1108 Socket *s = SOCKET(u);
83c60c9f
LP		 1109
1110 assert(s);
1111
034c6ed7
LP		 1112 /* We cannot fulfill this request right now, try again later
1113 * please! */
1114 if (s->state == SOCKET_STOP_PRE ||
1115 s->state == SOCKET_STOP_PRE_SIGKILL ||
1116 s->state == SOCKET_STOP_PRE_SIGTERM ||
1117 s->state == SOCKET_STOP_POST ||
80876c20
LP		 1118 s->state == SOCKET_FINAL_SIGTERM ||
1119 s->state == SOCKET_FINAL_SIGKILL)
034c6ed7
LP		 1120 return -EAGAIN;
1121
83c60c9f
LP		 1122 if (s->state == SOCKET_START_PRE ||
1123 s->state == SOCKET_START_POST)
034c6ed7 1124 return 0;
83c60c9f 1125
034c6ed7 1126 /* Cannot run this without the service being around */
4f2d528d
LP		 1127 if (s->service) {
1128 if (s->service->meta.load_state != UNIT_LOADED)
1129 return -ENOENT;
1130
1131 /* If the service is alredy actvie we cannot start the
1132 * socket */
1133 if (s->service->state != SERVICE_DEAD &&
18c78fb1 1134 s->service->state != SERVICE_MAINTENANCE &&
4f2d528d
LP		 1135 s->service->state != SERVICE_AUTO_RESTART)
1136 return -EBUSY;
1137 }
e537352b 1138
18c78fb1 1139 assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTENANCE);
83c60c9f 1140
034c6ed7
LP		 1141 s->failure = false;
1142 socket_enter_start_pre(s);
1143 return 0;
1144}
83c60c9f 1145
87f0e418
LP		 1146static int socket_stop(Unit *u) {
1147 Socket *s = SOCKET(u);
034c6ed7
LP		 1148
1149 assert(s);
1150
1151 /* We cannot fulfill this request right now, try again later
1152 * please! */
1153 if (s->state == SOCKET_START_PRE ||
1154 s->state == SOCKET_START_POST)
1155 return -EAGAIN;
83c60c9f 1156
e537352b
LP		 1157 /* Already on it */
1158 if (s->state == SOCKET_STOP_PRE ||
1159 s->state == SOCKET_STOP_PRE_SIGTERM ||
1160 s->state == SOCKET_STOP_PRE_SIGKILL ||
1161 s->state == SOCKET_STOP_POST ||
80876c20
LP		 1162 s->state == SOCKET_FINAL_SIGTERM ||
1163 s->state == SOCKET_FINAL_SIGTERM)
e537352b
LP		 1164 return 0;
1165
034c6ed7 1166 assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
83c60c9f 1167
034c6ed7 1168 socket_enter_stop_pre(s, true);
542563ba
LP		 1169 return 0;
1170}
1171
a16e1123
LP		 1172static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1173 Socket *s = SOCKET(u);
1174 SocketPort *p;
1175 int r;
1176
1177 assert(u);
1178 assert(f);
1179 assert(fds);
1180
1181 unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1182 unit_serialize_item(u, f, "failure", yes_no(s->failure));
1183 unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1184
1185 if (s->control_pid > 0)
5925dd3c 1186 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
a16e1123
LP		 1187
1188 if (s->control_command_id >= 0)
1189 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1190
1191 LIST_FOREACH(port, p, s->ports) {
1192 int copy;
1193
1194 if (p->fd < 0)
1195 continue;
1196
1197 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1198 return copy;
1199
1200 if (p->type == SOCKET_SOCKET) {
1201 char *t;
1202
1203 if ((r = socket_address_print(&p->address, &t)) < 0)
1204 return r;
1205
27ca8d7a 1206 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
a16e1123
LP		 1207 free(t);
1208 } else {
1209 assert(p->type == SOCKET_FIFO);
1210 unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1211 }
1212 }
1213
1214 return 0;
1215}
1216
1217static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1218 Socket *s = SOCKET(u);
1219 int r;
1220
1221 assert(u);
1222 assert(key);
1223 assert(value);
1224 assert(fds);
1225
1226 if (streq(key, "state")) {
1227 SocketState state;
1228
1229 if ((state = socket_state_from_string(value)) < 0)
1230 log_debug("Failed to parse state value %s", value);
1231 else
1232 s->deserialized_state = state;
1233 } else if (streq(key, "failure")) {
1234 int b;
1235
1236 if ((b = parse_boolean(value)) < 0)
1237 log_debug("Failed to parse failure value %s", value);
1238 else
1239 s->failure = b || s->failure;
1240
1241 } else if (streq(key, "n-accepted")) {
1242 unsigned k;
1243
1244 if ((r = safe_atou(value, &k)) < 0)
1245 log_debug("Failed to parse n-accepted value %s", value);
1246 else
1247 s->n_accepted += k;
1248 } else if (streq(key, "control-pid")) {
5925dd3c 1249 pid_t pid;
a16e1123 1250
5925dd3c 1251 if ((r = parse_pid(value, &pid)) < 0)
a16e1123
LP		 1252 log_debug("Failed to parse control-pid value %s", value);
1253 else
5925dd3c 1254 s->control_pid = pid;
a16e1123
LP		 1255 } else if (streq(key, "control-command")) {
1256 SocketExecCommand id;
1257
1258 if ((id = socket_exec_command_from_string(value)) < 0)
1259 log_debug("Failed to parse exec-command value %s", value);
1260 else {
1261 s->control_command_id = id;
1262 s->control_command = s->exec_command[id];
1263 }
1264 } else if (streq(key, "fifo")) {
1265 int fd, skip = 0;
1266 SocketPort *p;
1267
1268 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1269 log_debug("Failed to parse fifo value %s", value);
1270 else {
1271
1272 LIST_FOREACH(port, p, s->ports)
1273 if (streq(p->path, value+skip))
1274 break;
1275
1276 if (p) {
1277 if (p->fd >= 0)
1278 close_nointr_nofail(p->fd);
1279 p->fd = fdset_remove(fds, fd);
1280 }
1281 }
1282
1283 } else if (streq(key, "socket")) {
27ca8d7a 1284 int fd, type, skip = 0;
a16e1123
LP		 1285 SocketPort *p;
1286
27ca8d7a 1287 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
a16e1123
LP		 1288 log_debug("Failed to parse socket value %s", value);
1289 else {
1290
1291 LIST_FOREACH(port, p, s->ports)
27ca8d7a 1292 if (socket_address_is(&p->address, value+skip, type))
a16e1123
LP		 1293 break;
1294
1295 if (p) {
1296 if (p->fd >= 0)
1297 close_nointr_nofail(p->fd);
1298 p->fd = fdset_remove(fds, fd);
1299 }
1300 }
1301
1302 } else
1303 log_debug("Unknown serialization key '%s'", key);
1304
1305 return 0;
1306}
1307
87f0e418
LP		 1308static UnitActiveState socket_active_state(Unit *u) {
1309 assert(u);
5cb5a6ff 1310
acbb0225 1311 return state_translation_table[SOCKET(u)->state];
5cb5a6ff
LP		 1312}
1313
10a94420
LP		 1314static const char *socket_sub_state_to_string(Unit *u) {
1315 assert(u);
1316
a16e1123 1317 return socket_state_to_string(SOCKET(u)->state);
10a94420
LP		 1318}
1319
6cf6bbc2
LP		 1320static bool socket_check_gc(Unit *u) {
1321 Socket *s = SOCKET(u);
1322
1323 assert(u);
1324
1325 return s->n_connections > 0;
1326}
1327
acbb0225 1328static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
87f0e418 1329 Socket *s = SOCKET(u);
4f2d528d 1330 int cfd = -1;
9152c765 1331
034c6ed7 1332 assert(s);
8d567588 1333 assert(fd >= 0);
9152c765 1334
871d7de4
LP		 1335 if (s->state != SOCKET_LISTENING)
1336 return;
1337
9e2f7c11 1338 log_debug("Incoming traffic on %s", u->meta.id);
9152c765 1339
4f2d528d
LP		 1340 if (events != EPOLLIN) {
1341 log_error("Got invalid poll event on socket.");
8d567588 1342 goto fail;
4f2d528d
LP		 1343 }
1344
cabab516 1345 if (w->socket_accept) {
4f2d528d
LP		 1346 for (;;) {
1347
1348 if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1349
1350 if (errno == EINTR)
1351 continue;
1352
1353 log_error("Failed to accept socket: %m");
8d567588 1354 goto fail;
4f2d528d
LP		 1355 }
1356
1357 break;
1358 }
4fd5948e
LP		 1359
1360 socket_apply_socket_options(s, cfd);
4f2d528d 1361 }
9152c765 1362
4f2d528d 1363 socket_enter_running(s, cfd);
8d567588
LP		 1364 return;
1365
1366fail:
1367 socket_enter_stop_pre(s, false);
9152c765
LP		 1368}
1369
87f0e418
LP		 1370static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1371 Socket *s = SOCKET(u);
034c6ed7 1372 bool success;
5cb5a6ff
LP		 1373
1374 assert(s);
034c6ed7 1375 assert(pid >= 0);
5cb5a6ff 1376
8c47c732
LP		 1377 if (pid != s->control_pid)
1378 return;
542563ba 1379
034c6ed7
LP		 1380 s->control_pid = 0;
1381
8c47c732
LP		 1382 success = is_clean_exit(code, status);
1383 s->failure = s->failure || !success;
1384
a16e1123
LP		 1385 if (s->control_command)
1386 exec_status_fill(&s->control_command->exec_status, pid, code, status);
1387
9e2f7c11 1388 log_debug("%s control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
034c6ed7 1389
a16e1123
LP		 1390 if (s->control_command && s->control_command->command_next && success) {
1391 log_debug("%s running next command for state %s", u->meta.id, socket_state_to_string(s->state));
034c6ed7 1392 socket_run_next(s, success);
acbb0225 1393 } else {
a16e1123
LP		 1394 s->control_command = NULL;
1395 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1396
034c6ed7
LP		 1397 /* No further commands for this step, so let's figure
1398 * out what to do next */
5cb5a6ff 1399
a16e1123 1400 log_debug("%s got final SIGCHLD for state %s", u->meta.id, socket_state_to_string(s->state));
acbb0225 1401
034c6ed7
LP		 1402 switch (s->state) {
1403
1404 case SOCKET_START_PRE:
1405 if (success)
acbb0225 1406 socket_enter_start_post(s);
034c6ed7 1407 else
80876c20 1408 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
034c6ed7
LP		 1409 break;
1410
1411 case SOCKET_START_POST:
1412 if (success)
e9af15c3 1413 socket_enter_listening(s);
034c6ed7
LP		 1414 else
1415 socket_enter_stop_pre(s, false);
1416 break;
1417
1418 case SOCKET_STOP_PRE:
1419 case SOCKET_STOP_PRE_SIGTERM:
1420 case SOCKET_STOP_PRE_SIGKILL:
1421 socket_enter_stop_post(s, success);
1422 break;
1423
1424 case SOCKET_STOP_POST:
80876c20
LP		 1425 case SOCKET_FINAL_SIGTERM:
1426 case SOCKET_FINAL_SIGKILL:
034c6ed7
LP		 1427 socket_enter_dead(s, success);
1428 break;
1429
1430 default:
1431 assert_not_reached("Uh, control process died at wrong time.");
1432 }
1433 }
1434}
5cb5a6ff 1435
acbb0225 1436static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
87f0e418 1437 Socket *s = SOCKET(u);
5cb5a6ff 1438
034c6ed7
LP		 1439 assert(s);
1440 assert(elapsed == 1);
acbb0225 1441 assert(w == &s->timer_watch);
034c6ed7
LP		 1442
1443 switch (s->state) {
1444
1445 case SOCKET_START_PRE:
9e2f7c11 1446 log_warning("%s starting timed out. Terminating.", u->meta.id);
80876c20
LP		 1447 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
1448
034c6ed7 1449 case SOCKET_START_POST:
9e2f7c11 1450 log_warning("%s starting timed out. Stopping.", u->meta.id);
034c6ed7
LP		 1451 socket_enter_stop_pre(s, false);
1452 break;
1453
1454 case SOCKET_STOP_PRE:
9e2f7c11 1455 log_warning("%s stopping timed out. Terminating.", u->meta.id);
034c6ed7
LP		 1456 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, false);
1457 break;
1458
1459 case SOCKET_STOP_PRE_SIGTERM:
9e2f7c11 1460 log_warning("%s stopping timed out. Killing.", u->meta.id);
034c6ed7
LP		 1461 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, false);
1462 break;
1463
1464 case SOCKET_STOP_PRE_SIGKILL:
9e2f7c11 1465 log_warning("%s still around after SIGKILL. Ignoring.", u->meta.id);
034c6ed7
LP		 1466 socket_enter_stop_post(s, false);
1467 break;
1468
1469 case SOCKET_STOP_POST:
9e2f7c11 1470 log_warning("%s stopping timed out (2). Terminating.", u->meta.id);
80876c20 1471 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
034c6ed7
LP		 1472 break;
1473
80876c20 1474 case SOCKET_FINAL_SIGTERM:
9e2f7c11 1475 log_warning("%s stopping timed out (2). Killing.", u->meta.id);
80876c20 1476 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, false);
034c6ed7
LP		 1477 break;
1478
80876c20 1479 case SOCKET_FINAL_SIGKILL:
18c78fb1 1480 log_warning("%s still around after SIGKILL (2). Entering maintenance mode.", u->meta.id);
034c6ed7
LP		 1481 socket_enter_dead(s, false);
1482 break;
1483
1484 default:
1485 assert_not_reached("Timeout at wrong time.");
1486 }
5cb5a6ff
LP		 1487}
1488
44d8db9e
LP		 1489int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
1490 int *rfds;
1491 unsigned rn_fds, k;
1492 SocketPort *p;
1493
1494 assert(s);
1495 assert(fds);
1496 assert(n_fds);
1497
1498 /* Called from the service code for requesting our fds */
1499
1500 rn_fds = 0;
1501 LIST_FOREACH(port, p, s->ports)
1502 if (p->fd >= 0)
1503 rn_fds++;
1504
1505 if (!(rfds = new(int, rn_fds)) < 0)
1506 return -ENOMEM;
1507
1508 k = 0;
1509 LIST_FOREACH(port, p, s->ports)
1510 if (p->fd >= 0)
1511 rfds[k++] = p->fd;
1512
1513 assert(k == rn_fds);
1514
1515 *fds = rfds;
1516 *n_fds = rn_fds;
1517
1518 return 0;
1519}
1520
ceee3d82
LP		 1521void socket_notify_service_dead(Socket *s) {
1522 assert(s);
1523
6cf6bbc2
LP		 1524 /* The service is dead. Dang!
1525 *
1526 * This is strictly for one-instance-for-all-connections
1527 * services. */
ceee3d82
LP		 1528
1529 if (s->state == SOCKET_RUNNING) {
9e2f7c11 1530 log_debug("%s got notified about service death.", s->meta.id);
ceee3d82
LP		 1531 socket_enter_listening(s);
1532 }
1533}
1534
6cf6bbc2
LP		 1535void socket_connection_unref(Socket *s) {
1536 assert(s);
1537
1538 /* The service is dead. Yay!
1539 *
1540 * This is strictly for one-onstance-per-connection
1541 * services. */
1542
1543 assert(s->n_connections > 0);
1544 s->n_connections--;
1545
1546 log_debug("%s: One connection closed, %u left.", s->meta.id, s->n_connections);
1547}
1548
a16e1123
LP		 1549static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
1550 [SOCKET_DEAD] = "dead",
1551 [SOCKET_START_PRE] = "start-pre",
1552 [SOCKET_START_POST] = "start-post",
1553 [SOCKET_LISTENING] = "listening",
1554 [SOCKET_RUNNING] = "running",
1555 [SOCKET_STOP_PRE] = "stop-pre",
1556 [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
1557 [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
1558 [SOCKET_STOP_POST] = "stop-post",
1559 [SOCKET_FINAL_SIGTERM] = "final-sigterm",
1560 [SOCKET_FINAL_SIGKILL] = "final-sigkill",
18c78fb1 1561 [SOCKET_MAINTENANCE] = "maintenance"
a16e1123
LP		 1562};
1563
1564DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
1565
1566static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
1567 [SOCKET_EXEC_START_PRE] = "StartPre",
1568 [SOCKET_EXEC_START_POST] = "StartPost",
1569 [SOCKET_EXEC_STOP_PRE] = "StopPre",
1570 [SOCKET_EXEC_STOP_POST] = "StopPost"
1571};
1572
1573DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
1574
87f0e418 1575const UnitVTable socket_vtable = {
5cb5a6ff
LP		 1576 .suffix = ".socket",
1577
034c6ed7
LP		 1578 .init = socket_init,
1579 .done = socket_done,
a16e1123
LP		 1580 .load = socket_load,
1581
1582 .coldplug = socket_coldplug,
034c6ed7 1583
5cb5a6ff
LP		 1584 .dump = socket_dump,
1585
542563ba
LP		 1586 .start = socket_start,
1587 .stop = socket_stop,
5cb5a6ff 1588
a16e1123
LP		 1589 .serialize = socket_serialize,
1590 .deserialize_item = socket_deserialize_item,
1591
5cb5a6ff 1592 .active_state = socket_active_state,
10a94420 1593 .sub_state_to_string = socket_sub_state_to_string,
5cb5a6ff 1594
6cf6bbc2
LP		 1595 .check_gc = socket_check_gc,
1596
9152c765 1597 .fd_event = socket_fd_event,
034c6ed7 1598 .sigchld_event = socket_sigchld_event,
4139c1b2
LP		 1599 .timer_event = socket_timer_event,
1600
1601 .bus_message_handler = bus_socket_message_handler
5cb5a6ff 1602};
Unnamed repository; edit this file 'description' to name the repository.