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