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: "PID_FMT"\n",
 474                         prefix, 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                 break;
 683         }
 684
 685         default:
 686                 assert_not_reached("Unhandled socket type.");
 687         }
 688
 689         *instance = r;
 690         return 0;
 691 }
 692
 693 static void socket_close_fds(Socket *s) {
 694         SocketPort *p;
 695
 696         assert(s);
 697
 698         LIST_FOREACH(port, p, s->ports) {
 699
 700                 p->event_source = sd_event_source_unref(p->event_source);
 701
 702                 if (p->fd < 0)
 703                         continue;
 704
 705                 p->fd = safe_close(p->fd);
 706
 707                 /* One little note: we should never delete any sockets
 708                  * in the file system here! After all some other
 709                  * process we spawned might still have a reference of
 710                  * this fd and wants to continue to use it. Therefore
 711                  * we delete sockets in the file system before we
 712                  * create a new one, not after we stopped using
 713                  * one! */
 714         }
 715 }
 716
 717 static void socket_apply_socket_options(Socket *s, int fd) {
 718         assert(s);
 719         assert(fd >= 0);
 720
 721         if (s->keep_alive) {
 722                 int b = s->keep_alive;
 723                 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
 724                         log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
 725         }
 726
 727         if (s->broadcast) {
 728                 int one = 1;
 729                 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
 730                         log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
 731         }
 732
 733         if (s->pass_cred) {
 734                 int one = 1;
 735                 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
 736                         log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
 737         }
 738
 739         if (s->pass_sec) {
 740                 int one = 1;
 741                 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
 742                         log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
 743         }
 744
 745         if (s->priority >= 0)
 746                 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
 747                         log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
 748
 749         if (s->receive_buffer > 0) {
 750                 int value = (int) s->receive_buffer;
 751
 752                 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
 753
 754                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
 755                         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
 756                                 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
 757         }
 758
 759         if (s->send_buffer > 0) {
 760                 int value = (int) s->send_buffer;
 761                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
 762                         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
 763                                 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
 764         }
 765
 766         if (s->mark >= 0)
 767                 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
 768                         log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
 769
 770         if (s->ip_tos >= 0)
 771                 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
 772                         log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
 773
 774         if (s->ip_ttl >= 0) {
 775                 int r, x;
 776
 777                 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
 778
 779                 if (socket_ipv6_is_supported())
 780                         x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
 781                 else {
 782                         x = -1;
 783                         errno = EAFNOSUPPORT;
 784                 }
 785
 786                 if (r < 0 && x < 0)
 787                         log_warning_unit(UNIT(s)->id,
 788                                          "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
 789         }
 790
 791         if (s->tcp_congestion)
 792                 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
 793                         log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
 794
 795         if (s->reuse_port) {
 796                 int b = s->reuse_port;
 797                 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
 798                         log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
 799         }
 800
 801         if (s->smack_ip_in)
 802                 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
 803                         log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
 804
 805         if (s->smack_ip_out)
 806                 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
 807                         log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
 808 }
 809
 810 static void socket_apply_fifo_options(Socket *s, int fd) {
 811         assert(s);
 812         assert(fd >= 0);
 813
 814         if (s->pipe_size > 0)
 815                 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
 816                         log_warning_unit(UNIT(s)->id,
 817                                          "F_SETPIPE_SZ: %m");
 818
 819         if (s->smack)
 820                 if (smack_label_fd(fd, s->smack) < 0)
 821                         log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
 822 }
 823
 824 static int fifo_address_create(
 825                 const char *path,
 826                 mode_t directory_mode,
 827                 mode_t socket_mode,
 828                 int *_fd) {
 829
 830         int fd = -1, r = 0;
 831         struct stat st;
 832         mode_t old_mask;
 833
 834         assert(path);
 835         assert(_fd);
 836
 837         mkdir_parents_label(path, directory_mode);
 838
 839         r = label_context_set(path, S_IFIFO);
 840         if (r < 0)
 841                 goto fail;
 842
 843         /* Enforce the right access mode for the fifo */
 844         old_mask = umask(~ socket_mode);
 845
 846         /* Include the original umask in our mask */
 847         umask(~socket_mode | old_mask);
 848
 849         r = mkfifo(path, socket_mode);
 850         umask(old_mask);
 851
 852         if (r < 0 && errno != EEXIST) {
 853                 r = -errno;
 854                 goto fail;
 855         }
 856
 857         if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 858                 r = -errno;
 859                 goto fail;
 860         }
 861
 862         label_context_clear();
 863
 864         if (fstat(fd, &st) < 0) {
 865                 r = -errno;
 866                 goto fail;
 867         }
 868
 869         if (!S_ISFIFO(st.st_mode) ||
 870             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
 871             st.st_uid != getuid() ||
 872             st.st_gid != getgid()) {
 873
 874                 r = -EEXIST;
 875                 goto fail;
 876         }
 877
 878         *_fd = fd;
 879         return 0;
 880
 881 fail:
 882         label_context_clear();
 883         safe_close(fd);
 884
 885         return r;
 886 }
 887
 888 static int special_address_create(
 889                 const char *path,
 890                 int *_fd) {
 891
 892         int fd = -1, r = 0;
 893         struct stat st;
 894
 895         assert(path);
 896         assert(_fd);
 897
 898         if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 899                 r = -errno;
 900                 goto fail;
 901         }
 902
 903         if (fstat(fd, &st) < 0) {
 904                 r = -errno;
 905                 goto fail;
 906         }
 907
 908         /* Check whether this is a /proc, /sys or /dev file or char device */
 909         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 910                 r = -EEXIST;
 911                 goto fail;
 912         }
 913
 914         *_fd = fd;
 915         return 0;
 916
 917 fail:
 918         safe_close(fd);
 919
 920         return r;
 921 }
 922
 923 static int mq_address_create(
 924                 const char *path,
 925                 mode_t mq_mode,
 926                 long maxmsg,
 927                 long msgsize,
 928                 int *_fd) {
 929
 930         int fd = -1, r = 0;
 931         struct stat st;
 932         mode_t old_mask;
 933         struct mq_attr _attr, *attr = NULL;
 934
 935         assert(path);
 936         assert(_fd);
 937
 938         if (maxmsg > 0 && msgsize > 0) {
 939                 zero(_attr);
 940                 _attr.mq_flags = O_NONBLOCK;
 941                 _attr.mq_maxmsg = maxmsg;
 942                 _attr.mq_msgsize = msgsize;
 943                 attr = &_attr;
 944         }
 945
 946         /* Enforce the right access mode for the mq */
 947         old_mask = umask(~ mq_mode);
 948
 949         /* Include the original umask in our mask */
 950         umask(~mq_mode | old_mask);
 951
 952         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
 953         umask(old_mask);
 954
 955         if (fd < 0) {
 956                 r = -errno;
 957                 goto fail;
 958         }
 959
 960         if (fstat(fd, &st) < 0) {
 961                 r = -errno;
 962                 goto fail;
 963         }
 964
 965         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
 966             st.st_uid != getuid() ||
 967             st.st_gid != getgid()) {
 968
 969                 r = -EEXIST;
 970                 goto fail;
 971         }
 972
 973         *_fd = fd;
 974         return 0;
 975
 976 fail:
 977         safe_close(fd);
 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_ISSET(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                         r = socket_address_listen(
1015                                         &p->address,
1016                                         SOCK_CLOEXEC|SOCK_NONBLOCK,
1017                                         s->backlog,
1018                                         s->bind_ipv6_only,
1019                                         s->bind_to_device,
1020                                         s->free_bind,
1021                                         s->transparent,
1022                                         s->directory_mode,
1023                                         s->socket_mode,
1024                                         label);
1025                         if (r < 0)
1026                                 goto rollback;
1027
1028                         p->fd = r;
1029                         socket_apply_socket_options(s, p->fd);
1030
1031                 } else  if (p->type == SOCKET_SPECIAL) {
1032
1033                         r = special_address_create(
1034                                         p->path,
1035                                         &p->fd);
1036                         if (r < 0)
1037                                 goto rollback;
1038
1039                 } else  if (p->type == SOCKET_FIFO) {
1040
1041                         r = fifo_address_create(
1042                                         p->path,
1043                                         s->directory_mode,
1044                                         s->socket_mode,
1045                                         &p->fd);
1046                         if (r < 0)
1047                                 goto rollback;
1048
1049                         socket_apply_fifo_options(s, p->fd);
1050                 } else if (p->type == SOCKET_MQUEUE) {
1051
1052                         r = mq_address_create(
1053                                         p->path,
1054                                         s->socket_mode,
1055                                         s->mq_maxmsg,
1056                                         s->mq_msgsize,
1057                                         &p->fd);
1058                         if (r < 0)
1059                                 goto rollback;
1060                 } else
1061                         assert_not_reached("Unknown port type");
1062         }
1063
1064         label_free(label);
1065         return 0;
1066
1067 rollback:
1068         socket_close_fds(s);
1069         label_free(label);
1070         return r;
1071 }
1072
1073 static void socket_unwatch_fds(Socket *s) {
1074         SocketPort *p;
1075         int r;
1076
1077         assert(s);
1078
1079         LIST_FOREACH(port, p, s->ports) {
1080                 if (p->fd < 0)
1081                         continue;
1082
1083                 if (p->event_source) {
1084                         r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1085                         if (r < 0)
1086                                 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1087                 }
1088         }
1089 }
1090
1091 static int socket_watch_fds(Socket *s) {
1092         SocketPort *p;
1093         int r;
1094
1095         assert(s);
1096
1097         LIST_FOREACH(port, p, s->ports) {
1098                 if (p->fd < 0)
1099                         continue;
1100
1101                 if (p->event_source)
1102                         r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1103                 else
1104                         r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1105
1106                 if (r < 0) {
1107                         log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1108                         goto fail;
1109                 }
1110         }
1111
1112         return 0;
1113
1114 fail:
1115         socket_unwatch_fds(s);
1116         return r;
1117 }
1118
1119 static void socket_set_state(Socket *s, SocketState state) {
1120         SocketState old_state;
1121         assert(s);
1122
1123         old_state = s->state;
1124         s->state = state;
1125
1126         if (state != SOCKET_START_PRE &&
1127             state != SOCKET_START_POST &&
1128             state != SOCKET_STOP_PRE &&
1129             state != SOCKET_STOP_PRE_SIGTERM &&
1130             state != SOCKET_STOP_PRE_SIGKILL &&
1131             state != SOCKET_STOP_POST &&
1132             state != SOCKET_FINAL_SIGTERM &&
1133             state != SOCKET_FINAL_SIGKILL) {
1134
1135                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1136                 socket_unwatch_control_pid(s);
1137                 s->control_command = NULL;
1138                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1139         }
1140
1141         if (state != SOCKET_LISTENING)
1142                 socket_unwatch_fds(s);
1143
1144         if (state != SOCKET_START_POST &&
1145             state != SOCKET_LISTENING &&
1146             state != SOCKET_RUNNING &&
1147             state != SOCKET_STOP_PRE &&
1148             state != SOCKET_STOP_PRE_SIGTERM &&
1149             state != SOCKET_STOP_PRE_SIGKILL)
1150                 socket_close_fds(s);
1151
1152         if (state != old_state)
1153                 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1154                                UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1155
1156         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1157 }
1158
1159 static int socket_coldplug(Unit *u) {
1160         Socket *s = SOCKET(u);
1161         int r;
1162
1163         assert(s);
1164         assert(s->state == SOCKET_DEAD);
1165
1166         if (s->deserialized_state == s->state)
1167                 return 0;
1168
1169         if (s->deserialized_state == SOCKET_START_PRE ||
1170             s->deserialized_state == SOCKET_START_POST ||
1171             s->deserialized_state == SOCKET_STOP_PRE ||
1172             s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1173             s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1174             s->deserialized_state == SOCKET_STOP_POST ||
1175             s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1176             s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1177
1178                 if (s->control_pid <= 0)
1179                         return -EBADMSG;
1180
1181                 r = unit_watch_pid(UNIT(s), s->control_pid);
1182                 if (r < 0)
1183                         return r;
1184
1185                 r = socket_arm_timer(s);
1186                 if (r < 0)
1187                         return r;
1188         }
1189
1190         if (s->deserialized_state == SOCKET_START_POST ||
1191             s->deserialized_state == SOCKET_LISTENING ||
1192             s->deserialized_state == SOCKET_RUNNING ||
1193             s->deserialized_state == SOCKET_STOP_PRE ||
1194             s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1195             s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1196                 r = socket_open_fds(s);
1197                 if (r < 0)
1198                         return r;
1199         }
1200
1201         if (s->deserialized_state == SOCKET_LISTENING) {
1202                 r = socket_watch_fds(s);
1203                 if (r < 0)
1204                         return r;
1205         }
1206
1207         socket_set_state(s, s->deserialized_state);
1208         return 0;
1209 }
1210
1211 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1212         pid_t pid;
1213         int r;
1214         char **argv;
1215
1216         assert(s);
1217         assert(c);
1218         assert(_pid);
1219
1220         unit_realize_cgroup(UNIT(s));
1221
1222         r = unit_setup_exec_runtime(UNIT(s));
1223         if (r < 0)
1224                 goto fail;
1225
1226         r = socket_arm_timer(s);
1227         if (r < 0)
1228                 goto fail;
1229
1230         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1231         if (r < 0)
1232                 goto fail;
1233
1234         r = exec_spawn(c,
1235                        argv,
1236                        &s->exec_context,
1237                        NULL, 0,
1238                        UNIT(s)->manager->environment,
1239                        true,
1240                        true,
1241                        true,
1242                        UNIT(s)->manager->confirm_spawn,
1243                        UNIT(s)->manager->cgroup_supported,
1244                        UNIT(s)->cgroup_path,
1245                        manager_get_runtime_prefix(UNIT(s)->manager),
1246                        UNIT(s)->id,
1247                        0,
1248                        NULL,
1249                        s->exec_runtime,
1250                        &pid);
1251
1252         strv_free(argv);
1253         if (r < 0)
1254                 goto fail;
1255
1256         r = unit_watch_pid(UNIT(s), pid);
1257         if (r < 0)
1258                 /* FIXME: we need to do something here */
1259                 goto fail;
1260
1261         *_pid = pid;
1262
1263         return 0;
1264
1265 fail:
1266         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1267
1268         return r;
1269 }
1270
1271 static void socket_enter_dead(Socket *s, SocketResult f) {
1272         assert(s);
1273
1274         if (f != SOCKET_SUCCESS)
1275                 s->result = f;
1276
1277         exec_runtime_destroy(s->exec_runtime);
1278         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1279
1280         exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1281
1282         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1283 }
1284
1285 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1286
1287 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1288         int r;
1289         assert(s);
1290
1291         if (f != SOCKET_SUCCESS)
1292                 s->result = f;
1293
1294         socket_unwatch_control_pid(s);
1295
1296         s->control_command_id = SOCKET_EXEC_STOP_POST;
1297
1298         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1299                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1300                         goto fail;
1301
1302                 socket_set_state(s, SOCKET_STOP_POST);
1303         } else
1304                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1305
1306         return;
1307
1308 fail:
1309         log_warning_unit(UNIT(s)->id,
1310                          "%s failed to run 'stop-post' task: %s",
1311                          UNIT(s)->id, strerror(-r));
1312         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1313 }
1314
1315 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1316         int r;
1317
1318         assert(s);
1319
1320         if (f != SOCKET_SUCCESS)
1321                 s->result = f;
1322
1323         r = unit_kill_context(
1324                         UNIT(s),
1325                         &s->kill_context,
1326                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1327                         -1,
1328                         s->control_pid,
1329                         false);
1330         if (r < 0)
1331                 goto fail;
1332
1333         if (r > 0) {
1334                 r = socket_arm_timer(s);
1335                 if (r < 0)
1336                         goto fail;
1337
1338                 socket_set_state(s, state);
1339         } else if (state == SOCKET_STOP_PRE_SIGTERM)
1340                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1341         else if (state == SOCKET_STOP_PRE_SIGKILL)
1342                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1343         else if (state == SOCKET_FINAL_SIGTERM)
1344                 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1345         else
1346                 socket_enter_dead(s, SOCKET_SUCCESS);
1347
1348         return;
1349
1350 fail:
1351         log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1352
1353         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1354                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1355         else
1356                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1357 }
1358
1359 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1360         int r;
1361         assert(s);
1362
1363         if (f != SOCKET_SUCCESS)
1364                 s->result = f;
1365
1366         socket_unwatch_control_pid(s);
1367
1368         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1369
1370         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1371                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1372                         goto fail;
1373
1374                 socket_set_state(s, SOCKET_STOP_PRE);
1375         } else
1376                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1377
1378         return;
1379
1380 fail:
1381         log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1382         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1383 }
1384
1385 static void socket_enter_listening(Socket *s) {
1386         int r;
1387         assert(s);
1388
1389         r = socket_watch_fds(s);
1390         if (r < 0) {
1391                 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1392                 goto fail;
1393         }
1394
1395         socket_set_state(s, SOCKET_LISTENING);
1396         return;
1397
1398 fail:
1399         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1400 }
1401
1402 static void socket_enter_start_post(Socket *s) {
1403         int r;
1404         assert(s);
1405
1406         r = socket_open_fds(s);
1407         if (r < 0) {
1408                 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1409                 goto fail;
1410         }
1411
1412         socket_unwatch_control_pid(s);
1413
1414         s->control_command_id = SOCKET_EXEC_START_POST;
1415
1416         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1417                 r = socket_spawn(s, s->control_command, &s->control_pid);
1418                 if (r < 0) {
1419                         log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1420                         goto fail;
1421                 }
1422
1423                 socket_set_state(s, SOCKET_START_POST);
1424         } else
1425                 socket_enter_listening(s);
1426
1427         return;
1428
1429 fail:
1430         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1431 }
1432
1433 static void socket_enter_start_pre(Socket *s) {
1434         int r;
1435         assert(s);
1436
1437         socket_unwatch_control_pid(s);
1438
1439         s->control_command_id = SOCKET_EXEC_START_PRE;
1440
1441         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1442                 r = socket_spawn(s, s->control_command, &s->control_pid);
1443                 if (r < 0)
1444                         goto fail;
1445
1446                 socket_set_state(s, SOCKET_START_PRE);
1447         } else
1448                 socket_enter_start_post(s);
1449
1450         return;
1451
1452 fail:
1453         log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1454         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1455 }
1456
1457 static void socket_enter_running(Socket *s, int cfd) {
1458         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1459         int r;
1460
1461         assert(s);
1462
1463         /* We don't take connections anymore if we are supposed to
1464          * shut down anyway */
1465         if (unit_stop_pending(UNIT(s))) {
1466
1467                 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1468
1469                 if (cfd >= 0)
1470                         safe_close(cfd);
1471                 else  {
1472                         /* Flush all sockets by closing and reopening them */
1473                         socket_close_fds(s);
1474
1475                         r = socket_open_fds(s);
1476                         if (r < 0) {
1477                                 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1478                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1479                                 return;
1480                         }
1481
1482                         r = socket_watch_fds(s);
1483                         if (r < 0) {
1484                                 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1485                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1486                         }
1487                 }
1488
1489                 return;
1490         }
1491
1492         if (cfd < 0) {
1493                 Iterator i;
1494                 Unit *other;
1495                 bool pending = false;
1496
1497                 /* If there's already a start pending don't bother to
1498                  * do anything */
1499                 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1500                         if (unit_active_or_pending(other)) {
1501                                 pending = true;
1502                                 break;
1503                         }
1504
1505                 if (!pending) {
1506                         if (!UNIT_ISSET(s->service)) {
1507                                 log_error_unit(UNIT(s)->id, "%s: service to activate vanished, refusing activation.", UNIT(s)->id);
1508                                 r = -ENOENT;
1509                                 goto fail;
1510                         }
1511
1512                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1513                         if (r < 0)
1514                                 goto fail;
1515                 }
1516
1517                 socket_set_state(s, SOCKET_RUNNING);
1518         } else {
1519                 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1520                 Service *service;
1521
1522                 if (s->n_connections >= s->max_connections) {
1523                         log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1524                         safe_close(cfd);
1525                         return;
1526                 }
1527
1528                 r = socket_instantiate_service(s);
1529                 if (r < 0)
1530                         goto fail;
1531
1532                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1533                 if (r < 0) {
1534                         if (r != -ENOTCONN)
1535                                 goto fail;
1536
1537                         /* ENOTCONN is legitimate if TCP RST was received.
1538                          * This connection is over, but the socket unit lives on. */
1539                         safe_close(cfd);
1540                         return;
1541                 }
1542
1543                 prefix = unit_name_to_prefix(UNIT(s)->id);
1544                 if (!prefix) {
1545                         r = -ENOMEM;
1546                         goto fail;
1547                 }
1548
1549                 name = unit_name_build(prefix, instance, ".service");
1550                 if (!name) {
1551                         r = -ENOMEM;
1552                         goto fail;
1553                 }
1554
1555                 r = unit_add_name(UNIT_DEREF(s->service), name);
1556                 if (r < 0)
1557                         goto fail;
1558
1559                 service = SERVICE(UNIT_DEREF(s->service));
1560                 unit_ref_unset(&s->service);
1561                 s->n_accepted ++;
1562
1563                 UNIT(service)->no_gc = false;
1564
1565                 unit_choose_id(UNIT(service), name);
1566
1567                 r = service_set_socket_fd(service, cfd, s);
1568                 if (r < 0)
1569                         goto fail;
1570
1571                 cfd = -1;
1572                 s->n_connections ++;
1573
1574                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1575                 if (r < 0)
1576                         goto fail;
1577
1578                 /* Notify clients about changed counters */
1579                 unit_add_to_dbus_queue(UNIT(s));
1580         }
1581
1582         return;
1583
1584 fail:
1585         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",
1586                          UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1587                          bus_error_message(&error, r));
1588
1589         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1590         safe_close(cfd);
1591 }
1592
1593 static void socket_run_next(Socket *s) {
1594         int r;
1595
1596         assert(s);
1597         assert(s->control_command);
1598         assert(s->control_command->command_next);
1599
1600         socket_unwatch_control_pid(s);
1601
1602         s->control_command = s->control_command->command_next;
1603
1604         r = socket_spawn(s, s->control_command, &s->control_pid);
1605         if (r < 0)
1606                 goto fail;
1607
1608         return;
1609
1610 fail:
1611         log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1612
1613         if (s->state == SOCKET_START_POST)
1614                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1615         else if (s->state == SOCKET_STOP_POST)
1616                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1617         else
1618                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1619 }
1620
1621 static int socket_start(Unit *u) {
1622         Socket *s = SOCKET(u);
1623
1624         assert(s);
1625
1626         /* We cannot fulfill this request right now, try again later
1627          * please! */
1628         if (s->state == SOCKET_STOP_PRE ||
1629             s->state == SOCKET_STOP_PRE_SIGKILL ||
1630             s->state == SOCKET_STOP_PRE_SIGTERM ||
1631             s->state == SOCKET_STOP_POST ||
1632             s->state == SOCKET_FINAL_SIGTERM ||
1633             s->state == SOCKET_FINAL_SIGKILL)
1634                 return -EAGAIN;
1635
1636         if (s->state == SOCKET_START_PRE ||
1637             s->state == SOCKET_START_POST)
1638                 return 0;
1639
1640         /* Cannot run this without the service being around */
1641         if (UNIT_ISSET(s->service)) {
1642                 Service *service;
1643
1644                 service = SERVICE(UNIT_DEREF(s->service));
1645
1646                 if (UNIT(service)->load_state != UNIT_LOADED) {
1647                         log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1648                         return -ENOENT;
1649                 }
1650
1651                 /* If the service is already active we cannot start the
1652                  * socket */
1653                 if (service->state != SERVICE_DEAD &&
1654                     service->state != SERVICE_FAILED &&
1655                     service->state != SERVICE_AUTO_RESTART) {
1656                         log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1657                         return -EBUSY;
1658                 }
1659
1660 #ifdef HAVE_SYSV_COMPAT
1661                 if (service->is_sysv) {
1662                         log_error_unit(u->id,
1663                                        "Using SysV services for socket activation is not supported. Refusing.");
1664                         return -ENOENT;
1665                 }
1666 #endif
1667         }
1668
1669         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1670
1671         s->result = SOCKET_SUCCESS;
1672         socket_enter_start_pre(s);
1673
1674         return 0;
1675 }
1676
1677 static int socket_stop(Unit *u) {
1678         Socket *s = SOCKET(u);
1679
1680         assert(s);
1681
1682         /* Already on it */
1683         if (s->state == SOCKET_STOP_PRE ||
1684             s->state == SOCKET_STOP_PRE_SIGTERM ||
1685             s->state == SOCKET_STOP_PRE_SIGKILL ||
1686             s->state == SOCKET_STOP_POST ||
1687             s->state == SOCKET_FINAL_SIGTERM ||
1688             s->state == SOCKET_FINAL_SIGKILL)
1689                 return 0;
1690
1691         /* If there's already something running we go directly into
1692          * kill mode. */
1693         if (s->state == SOCKET_START_PRE ||
1694             s->state == SOCKET_START_POST) {
1695                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1696                 return -EAGAIN;
1697         }
1698
1699         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1700
1701         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1702         return 0;
1703 }
1704
1705 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1706         Socket *s = SOCKET(u);
1707         SocketPort *p;
1708         int r;
1709
1710         assert(u);
1711         assert(f);
1712         assert(fds);
1713
1714         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1715         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1716         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1717
1718         if (s->control_pid > 0)
1719                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
1720
1721         if (s->control_command_id >= 0)
1722                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1723
1724         LIST_FOREACH(port, p, s->ports) {
1725                 int copy;
1726
1727                 if (p->fd < 0)
1728                         continue;
1729
1730                 copy = fdset_put_dup(fds, p->fd);
1731                 if (copy < 0)
1732                         return copy;
1733
1734                 if (p->type == SOCKET_SOCKET) {
1735                         _cleanup_free_ char *t = NULL;
1736
1737                         r = socket_address_print(&p->address, &t);
1738                         if (r < 0)
1739                                 return r;
1740
1741                         if (socket_address_family(&p->address) == AF_NETLINK)
1742                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1743                         else
1744                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1745
1746                 } else if (p->type == SOCKET_SPECIAL)
1747                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1748                 else if (p->type == SOCKET_MQUEUE)
1749                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1750                 else {
1751                         assert(p->type == SOCKET_FIFO);
1752                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1753                 }
1754         }
1755
1756         return 0;
1757 }
1758
1759 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1760         Socket *s = SOCKET(u);
1761
1762         assert(u);
1763         assert(key);
1764         assert(value);
1765
1766         if (streq(key, "state")) {
1767                 SocketState state;
1768
1769                 state = socket_state_from_string(value);
1770                 if (state < 0)
1771                         log_debug_unit(u->id, "Failed to parse state value %s", value);
1772                 else
1773                         s->deserialized_state = state;
1774         } else if (streq(key, "result")) {
1775                 SocketResult f;
1776
1777                 f = socket_result_from_string(value);
1778                 if (f < 0)
1779                         log_debug_unit(u->id, "Failed to parse result value %s", value);
1780                 else if (f != SOCKET_SUCCESS)
1781                         s->result = f;
1782
1783         } else if (streq(key, "n-accepted")) {
1784                 unsigned k;
1785
1786                 if (safe_atou(value, &k) < 0)
1787                         log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1788                 else
1789                         s->n_accepted += k;
1790         } else if (streq(key, "control-pid")) {
1791                 pid_t pid;
1792
1793                 if (parse_pid(value, &pid) < 0)
1794                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1795                 else
1796                         s->control_pid = pid;
1797         } else if (streq(key, "control-command")) {
1798                 SocketExecCommand id;
1799
1800                 id = socket_exec_command_from_string(value);
1801                 if (id < 0)
1802                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
1803                 else {
1804                         s->control_command_id = id;
1805                         s->control_command = s->exec_command[id];
1806                 }
1807         } else if (streq(key, "fifo")) {
1808                 int fd, skip = 0;
1809                 SocketPort *p;
1810
1811                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1812                         log_debug_unit(u->id, "Failed to parse fifo value %s", value);
1813                 else {
1814
1815                         LIST_FOREACH(port, p, s->ports)
1816                                 if (p->type == SOCKET_FIFO &&
1817                                     streq_ptr(p->path, value+skip))
1818                                         break;
1819
1820                         if (p) {
1821                                 safe_close(p->fd);
1822                                 p->fd = fdset_remove(fds, fd);
1823                         }
1824                 }
1825
1826         } else if (streq(key, "special")) {
1827                 int fd, skip = 0;
1828                 SocketPort *p;
1829
1830                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1831                         log_debug_unit(u->id, "Failed to parse special value %s", value);
1832                 else {
1833
1834                         LIST_FOREACH(port, p, s->ports)
1835                                 if (p->type == SOCKET_SPECIAL &&
1836                                     streq_ptr(p->path, value+skip))
1837                                         break;
1838
1839                         if (p) {
1840                                 safe_close(p->fd);
1841                                 p->fd = fdset_remove(fds, fd);
1842                         }
1843                 }
1844
1845         } else if (streq(key, "mqueue")) {
1846                 int fd, skip = 0;
1847                 SocketPort *p;
1848
1849                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1850                         log_debug_unit(u->id, "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                                 safe_close(p->fd);
1860                                 p->fd = fdset_remove(fds, fd);
1861                         }
1862                 }
1863
1864         } else if (streq(key, "socket")) {
1865                 int fd, type, skip = 0;
1866                 SocketPort *p;
1867
1868                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1869                         log_debug_unit(u->id, "Failed to parse socket value %s", value);
1870                 else {
1871
1872                         LIST_FOREACH(port, p, s->ports)
1873                                 if (socket_address_is(&p->address, value+skip, type))
1874                                         break;
1875
1876                         if (p) {
1877                                 safe_close(p->fd);
1878                                 p->fd = fdset_remove(fds, fd);
1879                         }
1880                 }
1881
1882         } else if (streq(key, "netlink")) {
1883                 int fd, skip = 0;
1884                 SocketPort *p;
1885
1886                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1887                         log_debug_unit(u->id, "Failed to parse socket value %s", value);
1888                 else {
1889
1890                         LIST_FOREACH(port, p, s->ports)
1891                                 if (socket_address_is_netlink(&p->address, value+skip))
1892                                         break;
1893
1894                         if (p) {
1895                                 safe_close(p->fd);
1896                                 p->fd = fdset_remove(fds, fd);
1897                         }
1898                 }
1899         } else
1900                 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
1901
1902         return 0;
1903 }
1904
1905 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1906         Socket *s = SOCKET(u);
1907         SocketPort *p;
1908
1909         assert(u);
1910
1911         LIST_FOREACH(port, p, s->ports) {
1912                 Iterator i;
1913                 int fd;
1914
1915                 if (p->type != SOCKET_SOCKET)
1916                         continue;
1917
1918                 if (p->fd >= 0)
1919                         continue;
1920
1921                 FDSET_FOREACH(fd, fds, i) {
1922                         if (socket_address_matches_fd(&p->address, fd)) {
1923                                 p->fd = fdset_remove(fds, fd);
1924                                 s->deserialized_state = SOCKET_LISTENING;
1925                                 break;
1926                         }
1927                 }
1928         }
1929
1930         return 0;
1931 }
1932
1933 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1934         assert(u);
1935
1936         return state_translation_table[SOCKET(u)->state];
1937 }
1938
1939 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1940         assert(u);
1941
1942         return socket_state_to_string(SOCKET(u)->state);
1943 }
1944
1945 const char* socket_port_type_to_string(SocketPort *p) {
1946
1947         assert(p);
1948
1949         switch (p->type) {
1950
1951         case SOCKET_SOCKET:
1952
1953                 switch (p->address.type) {
1954
1955                 case SOCK_STREAM:
1956                         return "Stream";
1957
1958                 case SOCK_DGRAM:
1959                         return "Datagram";
1960
1961                 case SOCK_SEQPACKET:
1962                         return "SequentialPacket";
1963
1964                 case SOCK_RAW:
1965                         if (socket_address_family(&p->address) == AF_NETLINK)
1966                                 return "Netlink";
1967
1968                 default:
1969                         return NULL;
1970                 }
1971
1972         case SOCKET_SPECIAL:
1973                 return "Special";
1974
1975         case SOCKET_MQUEUE:
1976                 return "MessageQueue";
1977
1978         case SOCKET_FIFO:
1979                 return "FIFO";
1980
1981         default:
1982                 return NULL;
1983         }
1984 }
1985
1986 _pure_ static bool socket_check_gc(Unit *u) {
1987         Socket *s = SOCKET(u);
1988
1989         assert(u);
1990
1991         return s->n_connections > 0;
1992 }
1993
1994 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1995         SocketPort *p = userdata;
1996         int cfd = -1;
1997
1998         assert(p);
1999         assert(fd >= 0);
2000
2001         if (p->socket->state != SOCKET_LISTENING)
2002                 return 0;
2003
2004         log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2005
2006         if (revents != EPOLLIN) {
2007
2008                 if (revents & EPOLLHUP)
2009                         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.",
2010                                        UNIT(p->socket)->id);
2011                 else
2012                         log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2013                                        UNIT(p->socket)->id, revents);
2014
2015                 goto fail;
2016         }
2017
2018         if (p->socket->accept &&
2019             p->type == SOCKET_SOCKET &&
2020             socket_address_can_accept(&p->address)) {
2021
2022                 for (;;) {
2023
2024                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2025                         if (cfd < 0) {
2026
2027                                 if (errno == EINTR)
2028                                         continue;
2029
2030                                 log_error_unit(UNIT(p->socket)->id,
2031                                                "Failed to accept socket: %m");
2032                                 goto fail;
2033                         }
2034
2035                         break;
2036                 }
2037
2038                 socket_apply_socket_options(p->socket, cfd);
2039         }
2040
2041         socket_enter_running(p->socket, cfd);
2042         return 0;
2043
2044 fail:
2045         socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2046         return 0;
2047 }
2048
2049 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2050         Socket *s = SOCKET(u);
2051         SocketResult f;
2052
2053         assert(s);
2054         assert(pid >= 0);
2055
2056         if (pid != s->control_pid)
2057                 return;
2058
2059         s->control_pid = 0;
2060
2061         if (is_clean_exit(code, status, NULL))
2062                 f = SOCKET_SUCCESS;
2063         else if (code == CLD_EXITED)
2064                 f = SOCKET_FAILURE_EXIT_CODE;
2065         else if (code == CLD_KILLED)
2066                 f = SOCKET_FAILURE_SIGNAL;
2067         else if (code == CLD_DUMPED)
2068                 f = SOCKET_FAILURE_CORE_DUMP;
2069         else
2070                 assert_not_reached("Unknown code");
2071
2072         if (s->control_command) {
2073                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2074
2075                 if (s->control_command->ignore)
2076                         f = SOCKET_SUCCESS;
2077         }
2078
2079         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2080                       u->id,
2081                       "%s control process exited, code=%s status=%i",
2082                       u->id, sigchld_code_to_string(code), status);
2083
2084         if (f != SOCKET_SUCCESS)
2085                 s->result = f;
2086
2087         if (s->control_command &&
2088             s->control_command->command_next &&
2089             f == SOCKET_SUCCESS) {
2090
2091                 log_debug_unit(u->id,
2092                                "%s running next command for state %s",
2093                                u->id, socket_state_to_string(s->state));
2094                 socket_run_next(s);
2095         } else {
2096                 s->control_command = NULL;
2097                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2098
2099                 /* No further commands for this step, so let's figure
2100                  * out what to do next */
2101
2102                 log_debug_unit(u->id,
2103                                "%s got final SIGCHLD for state %s",
2104                                u->id, socket_state_to_string(s->state));
2105
2106                 switch (s->state) {
2107
2108                 case SOCKET_START_PRE:
2109                         if (f == SOCKET_SUCCESS)
2110                                 socket_enter_start_post(s);
2111                         else
2112                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2113                         break;
2114
2115                 case SOCKET_START_POST:
2116                         if (f == SOCKET_SUCCESS)
2117                                 socket_enter_listening(s);
2118                         else
2119                                 socket_enter_stop_pre(s, f);
2120                         break;
2121
2122                 case SOCKET_STOP_PRE:
2123                 case SOCKET_STOP_PRE_SIGTERM:
2124                 case SOCKET_STOP_PRE_SIGKILL:
2125                         socket_enter_stop_post(s, f);
2126                         break;
2127
2128                 case SOCKET_STOP_POST:
2129                 case SOCKET_FINAL_SIGTERM:
2130                 case SOCKET_FINAL_SIGKILL:
2131                         socket_enter_dead(s, f);
2132                         break;
2133
2134                 default:
2135                         assert_not_reached("Uh, control process died at wrong time.");
2136                 }
2137         }
2138
2139         /* Notify clients about changed exit status */
2140         unit_add_to_dbus_queue(u);
2141 }
2142
2143 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2144         Socket *s = SOCKET(userdata);
2145
2146         assert(s);
2147         assert(s->timer_event_source == source);
2148
2149         switch (s->state) {
2150
2151         case SOCKET_START_PRE:
2152                 log_warning_unit(UNIT(s)->id,
2153                                  "%s starting timed out. Terminating.", UNIT(s)->id);
2154                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2155                 break;
2156
2157         case SOCKET_START_POST:
2158                 log_warning_unit(UNIT(s)->id,
2159                                  "%s starting timed out. Stopping.", UNIT(s)->id);
2160                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2161                 break;
2162
2163         case SOCKET_STOP_PRE:
2164                 log_warning_unit(UNIT(s)->id,
2165                                  "%s stopping timed out. Terminating.", UNIT(s)->id);
2166                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2167                 break;
2168
2169         case SOCKET_STOP_PRE_SIGTERM:
2170                 if (s->kill_context.send_sigkill) {
2171                         log_warning_unit(UNIT(s)->id,
2172                                          "%s stopping timed out. Killing.", UNIT(s)->id);
2173                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2174                 } else {
2175                         log_warning_unit(UNIT(s)->id,
2176                                          "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2177                                          UNIT(s)->id);
2178                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2179                 }
2180                 break;
2181
2182         case SOCKET_STOP_PRE_SIGKILL:
2183                 log_warning_unit(UNIT(s)->id,
2184                                  "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2185                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2186                 break;
2187
2188         case SOCKET_STOP_POST:
2189                 log_warning_unit(UNIT(s)->id,
2190                                  "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2191                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2192                 break;
2193
2194         case SOCKET_FINAL_SIGTERM:
2195                 if (s->kill_context.send_sigkill) {
2196                         log_warning_unit(UNIT(s)->id,
2197                                          "%s stopping timed out (2). Killing.", UNIT(s)->id);
2198                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2199                 } else {
2200                         log_warning_unit(UNIT(s)->id,
2201                                          "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2202                                          UNIT(s)->id);
2203                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2204                 }
2205                 break;
2206
2207         case SOCKET_FINAL_SIGKILL:
2208                 log_warning_unit(UNIT(s)->id,
2209                                  "%s still around after SIGKILL (2). Entering failed mode.",
2210                                  UNIT(s)->id);
2211                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2212                 break;
2213
2214         default:
2215                 assert_not_reached("Timeout at wrong time.");
2216         }
2217
2218         return 0;
2219 }
2220
2221 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2222         int *rfds;
2223         unsigned rn_fds, k;
2224         SocketPort *p;
2225
2226         assert(s);
2227         assert(fds);
2228         assert(n_fds);
2229
2230         /* Called from the service code for requesting our fds */
2231
2232         rn_fds = 0;
2233         LIST_FOREACH(port, p, s->ports)
2234                 if (p->fd >= 0)
2235                         rn_fds++;
2236
2237         if (rn_fds <= 0) {
2238                 *fds = NULL;
2239                 *n_fds = 0;
2240                 return 0;
2241         }
2242
2243         if (!(rfds = new(int, rn_fds)))
2244                 return -ENOMEM;
2245
2246         k = 0;
2247         LIST_FOREACH(port, p, s->ports)
2248                 if (p->fd >= 0)
2249                         rfds[k++] = p->fd;
2250
2251         assert(k == rn_fds);
2252
2253         *fds = rfds;
2254         *n_fds = rn_fds;
2255
2256         return 0;
2257 }
2258
2259 static void socket_reset_failed(Unit *u) {
2260         Socket *s = SOCKET(u);
2261
2262         assert(s);
2263
2264         if (s->state == SOCKET_FAILED)
2265                 socket_set_state(s, SOCKET_DEAD);
2266
2267         s->result = SOCKET_SUCCESS;
2268 }
2269
2270 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2271         assert(s);
2272
2273         /* The service is dead. Dang!
2274          *
2275          * This is strictly for one-instance-for-all-connections
2276          * services. */
2277
2278         if (s->state == SOCKET_RUNNING) {
2279                 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2280                 if (failed_permanent)
2281                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2282                 else
2283                         socket_enter_listening(s);
2284         }
2285 }
2286
2287 void socket_connection_unref(Socket *s) {
2288         assert(s);
2289
2290         /* The service is dead. Yay!
2291          *
2292          * This is strictly for one-instance-per-connection
2293          * services. */
2294
2295         assert(s->n_connections > 0);
2296         s->n_connections--;
2297
2298         log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2299 }
2300
2301 static void socket_trigger_notify(Unit *u, Unit *other) {
2302         Socket *s = SOCKET(u);
2303         Service *se;
2304
2305         assert(u);
2306         assert(other);
2307
2308         /* Don't propagate state changes from the service if we are
2309            already down or accepting connections */
2310         if ((s->state !=  SOCKET_RUNNING &&
2311             s->state != SOCKET_LISTENING) ||
2312             s->accept)
2313                 return;
2314
2315         if (other->load_state != UNIT_LOADED ||
2316             other->type != UNIT_SERVICE)
2317                 return;
2318
2319         se = SERVICE(other);
2320
2321         if (se->state == SERVICE_FAILED)
2322                 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2323
2324         if (se->state == SERVICE_DEAD ||
2325             se->state == SERVICE_STOP ||
2326             se->state == SERVICE_STOP_SIGTERM ||
2327             se->state == SERVICE_STOP_SIGKILL ||
2328             se->state == SERVICE_STOP_POST ||
2329             se->state == SERVICE_FINAL_SIGTERM ||
2330             se->state == SERVICE_FINAL_SIGKILL ||
2331             se->state == SERVICE_AUTO_RESTART)
2332                 socket_notify_service_dead(s, false);
2333
2334         if (se->state == SERVICE_RUNNING)
2335                 socket_set_state(s, SOCKET_RUNNING);
2336 }
2337
2338 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2339         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2340 }
2341
2342 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2343         Socket *s = SOCKET(u);
2344         int r;
2345
2346         if (!s->timer_event_source)
2347                 return 0;
2348
2349         r = sd_event_source_get_time(s->timer_event_source, timeout);
2350         if (r < 0)
2351                 return r;
2352
2353         return 1;
2354 }
2355
2356 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2357         [SOCKET_DEAD] = "dead",
2358         [SOCKET_START_PRE] = "start-pre",
2359         [SOCKET_START_POST] = "start-post",
2360         [SOCKET_LISTENING] = "listening",
2361         [SOCKET_RUNNING] = "running",
2362         [SOCKET_STOP_PRE] = "stop-pre",
2363         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2364         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2365         [SOCKET_STOP_POST] = "stop-post",
2366         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2367         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2368         [SOCKET_FAILED] = "failed"
2369 };
2370
2371 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2372
2373 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2374         [SOCKET_EXEC_START_PRE] = "StartPre",
2375         [SOCKET_EXEC_START_POST] = "StartPost",
2376         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2377         [SOCKET_EXEC_STOP_POST] = "StopPost"
2378 };
2379
2380 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2381
2382 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2383         [SOCKET_SUCCESS] = "success",
2384         [SOCKET_FAILURE_RESOURCES] = "resources",
2385         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2386         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2387         [SOCKET_FAILURE_SIGNAL] = "signal",
2388         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2389         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2390 };
2391
2392 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2393
2394 const UnitVTable socket_vtable = {
2395         .object_size = sizeof(Socket),
2396         .exec_context_offset = offsetof(Socket, exec_context),
2397         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2398         .kill_context_offset = offsetof(Socket, kill_context),
2399         .exec_runtime_offset = offsetof(Socket, exec_runtime),
2400
2401         .sections =
2402                 "Unit\0"
2403                 "Socket\0"
2404                 "Install\0",
2405         .private_section = "Socket",
2406
2407         .init = socket_init,
2408         .done = socket_done,
2409         .load = socket_load,
2410
2411         .coldplug = socket_coldplug,
2412
2413         .dump = socket_dump,
2414
2415         .start = socket_start,
2416         .stop = socket_stop,
2417
2418         .kill = socket_kill,
2419
2420         .get_timeout = socket_get_timeout,
2421
2422         .serialize = socket_serialize,
2423         .deserialize_item = socket_deserialize_item,
2424         .distribute_fds = socket_distribute_fds,
2425
2426         .active_state = socket_active_state,
2427         .sub_state_to_string = socket_sub_state_to_string,
2428
2429         .check_gc = socket_check_gc,
2430
2431         .sigchld_event = socket_sigchld_event,
2432
2433         .trigger_notify = socket_trigger_notify,
2434
2435         .reset_failed = socket_reset_failed,
2436
2437         .bus_interface = "org.freedesktop.systemd1.Socket",
2438         .bus_vtable = bus_socket_vtable,
2439         .bus_set_property = bus_socket_set_property,
2440         .bus_commit_properties = bus_socket_commit_properties,
2441
2442         .status_message_formats = {
2443                 /*.starting_stopping = {
2444                         [0] = "Starting socket %s...",
2445                         [1] = "Stopping socket %s...",
2446                 },*/
2447                 .finished_start_job = {
2448                         [JOB_DONE]       = "Listening on %s.",
2449                         [JOB_FAILED]     = "Failed to listen on %s.",
2450                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2451                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2452                 },
2453                 .finished_stop_job = {
2454                         [JOB_DONE]       = "Closed %s.",
2455                         [JOB_FAILED]     = "Failed stopping %s.",
2456                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2457                 },
2458         },
2459 };