socket.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   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 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
  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
  31 #include "unit.h"
  32 #include "socket.h"
  33 #include "log.h"
  34 #include "load-dropin.h"
  35 #include "load-fragment.h"
  36 #include "strv.h"
  37 #include "unit-name.h"
  38 #include "dbus-socket.h"
  39
  40 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
  41         [SOCKET_DEAD] = UNIT_INACTIVE,
  42         [SOCKET_START_PRE] = UNIT_ACTIVATING,
  43         [SOCKET_START_POST] = UNIT_ACTIVATING,
  44         [SOCKET_LISTENING] = UNIT_ACTIVE,
  45         [SOCKET_RUNNING] = UNIT_ACTIVE,
  46         [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
  47         [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
  48         [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
  49         [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
  50         [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  51         [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  52         [SOCKET_MAINTAINANCE] = UNIT_INACTIVE,
  53 };
  54
  55 static const char* const state_string_table[_SOCKET_STATE_MAX] = {
  56         [SOCKET_DEAD] = "dead",
  57         [SOCKET_START_PRE] = "start-pre",
  58         [SOCKET_START_POST] = "start-post",
  59         [SOCKET_LISTENING] = "listening",
  60         [SOCKET_RUNNING] = "running",
  61         [SOCKET_STOP_PRE] = "stop-pre",
  62         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
  63         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
  64         [SOCKET_STOP_POST] = "stop-post",
  65         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
  66         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
  67         [SOCKET_MAINTAINANCE] = "maintainance"
  68 };
  69
  70 static void socket_unwatch_control_pid(Socket *s) {
  71         assert(s);
  72
  73         if (s->control_pid <= 0)
  74                 return;
  75
  76         unit_unwatch_pid(UNIT(s), s->control_pid);
  77         s->control_pid = 0;
  78 }
  79
  80 static void socket_done(Unit *u) {
  81         Socket *s = SOCKET(u);
  82         SocketPort *p;
  83
  84         assert(s);
  85
  86         while ((p = s->ports)) {
  87                 LIST_REMOVE(SocketPort, port, s->ports, p);
  88
  89                 if (p->fd >= 0)
  90                         close_nointr(p->fd);
  91                 free(p->path);
  92                 free(p);
  93         }
  94
  95         exec_context_done(&s->exec_context);
  96         exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
  97         s->control_command = NULL;
  98
  99         socket_unwatch_control_pid(s);
 100
 101         s->service = NULL;
 102
 103         free(s->bind_to_device);
 104         s->bind_to_device = NULL;
 105
 106         unit_unwatch_timer(u, &s->timer_watch);
 107 }
 108
 109 static void socket_init(Unit *u) {
 110         Socket *s = SOCKET(u);
 111
 112         assert(u);
 113         assert(u->meta.load_state == UNIT_STUB);
 114
 115         s->timer_watch.type = WATCH_INVALID;
 116         s->backlog = SOMAXCONN;
 117         s->timeout_usec = DEFAULT_TIMEOUT_USEC;
 118         s->directory_mode = 0755;
 119         s->socket_mode = 0666;
 120
 121         exec_context_init(&s->exec_context);
 122 }
 123
 124 static bool have_non_accept_socket(Socket *s) {
 125         SocketPort *p;
 126
 127         assert(s);
 128
 129         if (!s->accept)
 130                 return true;
 131
 132         LIST_FOREACH(port, p, s->ports)
 133                 if (!socket_address_can_accept(&p->address))
 134                         return true;
 135
 136         return false;
 137 }
 138
 139 static int socket_verify(Socket *s) {
 140         assert(s);
 141
 142         if (UNIT(s)->meta.load_state != UNIT_LOADED)
 143                 return 0;
 144
 145         if (!s->ports) {
 146                 log_error("%s lacks Listen setting. Refusing.", UNIT(s)->meta.id);
 147                 return -EINVAL;
 148         }
 149
 150         return 0;
 151 }
 152
 153 static int socket_load(Unit *u) {
 154         Socket *s = SOCKET(u);
 155         int r;
 156
 157         assert(u);
 158         assert(u->meta.load_state == UNIT_STUB);
 159
 160         if ((r = unit_load_fragment_and_dropin(u)) < 0)
 161                 return r;
 162
 163         /* This is a new unit? Then let's add in some extras */
 164         if (u->meta.load_state == UNIT_LOADED) {
 165
 166                 if (have_non_accept_socket(s)) {
 167                         if ((r = unit_load_related_unit(u, ".service", (Unit**) &s->service)))
 168                                 return r;
 169
 170                         if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service))) < 0)
 171                                 return r;
 172                 }
 173
 174                 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
 175                         return r;
 176
 177                 if ((r = unit_add_default_cgroup(u)) < 0)
 178                         return r;
 179         }
 180
 181         return socket_verify(s);
 182 }
 183
 184 static const char* listen_lookup(int type) {
 185
 186         if (type == SOCK_STREAM)
 187                 return "ListenStream";
 188         else if (type == SOCK_DGRAM)
 189                 return "ListenDatagram";
 190         else if (type == SOCK_SEQPACKET)
 191                 return "ListenSequentialPacket";
 192
 193         assert_not_reached("Unknown socket type");
 194         return NULL;
 195 }
 196
 197 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
 198
 199         static const char* const command_table[_SOCKET_EXEC_COMMAND_MAX] = {
 200                 [SOCKET_EXEC_START_PRE] = "StartPre",
 201                 [SOCKET_EXEC_START_POST] = "StartPost",
 202                 [SOCKET_EXEC_STOP_PRE] = "StopPre",
 203                 [SOCKET_EXEC_STOP_POST] = "StopPost"
 204         };
 205
 206         SocketExecCommand c;
 207         Socket *s = SOCKET(u);
 208         SocketPort *p;
 209         const char *prefix2;
 210         char *p2;
 211
 212         assert(s);
 213         assert(f);
 214
 215         p2 = strappend(prefix, "\t");
 216         prefix2 = p2 ? p2 : prefix;
 217
 218         fprintf(f,
 219                 "%sSocket State: %s\n"
 220                 "%sBindIPv6Only: %s\n"
 221                 "%sBacklog: %u\n"
 222                 "%sKillMode: %s\n"
 223                 "%sSocketMode: %04o\n"
 224                 "%sDirectoryMode: %04o\n",
 225                 prefix, state_string_table[s->state],
 226                 prefix, yes_no(s->bind_ipv6_only),
 227                 prefix, s->backlog,
 228                 prefix, kill_mode_to_string(s->kill_mode),
 229                 prefix, s->socket_mode,
 230                 prefix, s->directory_mode);
 231
 232         if (s->control_pid > 0)
 233                 fprintf(f,
 234                         "%sControl PID: %llu\n",
 235                         prefix, (unsigned long long) s->control_pid);
 236
 237         if (s->bind_to_device)
 238                 fprintf(f,
 239                         "%sBindToDevice: %s\n",
 240                         prefix, s->bind_to_device);
 241
 242         if (s->accept)
 243                 fprintf(f,
 244                         "%sAccepted: %u\n",
 245                         prefix, s->n_accepted);
 246
 247         LIST_FOREACH(port, p, s->ports) {
 248
 249                 if (p->type == SOCKET_SOCKET) {
 250                         const char *t;
 251                         int r;
 252                         char *k;
 253
 254                         if ((r = socket_address_print(&p->address, &k)) < 0)
 255                                 t = strerror(-r);
 256                         else
 257                                 t = k;
 258
 259                         fprintf(f, "%s%s: %s\n", prefix, listen_lookup(p->address.type), k);
 260                         free(k);
 261                 } else
 262                         fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
 263         }
 264
 265         exec_context_dump(&s->exec_context, f, prefix);
 266
 267         for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
 268                 if (!s->exec_command[c])
 269                         continue;
 270
 271                 fprintf(f, "%s→ %s:\n",
 272                         prefix, command_table[c]);
 273
 274                 exec_command_dump_list(s->exec_command[c], f, prefix2);
 275         }
 276
 277         free(p2);
 278 }
 279
 280 static int instance_from_socket(int fd, unsigned nr, char **instance) {
 281         socklen_t l;
 282         char *r;
 283         union {
 284                 struct sockaddr sa;
 285                 struct sockaddr_un un;
 286                 struct sockaddr_in in;
 287                 struct sockaddr_in6 in6;
 288                 struct sockaddr_storage storage;
 289         } local, remote;
 290
 291         assert(fd >= 0);
 292         assert(instance);
 293
 294         l = sizeof(local);
 295         if (getsockname(fd, &local.sa, &l) < 0)
 296                 return -errno;
 297
 298         l = sizeof(remote);
 299         if (getpeername(fd, &remote.sa, &l) < 0)
 300                 return -errno;
 301
 302         switch (local.sa.sa_family) {
 303
 304         case AF_INET: {
 305                 uint32_t
 306                         a = ntohl(local.in.sin_addr.s_addr),
 307                         b = ntohl(remote.in.sin_addr.s_addr);
 308
 309                 if (asprintf(&r,
 310                              "%u-%u.%u.%u.%u-%u-%u.%u.%u.%u-%u",
 311                              nr,
 312                              a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
 313                              ntohs(local.in.sin_port),
 314                              b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
 315                              ntohs(remote.in.sin_port)) < 0)
 316                         return -ENOMEM;
 317
 318                 break;
 319         }
 320
 321         case AF_INET6: {
 322                 char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
 323
 324                 if (asprintf(&r,
 325                              "%u-%s-%u-%s-%u",
 326                              nr,
 327                              inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
 328                              ntohs(local.in6.sin6_port),
 329                              inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
 330                              ntohs(remote.in6.sin6_port)) < 0)
 331                         return -ENOMEM;
 332
 333                 break;
 334         }
 335
 336         case AF_UNIX: {
 337                 struct ucred ucred;
 338
 339                 l = sizeof(ucred);
 340                 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
 341                         return -errno;
 342
 343                 if (asprintf(&r,
 344                              "%u-%llu-%llu",
 345                              nr,
 346                              (unsigned long long) ucred.pid,
 347                              (unsigned long long) ucred.uid) < 0)
 348                         return -ENOMEM;
 349
 350                 break;
 351         }
 352
 353         default:
 354                 assert_not_reached("Unhandled socket type.");
 355         }
 356
 357         *instance = r;
 358         return 0;
 359 }
 360
 361 static void socket_close_fds(Socket *s) {
 362         SocketPort *p;
 363
 364         assert(s);
 365
 366         LIST_FOREACH(port, p, s->ports) {
 367                 if (p->fd < 0)
 368                         continue;
 369
 370                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
 371                 assert_se(close_nointr(p->fd) >= 0);
 372
 373                 p->fd = -1;
 374         }
 375 }
 376
 377 static int socket_open_fds(Socket *s) {
 378         SocketPort *p;
 379         int r;
 380
 381         assert(s);
 382
 383         LIST_FOREACH(port, p, s->ports) {
 384
 385                 if (p->fd >= 0)
 386                         continue;
 387
 388                 if (p->type == SOCKET_SOCKET) {
 389
 390                         if ((r = socket_address_listen(
 391                                              &p->address,
 392                                              s->backlog,
 393                                              s->bind_ipv6_only,
 394                                              s->bind_to_device,
 395                                              s->directory_mode,
 396                                              s->socket_mode,
 397                                              &p->fd)) < 0)
 398                                 goto rollback;
 399
 400                 } else {
 401                         struct stat st;
 402                         assert(p->type == SOCKET_FIFO);
 403
 404                         mkdir_parents(p->path, s->directory_mode);
 405
 406                         if (mkfifo(p->path, s->socket_mode) < 0 && errno != EEXIST) {
 407                                 r = -errno;
 408                                 goto rollback;
 409                         }
 410
 411                         if ((p->fd = open(p->path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 412                                 r = -errno;
 413                                 goto rollback;
 414                         }
 415
 416                         if (fstat(p->fd, &st) < 0) {
 417                                 r = -errno;
 418                                 goto rollback;
 419                         }
 420
 421                         /* FIXME verify user, access mode */
 422
 423                         if (!S_ISFIFO(st.st_mode)) {
 424                                 r = -EEXIST;
 425                                 goto rollback;
 426                         }
 427                 }
 428         }
 429
 430         return 0;
 431
 432 rollback:
 433         socket_close_fds(s);
 434         return r;
 435 }
 436
 437 static void socket_unwatch_fds(Socket *s) {
 438         SocketPort *p;
 439
 440         assert(s);
 441
 442         LIST_FOREACH(port, p, s->ports) {
 443                 if (p->fd < 0)
 444                         continue;
 445
 446                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
 447         }
 448 }
 449
 450 static int socket_watch_fds(Socket *s) {
 451         SocketPort *p;
 452         int r;
 453
 454         assert(s);
 455
 456         LIST_FOREACH(port, p, s->ports) {
 457                 if (p->fd < 0)
 458                         continue;
 459
 460                 p->fd_watch.data.socket_accept =
 461                         s->accept &&
 462                         socket_address_can_accept(&p->address);
 463
 464                 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
 465                         goto fail;
 466         }
 467
 468         return 0;
 469
 470 fail:
 471         socket_unwatch_fds(s);
 472         return r;
 473 }
 474
 475 static void socket_set_state(Socket *s, SocketState state) {
 476         SocketState old_state;
 477         assert(s);
 478
 479         old_state = s->state;
 480         s->state = state;
 481
 482         if (state != SOCKET_START_PRE &&
 483             state != SOCKET_START_POST &&
 484             state != SOCKET_STOP_PRE &&
 485             state != SOCKET_STOP_PRE_SIGTERM &&
 486             state != SOCKET_STOP_PRE_SIGKILL &&
 487             state != SOCKET_STOP_POST &&
 488             state != SOCKET_FINAL_SIGTERM &&
 489             state != SOCKET_FINAL_SIGKILL) {
 490                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
 491                 socket_unwatch_control_pid(s);
 492                 s->control_command = NULL;
 493         }
 494
 495         if (state != SOCKET_START_POST &&
 496             state != SOCKET_LISTENING &&
 497             state != SOCKET_RUNNING &&
 498             state != SOCKET_STOP_PRE &&
 499             state != SOCKET_STOP_PRE_SIGTERM &&
 500             state != SOCKET_STOP_PRE_SIGKILL)
 501                 socket_close_fds(s);
 502
 503         if (state != SOCKET_LISTENING)
 504                 socket_unwatch_fds(s);
 505
 506         if (state != old_state)
 507                 log_debug("%s changed %s → %s", s->meta.id, state_string_table[old_state], state_string_table[state]);
 508
 509         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]);
 510 }
 511
 512 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
 513         pid_t pid;
 514         int r;
 515         char **argv;
 516
 517         assert(s);
 518         assert(c);
 519         assert(_pid);
 520
 521         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
 522                 goto fail;
 523
 524         if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
 525                 r = -ENOMEM;
 526                 goto fail;
 527         }
 528
 529         r = exec_spawn(c,
 530                        argv,
 531                        &s->exec_context,
 532                        NULL, 0,
 533                        true,
 534                        true,
 535                        UNIT(s)->meta.manager->confirm_spawn,
 536                        UNIT(s)->meta.cgroup_bondings,
 537                        &pid);
 538
 539         strv_free(argv);
 540         if (r < 0)
 541                 goto fail;
 542
 543         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
 544                 /* FIXME: we need to do something here */
 545                 goto fail;
 546
 547         *_pid = pid;
 548
 549         return 0;
 550
 551 fail:
 552         unit_unwatch_timer(UNIT(s), &s->timer_watch);
 553
 554         return r;
 555 }
 556
 557 static void socket_enter_dead(Socket *s, bool success) {
 558         assert(s);
 559
 560         if (!success)
 561                 s->failure = true;
 562
 563         socket_set_state(s, s->failure ? SOCKET_MAINTAINANCE : SOCKET_DEAD);
 564 }
 565
 566 static void socket_enter_signal(Socket *s, SocketState state, bool success);
 567
 568 static void socket_enter_stop_post(Socket *s, bool success) {
 569         int r;
 570         assert(s);
 571
 572         if (!success)
 573                 s->failure = true;
 574
 575         socket_unwatch_control_pid(s);
 576
 577         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
 578                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
 579                         goto fail;
 580
 581                 socket_set_state(s, SOCKET_STOP_POST);
 582         } else
 583                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, true);
 584
 585         return;
 586
 587 fail:
 588         log_warning("%s failed to run stop-post executable: %s", s->meta.id, strerror(-r));
 589         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 590 }
 591
 592 static void socket_enter_signal(Socket *s, SocketState state, bool success) {
 593         int r;
 594         bool sent = false;
 595
 596         assert(s);
 597
 598         if (!success)
 599                 s->failure = true;
 600
 601         if (s->kill_mode != KILL_NONE) {
 602                 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? SIGTERM : SIGKILL;
 603
 604                 if (s->kill_mode == KILL_CONTROL_GROUP) {
 605
 606                         if ((r = cgroup_bonding_kill_list(UNIT(s)->meta.cgroup_bondings, sig)) < 0) {
 607                                 if (r != -EAGAIN && r != -ESRCH)
 608                                         goto fail;
 609                         } else
 610                                 sent = true;
 611                 }
 612
 613                 if (!sent && s->control_pid > 0)
 614                         if (kill(s->kill_mode == KILL_PROCESS ? s->control_pid : -s->control_pid, sig) < 0 && errno != ESRCH) {
 615                                 r = -errno;
 616                                 goto fail;
 617                         }
 618         }
 619
 620         if (sent) {
 621                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
 622                         goto fail;
 623
 624                 socket_set_state(s, state);
 625         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
 626                 socket_enter_stop_post(s, true);
 627         else
 628                 socket_enter_dead(s, true);
 629
 630         return;
 631
 632 fail:
 633         log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r));
 634
 635         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
 636                 socket_enter_stop_post(s, false);
 637         else
 638                 socket_enter_dead(s, false);
 639 }
 640
 641 static void socket_enter_stop_pre(Socket *s, bool success) {
 642         int r;
 643         assert(s);
 644
 645         if (!success)
 646                 s->failure = true;
 647
 648         socket_unwatch_control_pid(s);
 649
 650         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
 651                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
 652                         goto fail;
 653
 654                 socket_set_state(s, SOCKET_STOP_PRE);
 655         } else
 656                 socket_enter_stop_post(s, true);
 657
 658         return;
 659
 660 fail:
 661         log_warning("%s failed to run stop-pre executable: %s", s->meta.id, strerror(-r));
 662         socket_enter_stop_post(s, false);
 663 }
 664
 665 static void socket_enter_listening(Socket *s) {
 666         int r;
 667         assert(s);
 668
 669         if ((r = socket_watch_fds(s)) < 0) {
 670                 log_warning("%s failed to watch sockets: %s", s->meta.id, strerror(-r));
 671                 goto fail;
 672         }
 673
 674         socket_set_state(s, SOCKET_LISTENING);
 675         return;
 676
 677 fail:
 678         socket_enter_stop_pre(s, false);
 679 }
 680
 681 static void socket_enter_start_post(Socket *s) {
 682         int r;
 683         assert(s);
 684
 685         if ((r = socket_open_fds(s)) < 0) {
 686                 log_warning("%s failed to listen on sockets: %s", s->meta.id, strerror(-r));
 687                 goto fail;
 688         }
 689
 690         socket_unwatch_control_pid(s);
 691
 692         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
 693                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) {
 694                         log_warning("%s failed to run start-post executable: %s", s->meta.id, strerror(-r));
 695                         goto fail;
 696                 }
 697
 698                 socket_set_state(s, SOCKET_START_POST);
 699         } else
 700                 socket_enter_listening(s);
 701
 702         return;
 703
 704 fail:
 705         socket_enter_stop_pre(s, false);
 706 }
 707
 708 static void socket_enter_start_pre(Socket *s) {
 709         int r;
 710         assert(s);
 711
 712         socket_unwatch_control_pid(s);
 713
 714         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
 715                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
 716                         goto fail;
 717
 718                 socket_set_state(s, SOCKET_START_PRE);
 719         } else
 720                 socket_enter_start_post(s);
 721
 722         return;
 723
 724 fail:
 725         log_warning("%s failed to run start-pre exectuable: %s", s->meta.id, strerror(-r));
 726         socket_enter_dead(s, false);
 727 }
 728
 729 static void socket_enter_running(Socket *s, int cfd) {
 730         int r;
 731
 732         assert(s);
 733
 734         if (cfd < 0) {
 735                 if ((r = manager_add_job(UNIT(s)->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, NULL)) < 0)
 736                         goto fail;
 737
 738                 socket_set_state(s, SOCKET_RUNNING);
 739         } else {
 740                 Unit *u;
 741                 char *prefix, *instance, *name;
 742
 743                 if ((r = instance_from_socket(cfd, s->n_accepted++, &instance)))
 744                         goto fail;
 745
 746                 if (!(prefix = unit_name_to_prefix(UNIT(s)->meta.id))) {
 747                         free(instance);
 748                         r = -ENOMEM;
 749                         goto fail;
 750                 }
 751
 752                 name = unit_name_build(prefix, instance, ".service");
 753                 free(prefix);
 754                 free(instance);
 755
 756                 if (!name)
 757                         r = -ENOMEM;
 758
 759                 r = manager_load_unit(UNIT(s)->meta.manager, name, NULL, &u);
 760                 free(name);
 761
 762                 if (r < 0)
 763                         goto fail;
 764
 765                 if ((r = service_set_socket_fd(SERVICE(u), cfd) < 0))
 766                         goto fail;
 767
 768                 cfd = -1;
 769
 770                 if ((r = manager_add_job(u->meta.manager, JOB_START, u, JOB_REPLACE, true, NULL)) < 0)
 771                         goto fail;
 772         }
 773
 774         return;
 775
 776 fail:
 777         log_warning("%s failed to queue socket startup job: %s", s->meta.id, strerror(-r));
 778         socket_enter_stop_pre(s, false);
 779
 780         if (cfd >= 0)
 781                 close_nointr_nofail(cfd);
 782 }
 783
 784 static void socket_run_next(Socket *s, bool success) {
 785         int r;
 786
 787         assert(s);
 788         assert(s->control_command);
 789         assert(s->control_command->command_next);
 790
 791         if (!success)
 792                 s->failure = true;
 793
 794         socket_unwatch_control_pid(s);
 795
 796         s->control_command = s->control_command->command_next;
 797
 798         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
 799                 goto fail;
 800
 801         return;
 802
 803 fail:
 804         log_warning("%s failed to run spawn next executable: %s", s->meta.id, strerror(-r));
 805
 806         if (s->state == SOCKET_START_POST)
 807                 socket_enter_stop_pre(s, false);
 808         else if (s->state == SOCKET_STOP_POST)
 809                 socket_enter_dead(s, false);
 810         else
 811                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 812 }
 813
 814 static int socket_start(Unit *u) {
 815         Socket *s = SOCKET(u);
 816
 817         assert(s);
 818
 819         /* We cannot fulfill this request right now, try again later
 820          * please! */
 821         if (s->state == SOCKET_STOP_PRE ||
 822             s->state == SOCKET_STOP_PRE_SIGKILL ||
 823             s->state == SOCKET_STOP_PRE_SIGTERM ||
 824             s->state == SOCKET_STOP_POST ||
 825             s->state == SOCKET_FINAL_SIGTERM ||
 826             s->state == SOCKET_FINAL_SIGKILL)
 827                 return -EAGAIN;
 828
 829         if (s->state == SOCKET_START_PRE ||
 830             s->state == SOCKET_START_POST)
 831                 return 0;
 832
 833         /* Cannot run this without the service being around */
 834         if (s->service) {
 835                 if (s->service->meta.load_state != UNIT_LOADED)
 836                         return -ENOENT;
 837
 838                 /* If the service is alredy actvie we cannot start the
 839                  * socket */
 840                 if (s->service->state != SERVICE_DEAD &&
 841                     s->service->state != SERVICE_MAINTAINANCE &&
 842                     s->service->state != SERVICE_AUTO_RESTART)
 843                         return -EBUSY;
 844         }
 845
 846         assert(s->state == SOCKET_DEAD || s->state == SOCKET_MAINTAINANCE);
 847
 848         s->failure = false;
 849         socket_enter_start_pre(s);
 850         return 0;
 851 }
 852
 853 static int socket_stop(Unit *u) {
 854         Socket *s = SOCKET(u);
 855
 856         assert(s);
 857
 858         /* We cannot fulfill this request right now, try again later
 859          * please! */
 860         if (s->state == SOCKET_START_PRE ||
 861             s->state == SOCKET_START_POST)
 862                 return -EAGAIN;
 863
 864         /* Already on it */
 865         if (s->state == SOCKET_STOP_PRE ||
 866             s->state == SOCKET_STOP_PRE_SIGTERM ||
 867             s->state == SOCKET_STOP_PRE_SIGKILL ||
 868             s->state == SOCKET_STOP_POST ||
 869             s->state == SOCKET_FINAL_SIGTERM ||
 870             s->state == SOCKET_FINAL_SIGTERM)
 871                 return 0;
 872
 873         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
 874
 875         socket_enter_stop_pre(s, true);
 876         return 0;
 877 }
 878
 879 static UnitActiveState socket_active_state(Unit *u) {
 880         assert(u);
 881
 882         return state_translation_table[SOCKET(u)->state];
 883 }
 884
 885 static const char *socket_sub_state_to_string(Unit *u) {
 886         assert(u);
 887
 888         return state_string_table[SOCKET(u)->state];
 889 }
 890
 891 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
 892         Socket *s = SOCKET(u);
 893         int cfd = -1;
 894
 895         assert(s);
 896         assert(fd >= 0);
 897
 898         log_debug("Incoming traffic on %s", u->meta.id);
 899
 900         if (events != EPOLLIN) {
 901                 log_error("Got invalid poll event on socket.");
 902                 goto fail;
 903         }
 904
 905         if (w->data.socket_accept) {
 906                 for (;;) {
 907
 908                         if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
 909
 910                                 if (errno == EINTR)
 911                                         continue;
 912
 913                                 log_error("Failed to accept socket: %m");
 914                                 goto fail;
 915                         }
 916
 917                         break;
 918                 }
 919         }
 920
 921         socket_enter_running(s, cfd);
 922         return;
 923
 924 fail:
 925         socket_enter_stop_pre(s, false);
 926 }
 927
 928 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 929         Socket *s = SOCKET(u);
 930         bool success;
 931
 932         assert(s);
 933         assert(pid >= 0);
 934
 935         success = code == CLD_EXITED && status == 0;
 936         s->failure = s->failure || !success;
 937
 938         assert(s->control_pid == pid);
 939         assert(s->control_command);
 940
 941         exec_status_fill(&s->control_command->exec_status, pid, code, status);
 942         s->control_pid = 0;
 943
 944         log_debug("%s control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
 945
 946         if (s->control_command->command_next && success) {
 947                 log_debug("%s running next command for state %s", u->meta.id, state_string_table[s->state]);
 948                 socket_run_next(s, success);
 949         } else {
 950                 /* No further commands for this step, so let's figure
 951                  * out what to do next */
 952
 953                 log_debug("%s got final SIGCHLD for state %s", u->meta.id, state_string_table[s->state]);
 954
 955                 switch (s->state) {
 956
 957                 case SOCKET_START_PRE:
 958                         if (success)
 959                                 socket_enter_start_post(s);
 960                         else
 961                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 962                         break;
 963
 964                 case SOCKET_START_POST:
 965                         if (success)
 966                                 socket_enter_listening(s);
 967                         else
 968                                 socket_enter_stop_pre(s, false);
 969                         break;
 970
 971                 case SOCKET_STOP_PRE:
 972                 case SOCKET_STOP_PRE_SIGTERM:
 973                 case SOCKET_STOP_PRE_SIGKILL:
 974                         socket_enter_stop_post(s, success);
 975                         break;
 976
 977                 case SOCKET_STOP_POST:
 978                 case SOCKET_FINAL_SIGTERM:
 979                 case SOCKET_FINAL_SIGKILL:
 980                         socket_enter_dead(s, success);
 981                         break;
 982
 983                 default:
 984                         assert_not_reached("Uh, control process died at wrong time.");
 985                 }
 986         }
 987 }
 988
 989 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
 990         Socket *s = SOCKET(u);
 991
 992         assert(s);
 993         assert(elapsed == 1);
 994         assert(w == &s->timer_watch);
 995
 996         switch (s->state) {
 997
 998         case SOCKET_START_PRE:
 999                 log_warning("%s starting timed out. Terminating.", u->meta.id);
1000                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
1001
1002         case SOCKET_START_POST:
1003                 log_warning("%s starting timed out. Stopping.", u->meta.id);
1004                 socket_enter_stop_pre(s, false);
1005                 break;
1006
1007         case SOCKET_STOP_PRE:
1008                 log_warning("%s stopping timed out. Terminating.", u->meta.id);
1009                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, false);
1010                 break;
1011
1012         case SOCKET_STOP_PRE_SIGTERM:
1013                 log_warning("%s stopping timed out. Killing.", u->meta.id);
1014                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, false);
1015                 break;
1016
1017         case SOCKET_STOP_PRE_SIGKILL:
1018                 log_warning("%s still around after SIGKILL. Ignoring.", u->meta.id);
1019                 socket_enter_stop_post(s, false);
1020                 break;
1021
1022         case SOCKET_STOP_POST:
1023                 log_warning("%s stopping timed out (2). Terminating.", u->meta.id);
1024                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
1025                 break;
1026
1027         case SOCKET_FINAL_SIGTERM:
1028                 log_warning("%s stopping timed out (2). Killing.", u->meta.id);
1029                 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, false);
1030                 break;
1031
1032         case SOCKET_FINAL_SIGKILL:
1033                 log_warning("%s still around after SIGKILL (2). Entering maintainance mode.", u->meta.id);
1034                 socket_enter_dead(s, false);
1035                 break;
1036
1037         default:
1038                 assert_not_reached("Timeout at wrong time.");
1039         }
1040 }
1041
1042 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
1043         int *rfds;
1044         unsigned rn_fds, k;
1045         SocketPort *p;
1046
1047         assert(s);
1048         assert(fds);
1049         assert(n_fds);
1050
1051         /* Called from the service code for requesting our fds */
1052
1053         rn_fds = 0;
1054         LIST_FOREACH(port, p, s->ports)
1055                 if (p->fd >= 0)
1056                         rn_fds++;
1057
1058         if (!(rfds = new(int, rn_fds)) < 0)
1059                 return -ENOMEM;
1060
1061         k = 0;
1062         LIST_FOREACH(port, p, s->ports)
1063                 if (p->fd >= 0)
1064                         rfds[k++] = p->fd;
1065
1066         assert(k == rn_fds);
1067
1068         *fds = rfds;
1069         *n_fds = rn_fds;
1070
1071         return 0;
1072 }
1073
1074 void socket_notify_service_dead(Socket *s) {
1075         assert(s);
1076
1077         /* The service is dead. Dang. */
1078
1079         if (s->state == SOCKET_RUNNING) {
1080                 log_debug("%s got notified about service death.", s->meta.id);
1081                 socket_enter_listening(s);
1082         }
1083 }
1084
1085 const UnitVTable socket_vtable = {
1086         .suffix = ".socket",
1087
1088         .init = socket_init,
1089         .load = socket_load,
1090         .done = socket_done,
1091
1092         .dump = socket_dump,
1093
1094         .start = socket_start,
1095         .stop = socket_stop,
1096
1097         .active_state = socket_active_state,
1098         .sub_state_to_string = socket_sub_state_to_string,
1099
1100         .fd_event = socket_fd_event,
1101         .sigchld_event = socket_sigchld_event,
1102         .timer_event = socket_timer_event,
1103
1104         .bus_message_handler = bus_socket_message_handler
1105 };