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