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