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