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