src/core/socket.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   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 Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 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   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser 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 #include <mqueue.h>
  31 #ifdef HAVE_ATTR_XATTR_H
  32 #include <attr/xattr.h>
  33 #endif
  34
  35 #include "unit.h"
  36 #include "socket.h"
  37 #include "netinet/tcp.h"
  38 #include "log.h"
  39 #include "load-dropin.h"
  40 #include "load-fragment.h"
  41 #include "strv.h"
  42 #include "mkdir.h"
  43 #include "path-util.h"
  44 #include "unit-name.h"
  45 #include "unit-printf.h"
  46 #include "dbus-socket.h"
  47 #include "missing.h"
  48 #include "special.h"
  49 #include "bus-errors.h"
  50 #include "label.h"
  51 #include "exit-status.h"
  52 #include "def.h"
  53
  54 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
  55         [SOCKET_DEAD] = UNIT_INACTIVE,
  56         [SOCKET_START_PRE] = UNIT_ACTIVATING,
  57         [SOCKET_START_POST] = UNIT_ACTIVATING,
  58         [SOCKET_LISTENING] = UNIT_ACTIVE,
  59         [SOCKET_RUNNING] = UNIT_ACTIVE,
  60         [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
  61         [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
  62         [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
  63         [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
  64         [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  65         [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  66         [SOCKET_FAILED] = UNIT_FAILED
  67 };
  68
  69 static void socket_init(Unit *u) {
  70         Socket *s = SOCKET(u);
  71
  72         assert(u);
  73         assert(u->load_state == UNIT_STUB);
  74
  75         s->backlog = SOMAXCONN;
  76         s->timeout_usec = DEFAULT_TIMEOUT_USEC;
  77         s->directory_mode = 0755;
  78         s->socket_mode = 0666;
  79
  80         s->max_connections = 64;
  81
  82         s->priority = -1;
  83         s->ip_tos = -1;
  84         s->ip_ttl = -1;
  85         s->mark = -1;
  86
  87         exec_context_init(&s->exec_context);
  88         s->exec_context.std_output = u->manager->default_std_output;
  89         s->exec_context.std_error = u->manager->default_std_error;
  90         kill_context_init(&s->kill_context);
  91
  92         s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
  93 }
  94
  95 static void socket_unwatch_control_pid(Socket *s) {
  96         assert(s);
  97
  98         if (s->control_pid <= 0)
  99                 return;
 100
 101         unit_unwatch_pid(UNIT(s), s->control_pid);
 102         s->control_pid = 0;
 103 }
 104
 105 void socket_free_ports(Socket *s) {
 106         SocketPort *p;
 107
 108         assert(s);
 109
 110         while ((p = s->ports)) {
 111                 LIST_REMOVE(SocketPort, port, s->ports, p);
 112
 113                 if (p->fd >= 0) {
 114                         unit_unwatch_fd(UNIT(s), &p->fd_watch);
 115                         close_nointr_nofail(p->fd);
 116                 }
 117
 118                 free(p->path);
 119                 free(p);
 120         }
 121 }
 122
 123 static void socket_done(Unit *u) {
 124         Socket *s = SOCKET(u);
 125
 126         assert(s);
 127
 128         socket_free_ports(s);
 129
 130         exec_context_done(&s->exec_context);
 131         exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
 132         s->control_command = NULL;
 133
 134         socket_unwatch_control_pid(s);
 135
 136         unit_ref_unset(&s->service);
 137
 138         free(s->tcp_congestion);
 139         s->tcp_congestion = NULL;
 140
 141         free(s->bind_to_device);
 142         s->bind_to_device = NULL;
 143
 144         free(s->smack);
 145         free(s->smack_ip_in);
 146         free(s->smack_ip_out);
 147
 148         unit_unwatch_timer(u, &s->timer_watch);
 149 }
 150
 151 static int socket_instantiate_service(Socket *s) {
 152         char *prefix, *name;
 153         int r;
 154         Unit *u;
 155
 156         assert(s);
 157
 158         /* This fills in s->service if it isn't filled in yet. For
 159          * Accept=yes sockets we create the next connection service
 160          * here. For Accept=no this is mostly a NOP since the service
 161          * is figured out at load time anyway. */
 162
 163         if (UNIT_DEREF(s->service))
 164                 return 0;
 165
 166         assert(s->accept);
 167
 168         if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
 169                 return -ENOMEM;
 170
 171         r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
 172         free(prefix);
 173
 174         if (r < 0)
 175                 return -ENOMEM;
 176
 177         r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
 178         free(name);
 179
 180         if (r < 0)
 181                 return r;
 182
 183 #ifdef HAVE_SYSV_COMPAT
 184         if (SERVICE(u)->is_sysv) {
 185                 log_error("Using SysV services for socket activation is not supported. Refusing.");
 186                 return -ENOENT;
 187         }
 188 #endif
 189
 190         u->no_gc = true;
 191         unit_ref_set(&s->service, u);
 192
 193         return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
 194 }
 195
 196 static bool have_non_accept_socket(Socket *s) {
 197         SocketPort *p;
 198
 199         assert(s);
 200
 201         if (!s->accept)
 202                 return true;
 203
 204         LIST_FOREACH(port, p, s->ports) {
 205
 206                 if (p->type != SOCKET_SOCKET)
 207                         return true;
 208
 209                 if (!socket_address_can_accept(&p->address))
 210                         return true;
 211         }
 212
 213         return false;
 214 }
 215
 216 static int socket_verify(Socket *s) {
 217         assert(s);
 218
 219         if (UNIT(s)->load_state != UNIT_LOADED)
 220                 return 0;
 221
 222         if (!s->ports) {
 223                 log_error_unit(UNIT(s)->id,
 224                                "%s lacks Listen setting. Refusing.", UNIT(s)->id);
 225                 return -EINVAL;
 226         }
 227
 228         if (s->accept && have_non_accept_socket(s)) {
 229                 log_error_unit(UNIT(s)->id,
 230                                "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
 231                                UNIT(s)->id);
 232                 return -EINVAL;
 233         }
 234
 235         if (s->accept && s->max_connections <= 0) {
 236                 log_error_unit(UNIT(s)->id,
 237                                "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
 238                 return -EINVAL;
 239         }
 240
 241         if (s->accept && UNIT_DEREF(s->service)) {
 242                 log_error_unit(UNIT(s)->id,
 243                                "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
 244                                UNIT(s)->id);
 245                 return -EINVAL;
 246         }
 247
 248         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 249                 log_error_unit(UNIT(s)->id,
 250                                "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
 251                                UNIT(s)->id);
 252                 return -EINVAL;
 253         }
 254
 255         return 0;
 256 }
 257
 258 static bool socket_needs_mount(Socket *s, const char *prefix) {
 259         SocketPort *p;
 260
 261         assert(s);
 262
 263         LIST_FOREACH(port, p, s->ports) {
 264
 265                 if (p->type == SOCKET_SOCKET) {
 266                         if (socket_address_needs_mount(&p->address, prefix))
 267                                 return true;
 268                 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
 269                         if (path_startswith(p->path, prefix))
 270                                 return true;
 271                 }
 272         }
 273
 274         return false;
 275 }
 276
 277 int socket_add_one_mount_link(Socket *s, Mount *m) {
 278         int r;
 279
 280         assert(s);
 281         assert(m);
 282
 283         if (UNIT(s)->load_state != UNIT_LOADED ||
 284             UNIT(m)->load_state != UNIT_LOADED)
 285                 return 0;
 286
 287         if (!socket_needs_mount(s, m->where))
 288                 return 0;
 289
 290         r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
 291         if (r < 0)
 292                 return r;
 293
 294         return 0;
 295 }
 296
 297 static int socket_add_mount_links(Socket *s) {
 298         Unit *other;
 299         int r;
 300
 301         assert(s);
 302
 303         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
 304                 r = socket_add_one_mount_link(s, MOUNT(other));
 305                 if (r < 0)
 306                         return r;
 307         }
 308
 309         return 0;
 310 }
 311
 312 static int socket_add_device_link(Socket *s) {
 313         char *t;
 314         int r;
 315
 316         assert(s);
 317
 318         if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
 319                 return 0;
 320
 321         if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
 322                 return -ENOMEM;
 323
 324         r = unit_add_node_link(UNIT(s), t, false);
 325         free(t);
 326
 327         return r;
 328 }
 329
 330 static int socket_add_default_dependencies(Socket *s) {
 331         int r;
 332         assert(s);
 333
 334         if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
 335                 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
 336                         return r;
 337
 338                 if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
 339                         return r;
 340         }
 341
 342         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
 343 }
 344
 345 static bool socket_has_exec(Socket *s) {
 346         unsigned i;
 347         assert(s);
 348
 349         for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
 350                 if (s->exec_command[i])
 351                         return true;
 352
 353         return false;
 354 }
 355
 356 static int socket_load(Unit *u) {
 357         Socket *s = SOCKET(u);
 358         int r;
 359
 360         assert(u);
 361         assert(u->load_state == UNIT_STUB);
 362
 363         if ((r = unit_load_fragment_and_dropin(u)) < 0)
 364                 return r;
 365
 366         /* This is a new unit? Then let's add in some extras */
 367         if (u->load_state == UNIT_LOADED) {
 368
 369                 if (have_non_accept_socket(s)) {
 370
 371                         if (!UNIT_DEREF(s->service)) {
 372                                 Unit *x;
 373
 374                                 r = unit_load_related_unit(u, ".service", &x);
 375                                 if (r < 0)
 376                                         return r;
 377
 378                                 unit_ref_set(&s->service, x);
 379                         }
 380
 381                         r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
 382                         if (r < 0)
 383                                 return r;
 384                 }
 385
 386                 if ((r = socket_add_mount_links(s)) < 0)
 387                         return r;
 388
 389                 if ((r = socket_add_device_link(s)) < 0)
 390                         return r;
 391
 392                 if (socket_has_exec(s))
 393                         if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
 394                                 return r;
 395
 396                 if ((r = unit_add_default_cgroups(u)) < 0)
 397                         return r;
 398
 399                 if (UNIT(s)->default_dependencies)
 400                         if ((r = socket_add_default_dependencies(s)) < 0)
 401                                 return r;
 402
 403                 r = unit_exec_context_defaults(u, &s->exec_context);
 404                 if (r < 0)
 405                         return r;
 406         }
 407
 408         return socket_verify(s);
 409 }
 410
 411 static const char* listen_lookup(int family, int type) {
 412
 413         if (family == AF_NETLINK)
 414                 return "ListenNetlink";
 415
 416         if (type == SOCK_STREAM)
 417                 return "ListenStream";
 418         else if (type == SOCK_DGRAM)
 419                 return "ListenDatagram";
 420         else if (type == SOCK_SEQPACKET)
 421                 return "ListenSequentialPacket";
 422
 423         assert_not_reached("Unknown socket type");
 424         return NULL;
 425 }
 426
 427 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
 428
 429         SocketExecCommand c;
 430         Socket *s = SOCKET(u);
 431         SocketPort *p;
 432         const char *prefix2;
 433         char *p2;
 434
 435         assert(s);
 436         assert(f);
 437
 438         p2 = strappend(prefix, "\t");
 439         prefix2 = p2 ? p2 : prefix;
 440
 441         fprintf(f,
 442                 "%sSocket State: %s\n"
 443                 "%sResult: %s\n"
 444                 "%sBindIPv6Only: %s\n"
 445                 "%sBacklog: %u\n"
 446                 "%sSocketMode: %04o\n"
 447                 "%sDirectoryMode: %04o\n"
 448                 "%sKeepAlive: %s\n"
 449                 "%sFreeBind: %s\n"
 450                 "%sTransparent: %s\n"
 451                 "%sBroadcast: %s\n"
 452                 "%sPassCredentials: %s\n"
 453                 "%sPassSecurity: %s\n"
 454                 "%sTCPCongestion: %s\n",
 455                 prefix, socket_state_to_string(s->state),
 456                 prefix, socket_result_to_string(s->result),
 457                 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
 458                 prefix, s->backlog,
 459                 prefix, s->socket_mode,
 460                 prefix, s->directory_mode,
 461                 prefix, yes_no(s->keep_alive),
 462                 prefix, yes_no(s->free_bind),
 463                 prefix, yes_no(s->transparent),
 464                 prefix, yes_no(s->broadcast),
 465                 prefix, yes_no(s->pass_cred),
 466                 prefix, yes_no(s->pass_sec),
 467                 prefix, strna(s->tcp_congestion));
 468
 469         if (s->control_pid > 0)
 470                 fprintf(f,
 471                         "%sControl PID: %lu\n",
 472                         prefix, (unsigned long) s->control_pid);
 473
 474         if (s->bind_to_device)
 475                 fprintf(f,
 476                         "%sBindToDevice: %s\n",
 477                         prefix, s->bind_to_device);
 478
 479         if (s->accept)
 480                 fprintf(f,
 481                         "%sAccepted: %u\n"
 482                         "%sNConnections: %u\n"
 483                         "%sMaxConnections: %u\n",
 484                         prefix, s->n_accepted,
 485                         prefix, s->n_connections,
 486                         prefix, s->max_connections);
 487
 488         if (s->priority >= 0)
 489                 fprintf(f,
 490                         "%sPriority: %i\n",
 491                         prefix, s->priority);
 492
 493         if (s->receive_buffer > 0)
 494                 fprintf(f,
 495                         "%sReceiveBuffer: %zu\n",
 496                         prefix, s->receive_buffer);
 497
 498         if (s->send_buffer > 0)
 499                 fprintf(f,
 500                         "%sSendBuffer: %zu\n",
 501                         prefix, s->send_buffer);
 502
 503         if (s->ip_tos >= 0)
 504                 fprintf(f,
 505                         "%sIPTOS: %i\n",
 506                         prefix, s->ip_tos);
 507
 508         if (s->ip_ttl >= 0)
 509                 fprintf(f,
 510                         "%sIPTTL: %i\n",
 511                         prefix, s->ip_ttl);
 512
 513         if (s->pipe_size > 0)
 514                 fprintf(f,
 515                         "%sPipeSize: %zu\n",
 516                         prefix, s->pipe_size);
 517
 518         if (s->mark >= 0)
 519                 fprintf(f,
 520                         "%sMark: %i\n",
 521                         prefix, s->mark);
 522
 523         if (s->mq_maxmsg > 0)
 524                 fprintf(f,
 525                         "%sMessageQueueMaxMessages: %li\n",
 526                         prefix, s->mq_maxmsg);
 527
 528         if (s->mq_msgsize > 0)
 529                 fprintf(f,
 530                         "%sMessageQueueMessageSize: %li\n",
 531                         prefix, s->mq_msgsize);
 532
 533         if (s->smack)
 534                 fprintf(f,
 535                         "%sSmackLabel: %s\n",
 536                         prefix, s->smack);
 537
 538         if (s->smack_ip_in)
 539                 fprintf(f,
 540                         "%sSmackLabelIPIn: %s\n",
 541                         prefix, s->smack_ip_in);
 542
 543         if (s->smack_ip_out)
 544                 fprintf(f,
 545                         "%sSmackLabelIPOut: %s\n",
 546                         prefix, s->smack_ip_out);
 547
 548         LIST_FOREACH(port, p, s->ports) {
 549
 550                 if (p->type == SOCKET_SOCKET) {
 551                         const char *t;
 552                         int r;
 553                         char *k = NULL;
 554
 555                         if ((r = socket_address_print(&p->address, &k)) < 0)
 556                                 t = strerror(-r);
 557                         else
 558                                 t = k;
 559
 560                         fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
 561                         free(k);
 562                 } else if (p->type == SOCKET_SPECIAL)
 563                         fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
 564                 else if (p->type == SOCKET_MQUEUE)
 565                         fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
 566                 else
 567                         fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
 568         }
 569
 570         exec_context_dump(&s->exec_context, f, prefix);
 571         kill_context_dump(&s->kill_context, f, prefix);
 572
 573         for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
 574                 if (!s->exec_command[c])
 575                         continue;
 576
 577                 fprintf(f, "%s-> %s:\n",
 578                         prefix, socket_exec_command_to_string(c));
 579
 580                 exec_command_dump_list(s->exec_command[c], f, prefix2);
 581         }
 582
 583         free(p2);
 584 }
 585
 586 static int instance_from_socket(int fd, unsigned nr, char **instance) {
 587         socklen_t l;
 588         char *r;
 589         union {
 590                 struct sockaddr sa;
 591                 struct sockaddr_un un;
 592                 struct sockaddr_in in;
 593                 struct sockaddr_in6 in6;
 594                 struct sockaddr_storage storage;
 595         } local, remote;
 596
 597         assert(fd >= 0);
 598         assert(instance);
 599
 600         l = sizeof(local);
 601         if (getsockname(fd, &local.sa, &l) < 0)
 602                 return -errno;
 603
 604         l = sizeof(remote);
 605         if (getpeername(fd, &remote.sa, &l) < 0)
 606                 return -errno;
 607
 608         switch (local.sa.sa_family) {
 609
 610         case AF_INET: {
 611                 uint32_t
 612                         a = ntohl(local.in.sin_addr.s_addr),
 613                         b = ntohl(remote.in.sin_addr.s_addr);
 614
 615                 if (asprintf(&r,
 616                              "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 617                              nr,
 618                              a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
 619                              ntohs(local.in.sin_port),
 620                              b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
 621                              ntohs(remote.in.sin_port)) < 0)
 622                         return -ENOMEM;
 623
 624                 break;
 625         }
 626
 627         case AF_INET6: {
 628                 static const unsigned char ipv4_prefix[] = {
 629                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
 630                 };
 631
 632                 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
 633                     memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
 634                         const uint8_t
 635                                 *a = local.in6.sin6_addr.s6_addr+12,
 636                                 *b = remote.in6.sin6_addr.s6_addr+12;
 637
 638                         if (asprintf(&r,
 639                                      "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 640                                      nr,
 641                                      a[0], a[1], a[2], a[3],
 642                                      ntohs(local.in6.sin6_port),
 643                                      b[0], b[1], b[2], b[3],
 644                                      ntohs(remote.in6.sin6_port)) < 0)
 645                                 return -ENOMEM;
 646                 } else {
 647                         char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
 648
 649                         if (asprintf(&r,
 650                                      "%u-%s:%u-%s:%u",
 651                                      nr,
 652                                      inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
 653                                      ntohs(local.in6.sin6_port),
 654                                      inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
 655                                      ntohs(remote.in6.sin6_port)) < 0)
 656                                 return -ENOMEM;
 657                 }
 658
 659                 break;
 660         }
 661
 662         case AF_UNIX: {
 663                 struct ucred ucred;
 664
 665                 l = sizeof(ucred);
 666                 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
 667                         return -errno;
 668
 669                 if (asprintf(&r,
 670                              "%u-%lu-%lu",
 671                              nr,
 672                              (unsigned long) ucred.pid,
 673                              (unsigned long) ucred.uid) < 0)
 674                         return -ENOMEM;
 675
 676                 break;
 677         }
 678
 679         default:
 680                 assert_not_reached("Unhandled socket type.");
 681         }
 682
 683         *instance = r;
 684         return 0;
 685 }
 686
 687 static void socket_close_fds(Socket *s) {
 688         SocketPort *p;
 689
 690         assert(s);
 691
 692         LIST_FOREACH(port, p, s->ports) {
 693                 if (p->fd < 0)
 694                         continue;
 695
 696                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
 697                 close_nointr_nofail(p->fd);
 698
 699                 /* One little note: we should never delete any sockets
 700                  * in the file system here! After all some other
 701                  * process we spawned might still have a reference of
 702                  * this fd and wants to continue to use it. Therefore
 703                  * we delete sockets in the file system before we
 704                  * create a new one, not after we stopped using
 705                  * one! */
 706
 707                 p->fd = -1;
 708         }
 709 }
 710
 711 static void socket_apply_socket_options(Socket *s, int fd) {
 712         assert(s);
 713         assert(fd >= 0);
 714
 715         if (s->keep_alive) {
 716                 int b = s->keep_alive;
 717                 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
 718                         log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
 719         }
 720
 721         if (s->broadcast) {
 722                 int one = 1;
 723                 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
 724                         log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
 725         }
 726
 727         if (s->pass_cred) {
 728                 int one = 1;
 729                 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
 730                         log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
 731         }
 732
 733         if (s->pass_sec) {
 734                 int one = 1;
 735                 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
 736                         log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
 737         }
 738
 739         if (s->priority >= 0)
 740                 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
 741                         log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
 742
 743         if (s->receive_buffer > 0) {
 744                 int value = (int) s->receive_buffer;
 745
 746                 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
 747
 748                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
 749                         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
 750                                 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
 751         }
 752
 753         if (s->send_buffer > 0) {
 754                 int value = (int) s->send_buffer;
 755                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
 756                         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
 757                                 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
 758         }
 759
 760         if (s->mark >= 0)
 761                 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
 762                         log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
 763
 764         if (s->ip_tos >= 0)
 765                 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
 766                         log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
 767
 768         if (s->ip_ttl >= 0) {
 769                 int r, x;
 770
 771                 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
 772
 773                 if (socket_ipv6_is_supported())
 774                         x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
 775                 else {
 776                         x = -1;
 777                         errno = EAFNOSUPPORT;
 778                 }
 779
 780                 if (r < 0 && x < 0)
 781                         log_warning_unit(UNIT(s)->id,
 782                                          "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
 783         }
 784
 785         if (s->tcp_congestion)
 786                 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
 787                         log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
 788
 789 #ifdef HAVE_ATTR_XATTR_H
 790         if (s->smack_ip_in)
 791                 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
 792                         log_error_unit(UNIT(s)->id,
 793                                        "fsetxattr(\"security.SMACK64IPIN\"): %m");
 794
 795         if (s->smack_ip_out)
 796                 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
 797                         log_error_unit(UNIT(s)->id,
 798                                        "fsetxattr(\"security.SMACK64IPOUT\"): %m");
 799 #endif
 800 }
 801
 802 static void socket_apply_fifo_options(Socket *s, int fd) {
 803         assert(s);
 804         assert(fd >= 0);
 805
 806         if (s->pipe_size > 0)
 807                 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
 808                         log_warning_unit(UNIT(s)->id,
 809                                          "F_SETPIPE_SZ: %m");
 810
 811 #ifdef HAVE_ATTR_XATTR_H
 812         if (s->smack)
 813                 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
 814                         log_error_unit(UNIT(s)->id,
 815                                        "fsetxattr(\"security.SMACK64\"): %m");
 816 #endif
 817 }
 818
 819 static int fifo_address_create(
 820                 const char *path,
 821                 mode_t directory_mode,
 822                 mode_t socket_mode,
 823                 int *_fd) {
 824
 825         int fd = -1, r = 0;
 826         struct stat st;
 827         mode_t old_mask;
 828
 829         assert(path);
 830         assert(_fd);
 831
 832         mkdir_parents_label(path, directory_mode);
 833
 834         r = label_context_set(path, S_IFIFO);
 835         if (r < 0)
 836                 goto fail;
 837
 838         /* Enforce the right access mode for the fifo */
 839         old_mask = umask(~ socket_mode);
 840
 841         /* Include the original umask in our mask */
 842         umask(~socket_mode | old_mask);
 843
 844         r = mkfifo(path, socket_mode);
 845         umask(old_mask);
 846
 847         if (r < 0 && errno != EEXIST) {
 848                 r = -errno;
 849                 goto fail;
 850         }
 851
 852         if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 853                 r = -errno;
 854                 goto fail;
 855         }
 856
 857         label_context_clear();
 858
 859         if (fstat(fd, &st) < 0) {
 860                 r = -errno;
 861                 goto fail;
 862         }
 863
 864         if (!S_ISFIFO(st.st_mode) ||
 865             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
 866             st.st_uid != getuid() ||
 867             st.st_gid != getgid()) {
 868
 869                 r = -EEXIST;
 870                 goto fail;
 871         }
 872
 873         *_fd = fd;
 874         return 0;
 875
 876 fail:
 877         label_context_clear();
 878
 879         if (fd >= 0)
 880                 close_nointr_nofail(fd);
 881
 882         return r;
 883 }
 884
 885 static int special_address_create(
 886                 const char *path,
 887                 int *_fd) {
 888
 889         int fd = -1, r = 0;
 890         struct stat st;
 891
 892         assert(path);
 893         assert(_fd);
 894
 895         if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 896                 r = -errno;
 897                 goto fail;
 898         }
 899
 900         if (fstat(fd, &st) < 0) {
 901                 r = -errno;
 902                 goto fail;
 903         }
 904
 905         /* Check whether this is a /proc, /sys or /dev file or char device */
 906         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 907                 r = -EEXIST;
 908                 goto fail;
 909         }
 910
 911         *_fd = fd;
 912         return 0;
 913
 914 fail:
 915         if (fd >= 0)
 916                 close_nointr_nofail(fd);
 917
 918         return r;
 919 }
 920
 921 static int mq_address_create(
 922                 const char *path,
 923                 mode_t mq_mode,
 924                 long maxmsg,
 925                 long msgsize,
 926                 int *_fd) {
 927
 928         int fd = -1, r = 0;
 929         struct stat st;
 930         mode_t old_mask;
 931         struct mq_attr _attr, *attr = NULL;
 932
 933         assert(path);
 934         assert(_fd);
 935
 936         if (maxmsg > 0 && msgsize > 0) {
 937                 zero(_attr);
 938                 _attr.mq_flags = O_NONBLOCK;
 939                 _attr.mq_maxmsg = maxmsg;
 940                 _attr.mq_msgsize = msgsize;
 941                 attr = &_attr;
 942         }
 943
 944         /* Enforce the right access mode for the mq */
 945         old_mask = umask(~ mq_mode);
 946
 947         /* Include the original umask in our mask */
 948         umask(~mq_mode | old_mask);
 949
 950         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
 951         umask(old_mask);
 952
 953         if (fd < 0) {
 954                 r = -errno;
 955                 goto fail;
 956         }
 957
 958         if (fstat(fd, &st) < 0) {
 959                 r = -errno;
 960                 goto fail;
 961         }
 962
 963         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
 964             st.st_uid != getuid() ||
 965             st.st_gid != getgid()) {
 966
 967                 r = -EEXIST;
 968                 goto fail;
 969         }
 970
 971         *_fd = fd;
 972         return 0;
 973
 974 fail:
 975         if (fd >= 0)
 976                 close_nointr_nofail(fd);
 977
 978         return r;
 979 }
 980
 981 static int socket_open_fds(Socket *s) {
 982         SocketPort *p;
 983         int r;
 984         char *label = NULL;
 985         bool know_label = false;
 986
 987         assert(s);
 988
 989         LIST_FOREACH(port, p, s->ports) {
 990
 991                 if (p->fd >= 0)
 992                         continue;
 993
 994                 if (p->type == SOCKET_SOCKET) {
 995
 996                         if (!know_label) {
 997
 998                                 if ((r = socket_instantiate_service(s)) < 0)
 999                                         return r;
1000
1001                                 if (UNIT_DEREF(s->service) &&
1002                                     SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1003                                         r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1004
1005                                         if (r < 0) {
1006                                                 if (r != -EPERM)
1007                                                         return r;
1008                                         }
1009                                 }
1010
1011                                 know_label = true;
1012                         }
1013
1014                         if ((r = socket_address_listen(
1015                                              &p->address,
1016                                              s->backlog,
1017                                              s->bind_ipv6_only,
1018                                              s->bind_to_device,
1019                                              s->free_bind,
1020                                              s->transparent,
1021                                              s->directory_mode,
1022                                              s->socket_mode,
1023                                              label,
1024                                              &p->fd)) < 0)
1025                                 goto rollback;
1026
1027                         socket_apply_socket_options(s, p->fd);
1028
1029                 } else  if (p->type == SOCKET_SPECIAL) {
1030
1031                         if ((r = special_address_create(
1032                                              p->path,
1033                                              &p->fd)) < 0)
1034                                 goto rollback;
1035
1036                 } else  if (p->type == SOCKET_FIFO) {
1037
1038                         if ((r = fifo_address_create(
1039                                              p->path,
1040                                              s->directory_mode,
1041                                              s->socket_mode,
1042                                              &p->fd)) < 0)
1043                                 goto rollback;
1044
1045                         socket_apply_fifo_options(s, p->fd);
1046                 } else if (p->type == SOCKET_MQUEUE) {
1047
1048                         if ((r = mq_address_create(
1049                                              p->path,
1050                                              s->socket_mode,
1051                                              s->mq_maxmsg,
1052                                              s->mq_msgsize,
1053                                              &p->fd)) < 0)
1054                                 goto rollback;
1055                 } else
1056                         assert_not_reached("Unknown port type");
1057         }
1058
1059         label_free(label);
1060         return 0;
1061
1062 rollback:
1063         socket_close_fds(s);
1064         label_free(label);
1065         return r;
1066 }
1067
1068 static void socket_unwatch_fds(Socket *s) {
1069         SocketPort *p;
1070
1071         assert(s);
1072
1073         LIST_FOREACH(port, p, s->ports) {
1074                 if (p->fd < 0)
1075                         continue;
1076
1077                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1078         }
1079 }
1080
1081 static int socket_watch_fds(Socket *s) {
1082         SocketPort *p;
1083         int r;
1084
1085         assert(s);
1086
1087         LIST_FOREACH(port, p, s->ports) {
1088                 if (p->fd < 0)
1089                         continue;
1090
1091                 p->fd_watch.socket_accept =
1092                         s->accept &&
1093                         p->type == SOCKET_SOCKET &&
1094                         socket_address_can_accept(&p->address);
1095
1096                 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1097                         goto fail;
1098         }
1099
1100         return 0;
1101
1102 fail:
1103         socket_unwatch_fds(s);
1104         return r;
1105 }
1106
1107 static void socket_set_state(Socket *s, SocketState state) {
1108         SocketState old_state;
1109         assert(s);
1110
1111         old_state = s->state;
1112         s->state = state;
1113
1114         if (state != SOCKET_START_PRE &&
1115             state != SOCKET_START_POST &&
1116             state != SOCKET_STOP_PRE &&
1117             state != SOCKET_STOP_PRE_SIGTERM &&
1118             state != SOCKET_STOP_PRE_SIGKILL &&
1119             state != SOCKET_STOP_POST &&
1120             state != SOCKET_FINAL_SIGTERM &&
1121             state != SOCKET_FINAL_SIGKILL) {
1122                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1123                 socket_unwatch_control_pid(s);
1124                 s->control_command = NULL;
1125                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1126         }
1127
1128         if (state != SOCKET_LISTENING)
1129                 socket_unwatch_fds(s);
1130
1131         if (state != SOCKET_START_POST &&
1132             state != SOCKET_LISTENING &&
1133             state != SOCKET_RUNNING &&
1134             state != SOCKET_STOP_PRE &&
1135             state != SOCKET_STOP_PRE_SIGTERM &&
1136             state != SOCKET_STOP_PRE_SIGKILL)
1137                 socket_close_fds(s);
1138
1139         if (state != old_state)
1140                 log_debug_unit(UNIT(s)->id,
1141                                "%s changed %s -> %s", UNIT(s)->id,
1142                                socket_state_to_string(old_state),
1143                                socket_state_to_string(state));
1144
1145         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1146 }
1147
1148 static int socket_coldplug(Unit *u) {
1149         Socket *s = SOCKET(u);
1150         int r;
1151
1152         assert(s);
1153         assert(s->state == SOCKET_DEAD);
1154
1155         if (s->deserialized_state != s->state) {
1156
1157                 if (s->deserialized_state == SOCKET_START_PRE ||
1158                     s->deserialized_state == SOCKET_START_POST ||
1159                     s->deserialized_state == SOCKET_STOP_PRE ||
1160                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1161                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1162                     s->deserialized_state == SOCKET_STOP_POST ||
1163                     s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1164                     s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1165
1166                         if (s->control_pid <= 0)
1167                                 return -EBADMSG;
1168
1169                         r = unit_watch_pid(UNIT(s), s->control_pid);
1170                         if (r < 0)
1171                                 return r;
1172
1173                         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1174                         if (r < 0)
1175                                 return r;
1176                 }
1177
1178                 if (s->deserialized_state == SOCKET_START_POST ||
1179                     s->deserialized_state == SOCKET_LISTENING ||
1180                     s->deserialized_state == SOCKET_RUNNING ||
1181                     s->deserialized_state == SOCKET_STOP_PRE ||
1182                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1183                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1184                         if ((r = socket_open_fds(s)) < 0)
1185                                 return r;
1186
1187                 if (s->deserialized_state == SOCKET_LISTENING)
1188                         if ((r = socket_watch_fds(s)) < 0)
1189                                 return r;
1190
1191                 socket_set_state(s, s->deserialized_state);
1192         }
1193
1194         return 0;
1195 }
1196
1197 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1198         pid_t pid;
1199         int r;
1200         char **argv;
1201
1202         assert(s);
1203         assert(c);
1204         assert(_pid);
1205
1206         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1207         if (r < 0)
1208                 goto fail;
1209
1210         argv = unit_full_printf_strv(UNIT(s), c->argv);
1211         if (!argv) {
1212                 r = -ENOMEM;
1213                 goto fail;
1214         }
1215
1216         r = exec_spawn(c,
1217                        argv,
1218                        &s->exec_context,
1219                        NULL, 0,
1220                        UNIT(s)->manager->environment,
1221                        true,
1222                        true,
1223                        true,
1224                        UNIT(s)->manager->confirm_spawn,
1225                        UNIT(s)->cgroup_bondings,
1226                        UNIT(s)->cgroup_attributes,
1227                        NULL,
1228                        UNIT(s)->id,
1229                        NULL,
1230                        &pid);
1231
1232         strv_free(argv);
1233         if (r < 0)
1234                 goto fail;
1235
1236         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1237                 /* FIXME: we need to do something here */
1238                 goto fail;
1239
1240         *_pid = pid;
1241
1242         return 0;
1243
1244 fail:
1245         unit_unwatch_timer(UNIT(s), &s->timer_watch);
1246
1247         return r;
1248 }
1249
1250 static void socket_enter_dead(Socket *s, SocketResult f) {
1251         assert(s);
1252
1253         if (f != SOCKET_SUCCESS)
1254                 s->result = f;
1255
1256         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1257 }
1258
1259 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1260
1261 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1262         int r;
1263         assert(s);
1264
1265         if (f != SOCKET_SUCCESS)
1266                 s->result = f;
1267
1268         socket_unwatch_control_pid(s);
1269
1270         s->control_command_id = SOCKET_EXEC_STOP_POST;
1271
1272         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1273                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1274                         goto fail;
1275
1276                 socket_set_state(s, SOCKET_STOP_POST);
1277         } else
1278                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1279
1280         return;
1281
1282 fail:
1283         log_warning_unit(UNIT(s)->id,
1284                          "%s failed to run 'stop-post' task: %s",
1285                          UNIT(s)->id, strerror(-r));
1286         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1287 }
1288
1289 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1290         int r;
1291
1292         assert(s);
1293
1294         if (f != SOCKET_SUCCESS)
1295                 s->result = f;
1296
1297         r = unit_kill_context(
1298                         UNIT(s),
1299                         &s->kill_context,
1300                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1301                         -1,
1302                         s->control_pid,
1303                         false);
1304         if (r < 0)
1305                 goto fail;
1306
1307         if (r > 0) {
1308                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1309                 if (r < 0)
1310                         goto fail;
1311
1312                 socket_set_state(s, state);
1313         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1314                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1315         else
1316                 socket_enter_dead(s, SOCKET_SUCCESS);
1317
1318         return;
1319
1320 fail:
1321         log_warning_unit(UNIT(s)->id,
1322                          "%s failed to kill processes: %s",
1323                          UNIT(s)->id, strerror(-r));
1324
1325         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1326                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1327         else
1328                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1329 }
1330
1331 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1332         int r;
1333         assert(s);
1334
1335         if (f != SOCKET_SUCCESS)
1336                 s->result = f;
1337
1338         socket_unwatch_control_pid(s);
1339
1340         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1341
1342         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1343                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1344                         goto fail;
1345
1346                 socket_set_state(s, SOCKET_STOP_PRE);
1347         } else
1348                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1349
1350         return;
1351
1352 fail:
1353         log_warning_unit(UNIT(s)->id,
1354                          "%s failed to run 'stop-pre' task: %s",
1355                          UNIT(s)->id, strerror(-r));
1356         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1357 }
1358
1359 static void socket_enter_listening(Socket *s) {
1360         int r;
1361         assert(s);
1362
1363         r = socket_watch_fds(s);
1364         if (r < 0) {
1365                 log_warning_unit(UNIT(s)->id,
1366                                  "%s failed to watch sockets: %s",
1367                                  UNIT(s)->id, strerror(-r));
1368                 goto fail;
1369         }
1370
1371         socket_set_state(s, SOCKET_LISTENING);
1372         return;
1373
1374 fail:
1375         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1376 }
1377
1378 static void socket_enter_start_post(Socket *s) {
1379         int r;
1380         assert(s);
1381
1382         r = socket_open_fds(s);
1383         if (r < 0) {
1384                 log_warning_unit(UNIT(s)->id,
1385                                  "%s failed to listen on sockets: %s",
1386                                  UNIT(s)->id, strerror(-r));
1387                 goto fail;
1388         }
1389
1390         socket_unwatch_control_pid(s);
1391
1392         s->control_command_id = SOCKET_EXEC_START_POST;
1393
1394         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1395                 r = socket_spawn(s, s->control_command, &s->control_pid);
1396                 if (r < 0) {
1397                         log_warning_unit(UNIT(s)->id,
1398                                          "%s failed to run 'start-post' task: %s",
1399                                          UNIT(s)->id, strerror(-r));
1400                         goto fail;
1401                 }
1402
1403                 socket_set_state(s, SOCKET_START_POST);
1404         } else
1405                 socket_enter_listening(s);
1406
1407         return;
1408
1409 fail:
1410         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1411 }
1412
1413 static void socket_enter_start_pre(Socket *s) {
1414         int r;
1415         assert(s);
1416
1417         socket_unwatch_control_pid(s);
1418
1419         s->control_command_id = SOCKET_EXEC_START_PRE;
1420
1421         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1422                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1423                         goto fail;
1424
1425                 socket_set_state(s, SOCKET_START_PRE);
1426         } else
1427                 socket_enter_start_post(s);
1428
1429         return;
1430
1431 fail:
1432         log_warning_unit(UNIT(s)->id,
1433                          "%s failed to run 'start-pre' task: %s",
1434                          UNIT(s)->id, strerror(-r));
1435         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1436 }
1437
1438 static void socket_enter_running(Socket *s, int cfd) {
1439         int r;
1440         DBusError error;
1441
1442         assert(s);
1443         dbus_error_init(&error);
1444
1445         /* We don't take connections anymore if we are supposed to
1446          * shut down anyway */
1447         if (unit_pending_inactive(UNIT(s))) {
1448                 log_debug_unit(UNIT(s)->id,
1449                                "Suppressing connection request on %s since unit stop is scheduled.",
1450                                UNIT(s)->id);
1451
1452                 if (cfd >= 0)
1453                         close_nointr_nofail(cfd);
1454                 else  {
1455                         /* Flush all sockets by closing and reopening them */
1456                         socket_close_fds(s);
1457
1458                         r = socket_watch_fds(s);
1459                         if (r < 0) {
1460                                 log_warning_unit(UNIT(s)->id,
1461                                                  "%s failed to watch sockets: %s",
1462                                                  UNIT(s)->id, strerror(-r));
1463                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1464                         }
1465                 }
1466
1467                 return;
1468         }
1469
1470         if (cfd < 0) {
1471                 Iterator i;
1472                 Unit *u;
1473                 bool pending = false;
1474
1475                 /* If there's already a start pending don't bother to
1476                  * do anything */
1477                 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1478                         if (unit_pending_active(u)) {
1479                                 pending = true;
1480                                 break;
1481                         }
1482
1483                 if (!pending) {
1484                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1485                         if (r < 0)
1486                                 goto fail;
1487                 }
1488
1489                 socket_set_state(s, SOCKET_RUNNING);
1490         } else {
1491                 char *prefix, *instance = NULL, *name;
1492                 Service *service;
1493
1494                 if (s->n_connections >= s->max_connections) {
1495                         log_warning_unit(UNIT(s)->id,
1496                                          "%s: Too many incoming connections (%u)",
1497                                          UNIT(s)->id, s->n_connections);
1498                         close_nointr_nofail(cfd);
1499                         return;
1500                 }
1501
1502                 r = socket_instantiate_service(s);
1503                 if (r < 0)
1504                         goto fail;
1505
1506                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1507                 if (r < 0) {
1508                         if (r != -ENOTCONN)
1509                                 goto fail;
1510
1511                         /* ENOTCONN is legitimate if TCP RST was received.
1512                          * This connection is over, but the socket unit lives on. */
1513                         close_nointr_nofail(cfd);
1514                         return;
1515                 }
1516
1517                 prefix = unit_name_to_prefix(UNIT(s)->id);
1518                 if (!prefix) {
1519                         free(instance);
1520                         r = -ENOMEM;
1521                         goto fail;
1522                 }
1523
1524                 name = unit_name_build(prefix, instance, ".service");
1525                 free(prefix);
1526                 free(instance);
1527
1528                 if (!name) {
1529                         r = -ENOMEM;
1530                         goto fail;
1531                 }
1532
1533                 r = unit_add_name(UNIT_DEREF(s->service), name);
1534                 if (r < 0) {
1535                         free(name);
1536                         goto fail;
1537                 }
1538
1539                 service = SERVICE(UNIT_DEREF(s->service));
1540                 unit_ref_unset(&s->service);
1541                 s->n_accepted ++;
1542
1543                 UNIT(service)->no_gc = false;
1544
1545                 unit_choose_id(UNIT(service), name);
1546                 free(name);
1547
1548                 r = service_set_socket_fd(service, cfd, s);
1549                 if (r < 0)
1550                         goto fail;
1551
1552                 cfd = -1;
1553                 s->n_connections ++;
1554
1555                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1556                 if (r < 0)
1557                         goto fail;
1558
1559                 /* Notify clients about changed counters */
1560                 unit_add_to_dbus_queue(UNIT(s));
1561         }
1562
1563         return;
1564
1565 fail:
1566         log_warning_unit(UNIT(s)->id,
1567                          "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1568                          UNIT(s)->id,
1569                          cfd >= 0 ? "template" : "non-template",
1570                          bus_error(&error, r));
1571         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1572
1573         if (cfd >= 0)
1574                 close_nointr_nofail(cfd);
1575
1576         dbus_error_free(&error);
1577 }
1578
1579 static void socket_run_next(Socket *s) {
1580         int r;
1581
1582         assert(s);
1583         assert(s->control_command);
1584         assert(s->control_command->command_next);
1585
1586         socket_unwatch_control_pid(s);
1587
1588         s->control_command = s->control_command->command_next;
1589
1590         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1591                 goto fail;
1592
1593         return;
1594
1595 fail:
1596         log_warning_unit(UNIT(s)->id,
1597                          "%s failed to run next task: %s",
1598                          UNIT(s)->id, strerror(-r));
1599
1600         if (s->state == SOCKET_START_POST)
1601                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1602         else if (s->state == SOCKET_STOP_POST)
1603                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1604         else
1605                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1606 }
1607
1608 static int socket_start(Unit *u) {
1609         Socket *s = SOCKET(u);
1610
1611         assert(s);
1612
1613         /* We cannot fulfill this request right now, try again later
1614          * please! */
1615         if (s->state == SOCKET_STOP_PRE ||
1616             s->state == SOCKET_STOP_PRE_SIGKILL ||
1617             s->state == SOCKET_STOP_PRE_SIGTERM ||
1618             s->state == SOCKET_STOP_POST ||
1619             s->state == SOCKET_FINAL_SIGTERM ||
1620             s->state == SOCKET_FINAL_SIGKILL)
1621                 return -EAGAIN;
1622
1623         if (s->state == SOCKET_START_PRE ||
1624             s->state == SOCKET_START_POST)
1625                 return 0;
1626
1627         /* Cannot run this without the service being around */
1628         if (UNIT_DEREF(s->service)) {
1629                 Service *service;
1630
1631                 service = SERVICE(UNIT_DEREF(s->service));
1632
1633                 if (UNIT(service)->load_state != UNIT_LOADED) {
1634                         log_error_unit(UNIT(service)->id,
1635                                        "Socket service %s not loaded, refusing.",
1636                                        UNIT(service)->id);
1637                         return -ENOENT;
1638                 }
1639
1640                 /* If the service is already active we cannot start the
1641                  * socket */
1642                 if (service->state != SERVICE_DEAD &&
1643                     service->state != SERVICE_FAILED &&
1644                     service->state != SERVICE_AUTO_RESTART) {
1645                         log_error_unit(UNIT(service)->id,
1646                                        "Socket service %s already active, refusing.",
1647                                        UNIT(service)->id);
1648                         return -EBUSY;
1649                 }
1650
1651 #ifdef HAVE_SYSV_COMPAT
1652                 if (service->is_sysv) {
1653                         log_error_unit(UNIT(s)->id,
1654                                        "Using SysV services for socket activation is not supported. Refusing.");
1655                         return -ENOENT;
1656                 }
1657 #endif
1658         }
1659
1660         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1661
1662         s->result = SOCKET_SUCCESS;
1663         socket_enter_start_pre(s);
1664         return 0;
1665 }
1666
1667 static int socket_stop(Unit *u) {
1668         Socket *s = SOCKET(u);
1669
1670         assert(s);
1671
1672         /* Already on it */
1673         if (s->state == SOCKET_STOP_PRE ||
1674             s->state == SOCKET_STOP_PRE_SIGTERM ||
1675             s->state == SOCKET_STOP_PRE_SIGKILL ||
1676             s->state == SOCKET_STOP_POST ||
1677             s->state == SOCKET_FINAL_SIGTERM ||
1678             s->state == SOCKET_FINAL_SIGKILL)
1679                 return 0;
1680
1681         /* If there's already something running we go directly into
1682          * kill mode. */
1683         if (s->state == SOCKET_START_PRE ||
1684             s->state == SOCKET_START_POST) {
1685                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1686                 return -EAGAIN;
1687         }
1688
1689         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1690
1691         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1692         return 0;
1693 }
1694
1695 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1696         Socket *s = SOCKET(u);
1697         SocketPort *p;
1698         int r;
1699
1700         assert(u);
1701         assert(f);
1702         assert(fds);
1703
1704         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1705         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1706         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1707
1708         if (s->control_pid > 0)
1709                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1710
1711         if (s->control_command_id >= 0)
1712                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1713
1714         LIST_FOREACH(port, p, s->ports) {
1715                 int copy;
1716
1717                 if (p->fd < 0)
1718                         continue;
1719
1720                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1721                         return copy;
1722
1723                 if (p->type == SOCKET_SOCKET) {
1724                         char *t;
1725
1726                         r = socket_address_print(&p->address, &t);
1727                         if (r < 0)
1728                                 return r;
1729
1730                         if (socket_address_family(&p->address) == AF_NETLINK)
1731                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1732                         else
1733                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1734                         free(t);
1735                 } else if (p->type == SOCKET_SPECIAL)
1736                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1737                 else if (p->type == SOCKET_MQUEUE)
1738                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1739                 else {
1740                         assert(p->type == SOCKET_FIFO);
1741                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1742                 }
1743         }
1744
1745         return 0;
1746 }
1747
1748 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1749         Socket *s = SOCKET(u);
1750
1751         assert(u);
1752         assert(key);
1753         assert(value);
1754         assert(fds);
1755
1756         if (streq(key, "state")) {
1757                 SocketState state;
1758
1759                 state = socket_state_from_string(value);
1760                 if (state < 0)
1761                         log_debug_unit(u->id,
1762                                        "Failed to parse state value %s", value);
1763                 else
1764                         s->deserialized_state = state;
1765         } else if (streq(key, "result")) {
1766                 SocketResult f;
1767
1768                 f = socket_result_from_string(value);
1769                 if (f < 0)
1770                         log_debug_unit(u->id,
1771                                        "Failed to parse result value %s", value);
1772                 else if (f != SOCKET_SUCCESS)
1773                         s->result = f;
1774
1775         } else if (streq(key, "n-accepted")) {
1776                 unsigned k;
1777
1778                 if (safe_atou(value, &k) < 0)
1779                         log_debug_unit(u->id,
1780                                        "Failed to parse n-accepted value %s", value);
1781                 else
1782                         s->n_accepted += k;
1783         } else if (streq(key, "control-pid")) {
1784                 pid_t pid;
1785
1786                 if (parse_pid(value, &pid) < 0)
1787                         log_debug_unit(u->id,
1788                                        "Failed to parse control-pid value %s", value);
1789                 else
1790                         s->control_pid = pid;
1791         } else if (streq(key, "control-command")) {
1792                 SocketExecCommand id;
1793
1794                 id = socket_exec_command_from_string(value);
1795                 if (id < 0)
1796                         log_debug_unit(u->id,
1797                                        "Failed to parse exec-command value %s", value);
1798                 else {
1799                         s->control_command_id = id;
1800                         s->control_command = s->exec_command[id];
1801                 }
1802         } else if (streq(key, "fifo")) {
1803                 int fd, skip = 0;
1804                 SocketPort *p;
1805
1806                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1807                         log_debug_unit(u->id,
1808                                        "Failed to parse fifo value %s", value);
1809                 else {
1810
1811                         LIST_FOREACH(port, p, s->ports)
1812                                 if (p->type == SOCKET_FIFO &&
1813                                     streq_ptr(p->path, value+skip))
1814                                         break;
1815
1816                         if (p) {
1817                                 if (p->fd >= 0)
1818                                         close_nointr_nofail(p->fd);
1819                                 p->fd = fdset_remove(fds, fd);
1820                         }
1821                 }
1822
1823         } else if (streq(key, "special")) {
1824                 int fd, skip = 0;
1825                 SocketPort *p;
1826
1827                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1828                         log_debug_unit(u->id,
1829                                        "Failed to parse special value %s", value);
1830                 else {
1831
1832                         LIST_FOREACH(port, p, s->ports)
1833                                 if (p->type == SOCKET_SPECIAL &&
1834                                     streq_ptr(p->path, value+skip))
1835                                         break;
1836
1837                         if (p) {
1838                                 if (p->fd >= 0)
1839                                         close_nointr_nofail(p->fd);
1840                                 p->fd = fdset_remove(fds, fd);
1841                         }
1842                 }
1843
1844         } else if (streq(key, "mqueue")) {
1845                 int fd, skip = 0;
1846                 SocketPort *p;
1847
1848                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1849                         log_debug_unit(u->id,
1850                                        "Failed to parse mqueue value %s", value);
1851                 else {
1852
1853                         LIST_FOREACH(port, p, s->ports)
1854                                 if (p->type == SOCKET_MQUEUE &&
1855                                     streq_ptr(p->path, value+skip))
1856                                         break;
1857
1858                         if (p) {
1859                                 if (p->fd >= 0)
1860                                         close_nointr_nofail(p->fd);
1861                                 p->fd = fdset_remove(fds, fd);
1862                         }
1863                 }
1864
1865         } else if (streq(key, "socket")) {
1866                 int fd, type, skip = 0;
1867                 SocketPort *p;
1868
1869                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1870                         log_debug_unit(u->id,
1871                                        "Failed to parse socket value %s", value);
1872                 else {
1873
1874                         LIST_FOREACH(port, p, s->ports)
1875                                 if (socket_address_is(&p->address, value+skip, type))
1876                                         break;
1877
1878                         if (p) {
1879                                 if (p->fd >= 0)
1880                                         close_nointr_nofail(p->fd);
1881                                 p->fd = fdset_remove(fds, fd);
1882                         }
1883                 }
1884
1885         } else if (streq(key, "netlink")) {
1886                 int fd, skip = 0;
1887                 SocketPort *p;
1888
1889                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1890                         log_debug_unit(u->id,
1891                                        "Failed to parse socket value %s", value);
1892                 else {
1893
1894                         LIST_FOREACH(port, p, s->ports)
1895                                 if (socket_address_is_netlink(&p->address, value+skip))
1896                                         break;
1897
1898                         if (p) {
1899                                 if (p->fd >= 0)
1900                                         close_nointr_nofail(p->fd);
1901                                 p->fd = fdset_remove(fds, fd);
1902                         }
1903                 }
1904
1905         } else
1906                 log_debug_unit(UNIT(s)->id,
1907                                "Unknown serialization key '%s'", key);
1908
1909         return 0;
1910 }
1911
1912 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1913         Socket *s = SOCKET(u);
1914         SocketPort *p;
1915
1916         assert(u);
1917
1918         LIST_FOREACH(port, p, s->ports) {
1919                 Iterator i;
1920                 int fd;
1921
1922                 if (p->type != SOCKET_SOCKET)
1923                         continue;
1924
1925                 if (p->fd >= 0)
1926                         continue;
1927
1928                 FDSET_FOREACH(fd, fds, i) {
1929                         if (socket_address_matches_fd(&p->address, fd)) {
1930                                 p->fd = fdset_remove(fds, fd);
1931                                 s->deserialized_state = SOCKET_LISTENING;
1932                                 break;
1933                         }
1934                 }
1935         }
1936
1937         return 0;
1938 }
1939
1940 static UnitActiveState socket_active_state(Unit *u) {
1941         assert(u);
1942
1943         return state_translation_table[SOCKET(u)->state];
1944 }
1945
1946 static const char *socket_sub_state_to_string(Unit *u) {
1947         assert(u);
1948
1949         return socket_state_to_string(SOCKET(u)->state);
1950 }
1951
1952 static bool socket_check_gc(Unit *u) {
1953         Socket *s = SOCKET(u);
1954
1955         assert(u);
1956
1957         return s->n_connections > 0;
1958 }
1959
1960 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1961         Socket *s = SOCKET(u);
1962         int cfd = -1;
1963
1964         assert(s);
1965         assert(fd >= 0);
1966
1967         if (s->state != SOCKET_LISTENING)
1968                 return;
1969
1970         log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1971
1972         if (events != EPOLLIN) {
1973
1974                 if (events & EPOLLHUP)
1975                         log_error_unit(u->id,
1976                                        "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
1977                                        u->id);
1978                 else
1979                         log_error_unit(u->id,
1980                                        "%s: Got unexpected poll event (0x%x) on socket.",
1981                                        u->id, events);
1982
1983                 goto fail;
1984         }
1985
1986         if (w->socket_accept) {
1987                 for (;;) {
1988
1989                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1990                         if (cfd < 0) {
1991
1992                                 if (errno == EINTR)
1993                                         continue;
1994
1995                                 log_error_unit(u->id,
1996                                                "Failed to accept socket: %m");
1997                                 goto fail;
1998                         }
1999
2000                         break;
2001                 }
2002
2003                 socket_apply_socket_options(s, cfd);
2004         }
2005
2006         socket_enter_running(s, cfd);
2007         return;
2008
2009 fail:
2010         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2011 }
2012
2013 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2014         Socket *s = SOCKET(u);
2015         SocketResult f;
2016
2017         assert(s);
2018         assert(pid >= 0);
2019
2020         if (pid != s->control_pid)
2021                 return;
2022
2023         s->control_pid = 0;
2024
2025         if (is_clean_exit(code, status, NULL))
2026                 f = SOCKET_SUCCESS;
2027         else if (code == CLD_EXITED)
2028                 f = SOCKET_FAILURE_EXIT_CODE;
2029         else if (code == CLD_KILLED)
2030                 f = SOCKET_FAILURE_SIGNAL;
2031         else if (code == CLD_DUMPED)
2032                 f = SOCKET_FAILURE_CORE_DUMP;
2033         else
2034                 assert_not_reached("Unknown code");
2035
2036         if (s->control_command) {
2037                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2038
2039                 if (s->control_command->ignore)
2040                         f = SOCKET_SUCCESS;
2041         }
2042
2043         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2044                       u->id,
2045                       "%s control process exited, code=%s status=%i",
2046                       u->id, sigchld_code_to_string(code), status);
2047
2048         if (f != SOCKET_SUCCESS)
2049                 s->result = f;
2050
2051         if (s->control_command &&
2052             s->control_command->command_next &&
2053             f == SOCKET_SUCCESS) {
2054
2055                 log_debug_unit(u->id,
2056                                "%s running next command for state %s",
2057                                u->id, socket_state_to_string(s->state));
2058                 socket_run_next(s);
2059         } else {
2060                 s->control_command = NULL;
2061                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2062
2063                 /* No further commands for this step, so let's figure
2064                  * out what to do next */
2065
2066                 log_debug_unit(u->id,
2067                                "%s got final SIGCHLD for state %s",
2068                                u->id, socket_state_to_string(s->state));
2069
2070                 switch (s->state) {
2071
2072                 case SOCKET_START_PRE:
2073                         if (f == SOCKET_SUCCESS)
2074                                 socket_enter_start_post(s);
2075                         else
2076                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2077                         break;
2078
2079                 case SOCKET_START_POST:
2080                         if (f == SOCKET_SUCCESS)
2081                                 socket_enter_listening(s);
2082                         else
2083                                 socket_enter_stop_pre(s, f);
2084                         break;
2085
2086                 case SOCKET_STOP_PRE:
2087                 case SOCKET_STOP_PRE_SIGTERM:
2088                 case SOCKET_STOP_PRE_SIGKILL:
2089                         socket_enter_stop_post(s, f);
2090                         break;
2091
2092                 case SOCKET_STOP_POST:
2093                 case SOCKET_FINAL_SIGTERM:
2094                 case SOCKET_FINAL_SIGKILL:
2095                         socket_enter_dead(s, f);
2096                         break;
2097
2098                 default:
2099                         assert_not_reached("Uh, control process died at wrong time.");
2100                 }
2101         }
2102
2103         /* Notify clients about changed exit status */
2104         unit_add_to_dbus_queue(u);
2105 }
2106
2107 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2108         Socket *s = SOCKET(u);
2109
2110         assert(s);
2111         assert(elapsed == 1);
2112         assert(w == &s->timer_watch);
2113
2114         switch (s->state) {
2115
2116         case SOCKET_START_PRE:
2117                 log_warning_unit(u->id,
2118                                  "%s starting timed out. Terminating.", u->id);
2119                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2120                 break;
2121
2122         case SOCKET_START_POST:
2123                 log_warning_unit(u->id,
2124                                  "%s starting timed out. Stopping.", u->id);
2125                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2126                 break;
2127
2128         case SOCKET_STOP_PRE:
2129                 log_warning_unit(u->id,
2130                                  "%s stopping timed out. Terminating.", u->id);
2131                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2132                 break;
2133
2134         case SOCKET_STOP_PRE_SIGTERM:
2135                 if (s->kill_context.send_sigkill) {
2136                         log_warning_unit(u->id,
2137                                          "%s stopping timed out. Killing.", u->id);
2138                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2139                 } else {
2140                         log_warning_unit(u->id,
2141                                          "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2142                                          u->id);
2143                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2144                 }
2145                 break;
2146
2147         case SOCKET_STOP_PRE_SIGKILL:
2148                 log_warning_unit(u->id,
2149                                  "%s still around after SIGKILL. Ignoring.", u->id);
2150                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2151                 break;
2152
2153         case SOCKET_STOP_POST:
2154                 log_warning_unit(u->id,
2155                                  "%s stopping timed out (2). Terminating.", u->id);
2156                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2157                 break;
2158
2159         case SOCKET_FINAL_SIGTERM:
2160                 if (s->kill_context.send_sigkill) {
2161                         log_warning_unit(u->id,
2162                                          "%s stopping timed out (2). Killing.", u->id);
2163                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2164                 } else {
2165                         log_warning_unit(u->id,
2166                                          "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2167                                          u->id);
2168                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2169                 }
2170                 break;
2171
2172         case SOCKET_FINAL_SIGKILL:
2173                 log_warning_unit(u->id,
2174                                  "%s still around after SIGKILL (2). Entering failed mode.",
2175                                  u->id);
2176                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2177                 break;
2178
2179         default:
2180                 assert_not_reached("Timeout at wrong time.");
2181         }
2182 }
2183
2184 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2185         int *rfds;
2186         unsigned rn_fds, k;
2187         SocketPort *p;
2188
2189         assert(s);
2190         assert(fds);
2191         assert(n_fds);
2192
2193         /* Called from the service code for requesting our fds */
2194
2195         rn_fds = 0;
2196         LIST_FOREACH(port, p, s->ports)
2197                 if (p->fd >= 0)
2198                         rn_fds++;
2199
2200         if (rn_fds <= 0) {
2201                 *fds = NULL;
2202                 *n_fds = 0;
2203                 return 0;
2204         }
2205
2206         if (!(rfds = new(int, rn_fds)))
2207                 return -ENOMEM;
2208
2209         k = 0;
2210         LIST_FOREACH(port, p, s->ports)
2211                 if (p->fd >= 0)
2212                         rfds[k++] = p->fd;
2213
2214         assert(k == rn_fds);
2215
2216         *fds = rfds;
2217         *n_fds = rn_fds;
2218
2219         return 0;
2220 }
2221
2222 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2223         assert(s);
2224
2225         /* The service is dead. Dang!
2226          *
2227          * This is strictly for one-instance-for-all-connections
2228          * services. */
2229
2230         if (s->state == SOCKET_RUNNING) {
2231                 log_debug_unit(UNIT(s)->id,
2232                                "%s got notified about service death (failed permanently: %s)",
2233                                UNIT(s)->id, yes_no(failed_permanent));
2234                 if (failed_permanent)
2235                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2236                 else
2237                         socket_enter_listening(s);
2238         }
2239 }
2240
2241 void socket_connection_unref(Socket *s) {
2242         assert(s);
2243
2244         /* The service is dead. Yay!
2245          *
2246          * This is strictly for one-instance-per-connection
2247          * services. */
2248
2249         assert(s->n_connections > 0);
2250         s->n_connections--;
2251
2252         log_debug_unit(UNIT(s)->id,
2253                        "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2254 }
2255
2256 static void socket_reset_failed(Unit *u) {
2257         Socket *s = SOCKET(u);
2258
2259         assert(s);
2260
2261         if (s->state == SOCKET_FAILED)
2262                 socket_set_state(s, SOCKET_DEAD);
2263
2264         s->result = SOCKET_SUCCESS;
2265 }
2266
2267 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2268         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2269 }
2270
2271 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2272         [SOCKET_DEAD] = "dead",
2273         [SOCKET_START_PRE] = "start-pre",
2274         [SOCKET_START_POST] = "start-post",
2275         [SOCKET_LISTENING] = "listening",
2276         [SOCKET_RUNNING] = "running",
2277         [SOCKET_STOP_PRE] = "stop-pre",
2278         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2279         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2280         [SOCKET_STOP_POST] = "stop-post",
2281         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2282         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2283         [SOCKET_FAILED] = "failed"
2284 };
2285
2286 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2287
2288 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2289         [SOCKET_EXEC_START_PRE] = "StartPre",
2290         [SOCKET_EXEC_START_POST] = "StartPost",
2291         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2292         [SOCKET_EXEC_STOP_POST] = "StopPost"
2293 };
2294
2295 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2296
2297 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2298         [SOCKET_SUCCESS] = "success",
2299         [SOCKET_FAILURE_RESOURCES] = "resources",
2300         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2301         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2302         [SOCKET_FAILURE_SIGNAL] = "signal",
2303         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2304         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2305 };
2306
2307 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2308
2309 const UnitVTable socket_vtable = {
2310         .object_size = sizeof(Socket),
2311
2312         .sections =
2313                 "Unit\0"
2314                 "Socket\0"
2315                 "Install\0",
2316
2317         .exec_context_offset = offsetof(Socket, exec_context),
2318         .exec_section = "Socket",
2319
2320         .init = socket_init,
2321         .done = socket_done,
2322         .load = socket_load,
2323
2324         .kill = socket_kill,
2325
2326         .coldplug = socket_coldplug,
2327
2328         .dump = socket_dump,
2329
2330         .start = socket_start,
2331         .stop = socket_stop,
2332
2333         .serialize = socket_serialize,
2334         .deserialize_item = socket_deserialize_item,
2335         .distribute_fds = socket_distribute_fds,
2336
2337         .active_state = socket_active_state,
2338         .sub_state_to_string = socket_sub_state_to_string,
2339
2340         .check_gc = socket_check_gc,
2341
2342         .fd_event = socket_fd_event,
2343         .sigchld_event = socket_sigchld_event,
2344         .timer_event = socket_timer_event,
2345
2346         .reset_failed = socket_reset_failed,
2347
2348         .bus_interface = "org.freedesktop.systemd1.Socket",
2349         .bus_message_handler = bus_socket_message_handler,
2350         .bus_invalidating_properties =  bus_socket_invalidating_properties,
2351
2352         .status_message_formats = {
2353                 /*.starting_stopping = {
2354                         [0] = "Starting socket %s...",
2355                         [1] = "Stopping socket %s...",
2356                 },*/
2357                 .finished_start_job = {
2358                         [JOB_DONE]       = "Listening on %s.",
2359                         [JOB_FAILED]     = "Failed to listen on %s.",
2360                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2361                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2362                 },
2363                 .finished_stop_job = {
2364                         [JOB_DONE]       = "Closed %s.",
2365                         [JOB_FAILED]     = "Failed stopping %s.",
2366                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2367                 },
2368         },
2369 };