src/core/socket.c

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