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         s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
 100 }
 101
 102 static void socket_unwatch_control_pid(Socket *s) {
 103         assert(s);
 104
 105         if (s->control_pid <= 0)
 106                 return;
 107
 108         unit_unwatch_pid(UNIT(s), s->control_pid);
 109         s->control_pid = 0;
 110 }
 111
 112 void socket_free_ports(Socket *s) {
 113         SocketPort *p;
 114
 115         assert(s);
 116
 117         while ((p = s->ports)) {
 118                 LIST_REMOVE(port, s->ports, p);
 119
 120                 sd_event_source_unref(p->event_source);
 121
 122                 if (p->fd >= 0)
 123                         close_nointr_nofail(p->fd);
 124
 125                 free(p->path);
 126                 free(p);
 127         }
 128 }
 129
 130 static void socket_done(Unit *u) {
 131         Socket *s = SOCKET(u);
 132
 133         assert(s);
 134
 135         socket_free_ports(s);
 136
 137         cgroup_context_done(&s->cgroup_context);
 138         exec_context_done(&s->exec_context);
 139         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
 140         exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
 141         s->control_command = NULL;
 142
 143         socket_unwatch_control_pid(s);
 144
 145         unit_ref_unset(&s->service);
 146
 147         free(s->tcp_congestion);
 148         s->tcp_congestion = NULL;
 149
 150         free(s->bind_to_device);
 151         s->bind_to_device = NULL;
 152
 153         free(s->smack);
 154         free(s->smack_ip_in);
 155         free(s->smack_ip_out);
 156
 157         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 158 }
 159
 160 static int socket_arm_timer(Socket *s) {
 161         int r;
 162
 163         assert(s);
 164
 165         if (s->timeout_usec <= 0) {
 166                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 167                 return 0;
 168         }
 169
 170         if (s->timer_event_source) {
 171                 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
 172                 if (r < 0)
 173                         return r;
 174
 175                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
 176         }
 177
 178         return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, socket_dispatch_timer, s, &s->timer_event_source);
 179 }
 180
 181 static int socket_instantiate_service(Socket *s) {
 182         char *prefix, *name;
 183         int r;
 184         Unit *u;
 185
 186         assert(s);
 187
 188         /* This fills in s->service if it isn't filled in yet. For
 189          * Accept=yes sockets we create the next connection service
 190          * here. For Accept=no this is mostly a NOP since the service
 191          * is figured out at load time anyway. */
 192
 193         if (UNIT_DEREF(s->service))
 194                 return 0;
 195
 196         assert(s->accept);
 197
 198         if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
 199                 return -ENOMEM;
 200
 201         r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
 202         free(prefix);
 203
 204         if (r < 0)
 205                 return -ENOMEM;
 206
 207         r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
 208         free(name);
 209
 210         if (r < 0)
 211                 return r;
 212
 213 #ifdef HAVE_SYSV_COMPAT
 214         if (SERVICE(u)->is_sysv) {
 215                 log_error("Using SysV services for socket activation is not supported. Refusing.");
 216                 return -ENOENT;
 217         }
 218 #endif
 219
 220         u->no_gc = true;
 221         unit_ref_set(&s->service, u);
 222
 223         return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
 224 }
 225
 226 static bool have_non_accept_socket(Socket *s) {
 227         SocketPort *p;
 228
 229         assert(s);
 230
 231         if (!s->accept)
 232                 return true;
 233
 234         LIST_FOREACH(port, p, s->ports) {
 235
 236                 if (p->type != SOCKET_SOCKET)
 237                         return true;
 238
 239                 if (!socket_address_can_accept(&p->address))
 240                         return true;
 241         }
 242
 243         return false;
 244 }
 245
 246 static int socket_add_mount_links(Socket *s) {
 247         SocketPort *p;
 248         int r;
 249
 250         assert(s);
 251
 252         LIST_FOREACH(port, p, s->ports) {
 253                 const char *path = NULL;
 254
 255                 if (p->type == SOCKET_SOCKET)
 256                         path = socket_address_get_path(&p->address);
 257                 else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL)
 258                         path = p->path;
 259
 260                 if (!path)
 261                         continue;
 262
 263                 r = unit_require_mounts_for(UNIT(s), path);
 264                 if (r < 0)
 265                         return r;
 266         }
 267
 268         return 0;
 269 }
 270
 271 static int socket_add_device_link(Socket *s) {
 272         char *t;
 273
 274         assert(s);
 275
 276         if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
 277                 return 0;
 278
 279         t = strappenda("/sys/subsystem/net/devices/", s->bind_to_device);
 280         return unit_add_node_link(UNIT(s), t, false);
 281 }
 282
 283 static int socket_add_default_dependencies(Socket *s) {
 284         int r;
 285         assert(s);
 286
 287         r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
 288         if (r < 0)
 289                 return r;
 290
 291         if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
 292                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
 293                 if (r < 0)
 294                         return r;
 295         }
 296
 297         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
 298 }
 299
 300 _pure_ static bool socket_has_exec(Socket *s) {
 301         unsigned i;
 302         assert(s);
 303
 304         for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
 305                 if (s->exec_command[i])
 306                         return true;
 307
 308         return false;
 309 }
 310
 311 static int socket_add_extras(Socket *s) {
 312         Unit *u = UNIT(s);
 313         int r;
 314
 315         assert(s);
 316
 317         if (have_non_accept_socket(s)) {
 318
 319                 if (!UNIT_DEREF(s->service)) {
 320                         Unit *x;
 321
 322                         r = unit_load_related_unit(u, ".service", &x);
 323                         if (r < 0)
 324                                 return r;
 325
 326                         unit_ref_set(&s->service, x);
 327                 }
 328
 329                 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
 330                 if (r < 0)
 331                         return r;
 332         }
 333
 334         r = socket_add_mount_links(s);
 335         if (r < 0)
 336                 return r;
 337
 338         r = socket_add_device_link(s);
 339         if (r < 0)
 340                 return r;
 341
 342         r = unit_exec_context_defaults(u, &s->exec_context);
 343         if (r < 0)
 344                 return r;
 345
 346         if (socket_has_exec(s)) {
 347                 r = unit_add_exec_dependencies(u, &s->exec_context);
 348                 if (r < 0)
 349                         return r;
 350
 351                 r = unit_add_default_slice(u);
 352                 if (r < 0)
 353                         return r;
 354         }
 355
 356         if (u->default_dependencies) {
 357                 r = socket_add_default_dependencies(s);
 358                 if (r < 0)
 359                         return r;
 360         }
 361
 362         return 0;
 363 }
 364
 365 static int socket_verify(Socket *s) {
 366         assert(s);
 367
 368         if (UNIT(s)->load_state != UNIT_LOADED)
 369                 return 0;
 370
 371         if (!s->ports) {
 372                 log_error_unit(UNIT(s)->id, "%s lacks Listen setting. Refusing.", UNIT(s)->id);
 373                 return -EINVAL;
 374         }
 375
 376         if (s->accept && have_non_accept_socket(s)) {
 377                 log_error_unit(UNIT(s)->id, "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
 378                                UNIT(s)->id);
 379                 return -EINVAL;
 380         }
 381
 382         if (s->accept && s->max_connections <= 0) {
 383                 log_error_unit(UNIT(s)->id, "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
 384                 return -EINVAL;
 385         }
 386
 387         if (s->accept && UNIT_DEREF(s->service)) {
 388                 log_error_unit(UNIT(s)->id, "Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
 389                 return -EINVAL;
 390         }
 391
 392         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 393                 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
 394                 return -EINVAL;
 395         }
 396
 397         return 0;
 398 }
 399
 400 static int socket_load(Unit *u) {
 401         Socket *s = SOCKET(u);
 402         int r;
 403
 404         assert(u);
 405         assert(u->load_state == UNIT_STUB);
 406
 407         r = unit_load_fragment_and_dropin(u);
 408         if (r < 0)
 409                 return r;
 410
 411         if (u->load_state == UNIT_LOADED) {
 412                 /* This is a new unit? Then let's add in some extras */
 413                 r = socket_add_extras(s);
 414                 if (r < 0)
 415                         return r;
 416         }
 417
 418         return socket_verify(s);
 419 }
 420
 421 _const_ static const char* listen_lookup(int family, int type) {
 422
 423         if (family == AF_NETLINK)
 424                 return "ListenNetlink";
 425
 426         if (type == SOCK_STREAM)
 427                 return "ListenStream";
 428         else if (type == SOCK_DGRAM)
 429                 return "ListenDatagram";
 430         else if (type == SOCK_SEQPACKET)
 431                 return "ListenSequentialPacket";
 432
 433         assert_not_reached("Unknown socket type");
 434         return NULL;
 435 }
 436
 437 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
 438         SocketExecCommand c;
 439         Socket *s = SOCKET(u);
 440         SocketPort *p;
 441         const char *prefix2;
 442
 443         assert(s);
 444         assert(f);
 445
 446         prefix2 = strappenda(prefix, "\t");
 447
 448         fprintf(f,
 449                 "%sSocket State: %s\n"
 450                 "%sResult: %s\n"
 451                 "%sBindIPv6Only: %s\n"
 452                 "%sBacklog: %u\n"
 453                 "%sSocketMode: %04o\n"
 454                 "%sDirectoryMode: %04o\n"
 455                 "%sKeepAlive: %s\n"
 456                 "%sFreeBind: %s\n"
 457                 "%sTransparent: %s\n"
 458                 "%sBroadcast: %s\n"
 459                 "%sPassCredentials: %s\n"
 460                 "%sPassSecurity: %s\n"
 461                 "%sTCPCongestion: %s\n",
 462                 prefix, socket_state_to_string(s->state),
 463                 prefix, socket_result_to_string(s->result),
 464                 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
 465                 prefix, s->backlog,
 466                 prefix, s->socket_mode,
 467                 prefix, s->directory_mode,
 468                 prefix, yes_no(s->keep_alive),
 469                 prefix, yes_no(s->free_bind),
 470                 prefix, yes_no(s->transparent),
 471                 prefix, yes_no(s->broadcast),
 472                 prefix, yes_no(s->pass_cred),
 473                 prefix, yes_no(s->pass_sec),
 474                 prefix, strna(s->tcp_congestion));
 475
 476         if (s->control_pid > 0)
 477                 fprintf(f,
 478                         "%sControl PID: %lu\n",
 479                         prefix, (unsigned long) s->control_pid);
 480
 481         if (s->bind_to_device)
 482                 fprintf(f,
 483                         "%sBindToDevice: %s\n",
 484                         prefix, s->bind_to_device);
 485
 486         if (s->accept)
 487                 fprintf(f,
 488                         "%sAccepted: %u\n"
 489                         "%sNConnections: %u\n"
 490                         "%sMaxConnections: %u\n",
 491                         prefix, s->n_accepted,
 492                         prefix, s->n_connections,
 493                         prefix, s->max_connections);
 494
 495         if (s->priority >= 0)
 496                 fprintf(f,
 497                         "%sPriority: %i\n",
 498                         prefix, s->priority);
 499
 500         if (s->receive_buffer > 0)
 501                 fprintf(f,
 502                         "%sReceiveBuffer: %zu\n",
 503                         prefix, s->receive_buffer);
 504
 505         if (s->send_buffer > 0)
 506                 fprintf(f,
 507                         "%sSendBuffer: %zu\n",
 508                         prefix, s->send_buffer);
 509
 510         if (s->ip_tos >= 0)
 511                 fprintf(f,
 512                         "%sIPTOS: %i\n",
 513                         prefix, s->ip_tos);
 514
 515         if (s->ip_ttl >= 0)
 516                 fprintf(f,
 517                         "%sIPTTL: %i\n",
 518                         prefix, s->ip_ttl);
 519
 520         if (s->pipe_size > 0)
 521                 fprintf(f,
 522                         "%sPipeSize: %zu\n",
 523                         prefix, s->pipe_size);
 524
 525         if (s->mark >= 0)
 526                 fprintf(f,
 527                         "%sMark: %i\n",
 528                         prefix, s->mark);
 529
 530         if (s->mq_maxmsg > 0)
 531                 fprintf(f,
 532                         "%sMessageQueueMaxMessages: %li\n",
 533                         prefix, s->mq_maxmsg);
 534
 535         if (s->mq_msgsize > 0)
 536                 fprintf(f,
 537                         "%sMessageQueueMessageSize: %li\n",
 538                         prefix, s->mq_msgsize);
 539
 540         if (s->reuse_port)
 541                 fprintf(f,
 542                         "%sReusePort: %s\n",
 543                          prefix, yes_no(s->reuse_port));
 544
 545         if (s->smack)
 546                 fprintf(f,
 547                         "%sSmackLabel: %s\n",
 548                         prefix, s->smack);
 549
 550         if (s->smack_ip_in)
 551                 fprintf(f,
 552                         "%sSmackLabelIPIn: %s\n",
 553                         prefix, s->smack_ip_in);
 554
 555         if (s->smack_ip_out)
 556                 fprintf(f,
 557                         "%sSmackLabelIPOut: %s\n",
 558                         prefix, s->smack_ip_out);
 559
 560         LIST_FOREACH(port, p, s->ports) {
 561
 562                 if (p->type == SOCKET_SOCKET) {
 563                         const char *t;
 564                         int r;
 565                         char *k = NULL;
 566
 567                         if ((r = socket_address_print(&p->address, &k)) < 0)
 568                                 t = strerror(-r);
 569                         else
 570                                 t = k;
 571
 572                         fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
 573                         free(k);
 574                 } else if (p->type == SOCKET_SPECIAL)
 575                         fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
 576                 else if (p->type == SOCKET_MQUEUE)
 577                         fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
 578                 else
 579                         fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
 580         }
 581
 582         exec_context_dump(&s->exec_context, f, prefix);
 583         kill_context_dump(&s->kill_context, f, prefix);
 584
 585         for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
 586                 if (!s->exec_command[c])
 587                         continue;
 588
 589                 fprintf(f, "%s-> %s:\n",
 590                         prefix, socket_exec_command_to_string(c));
 591
 592                 exec_command_dump_list(s->exec_command[c], f, prefix2);
 593         }
 594 }
 595
 596 static int instance_from_socket(int fd, unsigned nr, char **instance) {
 597         socklen_t l;
 598         char *r;
 599         union {
 600                 struct sockaddr sa;
 601                 struct sockaddr_un un;
 602                 struct sockaddr_in in;
 603                 struct sockaddr_in6 in6;
 604                 struct sockaddr_storage storage;
 605         } local, remote;
 606
 607         assert(fd >= 0);
 608         assert(instance);
 609
 610         l = sizeof(local);
 611         if (getsockname(fd, &local.sa, &l) < 0)
 612                 return -errno;
 613
 614         l = sizeof(remote);
 615         if (getpeername(fd, &remote.sa, &l) < 0)
 616                 return -errno;
 617
 618         switch (local.sa.sa_family) {
 619
 620         case AF_INET: {
 621                 uint32_t
 622                         a = ntohl(local.in.sin_addr.s_addr),
 623                         b = ntohl(remote.in.sin_addr.s_addr);
 624
 625                 if (asprintf(&r,
 626                              "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 627                              nr,
 628                              a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
 629                              ntohs(local.in.sin_port),
 630                              b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
 631                              ntohs(remote.in.sin_port)) < 0)
 632                         return -ENOMEM;
 633
 634                 break;
 635         }
 636
 637         case AF_INET6: {
 638                 static const unsigned char ipv4_prefix[] = {
 639                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
 640                 };
 641
 642                 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
 643                     memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
 644                         const uint8_t
 645                                 *a = local.in6.sin6_addr.s6_addr+12,
 646                                 *b = remote.in6.sin6_addr.s6_addr+12;
 647
 648                         if (asprintf(&r,
 649                                      "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 650                                      nr,
 651                                      a[0], a[1], a[2], a[3],
 652                                      ntohs(local.in6.sin6_port),
 653                                      b[0], b[1], b[2], b[3],
 654                                      ntohs(remote.in6.sin6_port)) < 0)
 655                                 return -ENOMEM;
 656                 } else {
 657                         char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
 658
 659                         if (asprintf(&r,
 660                                      "%u-%s:%u-%s:%u",
 661                                      nr,
 662                                      inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
 663                                      ntohs(local.in6.sin6_port),
 664                                      inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
 665                                      ntohs(remote.in6.sin6_port)) < 0)
 666                                 return -ENOMEM;
 667                 }
 668
 669                 break;
 670         }
 671
 672         case AF_UNIX: {
 673                 struct ucred ucred;
 674                 int k;
 675
 676                 k = getpeercred(fd, &ucred);
 677                 if (k < 0)
 678                         return k;
 679
 680                 if (asprintf(&r,
 681                              "%u-%lu-%lu",
 682                              nr,
 683                              (unsigned long) ucred.pid,
 684                              (unsigned long) ucred.uid) < 0)
 685                         return -ENOMEM;
 686
 687                 break;
 688         }
 689
 690         default:
 691                 assert_not_reached("Unhandled socket type.");
 692         }
 693
 694         *instance = r;
 695         return 0;
 696 }
 697
 698 static void socket_close_fds(Socket *s) {
 699         SocketPort *p;
 700
 701         assert(s);
 702
 703         LIST_FOREACH(port, p, s->ports) {
 704
 705                 p->event_source = sd_event_source_unref(p->event_source);
 706
 707                 if (p->fd < 0)
 708                         continue;
 709
 710                 close_nointr_nofail(p->fd);
 711
 712                 /* One little note: we should never delete any sockets
 713                  * in the file system here! After all some other
 714                  * process we spawned might still have a reference of
 715                  * this fd and wants to continue to use it. Therefore
 716                  * we delete sockets in the file system before we
 717                  * create a new one, not after we stopped using
 718                  * one! */
 719
 720                 p->fd = -1;
 721         }
 722 }
 723
 724 static void socket_apply_socket_options(Socket *s, int fd) {
 725         assert(s);
 726         assert(fd >= 0);
 727
 728         if (s->keep_alive) {
 729                 int b = s->keep_alive;
 730                 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
 731                         log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
 732         }
 733
 734         if (s->broadcast) {
 735                 int one = 1;
 736                 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
 737                         log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
 738         }
 739
 740         if (s->pass_cred) {
 741                 int one = 1;
 742                 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
 743                         log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
 744         }
 745
 746         if (s->pass_sec) {
 747                 int one = 1;
 748                 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
 749                         log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
 750         }
 751
 752         if (s->priority >= 0)
 753                 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
 754                         log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
 755
 756         if (s->receive_buffer > 0) {
 757                 int value = (int) s->receive_buffer;
 758
 759                 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
 760
 761                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
 762                         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
 763                                 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
 764         }
 765
 766         if (s->send_buffer > 0) {
 767                 int value = (int) s->send_buffer;
 768                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
 769                         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
 770                                 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
 771         }
 772
 773         if (s->mark >= 0)
 774                 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
 775                         log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
 776
 777         if (s->ip_tos >= 0)
 778                 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
 779                         log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
 780
 781         if (s->ip_ttl >= 0) {
 782                 int r, x;
 783
 784                 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
 785
 786                 if (socket_ipv6_is_supported())
 787                         x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
 788                 else {
 789                         x = -1;
 790                         errno = EAFNOSUPPORT;
 791                 }
 792
 793                 if (r < 0 && x < 0)
 794                         log_warning_unit(UNIT(s)->id,
 795                                          "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
 796         }
 797
 798         if (s->tcp_congestion)
 799                 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
 800                         log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
 801
 802         if (s->reuse_port) {
 803                 int b = s->reuse_port;
 804                 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)) < 0)
 805                         log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
 806         }
 807
 808         if (s->smack_ip_in)
 809                 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
 810                         log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
 811
 812         if (s->smack_ip_out)
 813                 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
 814                         log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
 815 }
 816
 817 static void socket_apply_fifo_options(Socket *s, int fd) {
 818         assert(s);
 819         assert(fd >= 0);
 820
 821         if (s->pipe_size > 0)
 822                 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
 823                         log_warning_unit(UNIT(s)->id,
 824                                          "F_SETPIPE_SZ: %m");
 825
 826         if (s->smack)
 827                 if (smack_label_fd(fd, s->smack) < 0)
 828                         log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
 829 }
 830
 831 static int fifo_address_create(
 832                 const char *path,
 833                 mode_t directory_mode,
 834                 mode_t socket_mode,
 835                 int *_fd) {
 836
 837         int fd = -1, r = 0;
 838         struct stat st;
 839         mode_t old_mask;
 840
 841         assert(path);
 842         assert(_fd);
 843
 844         mkdir_parents_label(path, directory_mode);
 845
 846         r = label_context_set(path, S_IFIFO);
 847         if (r < 0)
 848                 goto fail;
 849
 850         /* Enforce the right access mode for the fifo */
 851         old_mask = umask(~ socket_mode);
 852
 853         /* Include the original umask in our mask */
 854         umask(~socket_mode | old_mask);
 855
 856         r = mkfifo(path, socket_mode);
 857         umask(old_mask);
 858
 859         if (r < 0 && errno != EEXIST) {
 860                 r = -errno;
 861                 goto fail;
 862         }
 863
 864         if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 865                 r = -errno;
 866                 goto fail;
 867         }
 868
 869         label_context_clear();
 870
 871         if (fstat(fd, &st) < 0) {
 872                 r = -errno;
 873                 goto fail;
 874         }
 875
 876         if (!S_ISFIFO(st.st_mode) ||
 877             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
 878             st.st_uid != getuid() ||
 879             st.st_gid != getgid()) {
 880
 881                 r = -EEXIST;
 882                 goto fail;
 883         }
 884
 885         *_fd = fd;
 886         return 0;
 887
 888 fail:
 889         label_context_clear();
 890
 891         if (fd >= 0)
 892                 close_nointr_nofail(fd);
 893
 894         return r;
 895 }
 896
 897 static int special_address_create(
 898                 const char *path,
 899                 int *_fd) {
 900
 901         int fd = -1, r = 0;
 902         struct stat st;
 903
 904         assert(path);
 905         assert(_fd);
 906
 907         if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 908                 r = -errno;
 909                 goto fail;
 910         }
 911
 912         if (fstat(fd, &st) < 0) {
 913                 r = -errno;
 914                 goto fail;
 915         }
 916
 917         /* Check whether this is a /proc, /sys or /dev file or char device */
 918         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 919                 r = -EEXIST;
 920                 goto fail;
 921         }
 922
 923         *_fd = fd;
 924         return 0;
 925
 926 fail:
 927         if (fd >= 0)
 928                 close_nointr_nofail(fd);
 929
 930         return r;
 931 }
 932
 933 static int mq_address_create(
 934                 const char *path,
 935                 mode_t mq_mode,
 936                 long maxmsg,
 937                 long msgsize,
 938                 int *_fd) {
 939
 940         int fd = -1, r = 0;
 941         struct stat st;
 942         mode_t old_mask;
 943         struct mq_attr _attr, *attr = NULL;
 944
 945         assert(path);
 946         assert(_fd);
 947
 948         if (maxmsg > 0 && msgsize > 0) {
 949                 zero(_attr);
 950                 _attr.mq_flags = O_NONBLOCK;
 951                 _attr.mq_maxmsg = maxmsg;
 952                 _attr.mq_msgsize = msgsize;
 953                 attr = &_attr;
 954         }
 955
 956         /* Enforce the right access mode for the mq */
 957         old_mask = umask(~ mq_mode);
 958
 959         /* Include the original umask in our mask */
 960         umask(~mq_mode | old_mask);
 961
 962         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
 963         umask(old_mask);
 964
 965         if (fd < 0) {
 966                 r = -errno;
 967                 goto fail;
 968         }
 969
 970         if (fstat(fd, &st) < 0) {
 971                 r = -errno;
 972                 goto fail;
 973         }
 974
 975         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
 976             st.st_uid != getuid() ||
 977             st.st_gid != getgid()) {
 978
 979                 r = -EEXIST;
 980                 goto fail;
 981         }
 982
 983         *_fd = fd;
 984         return 0;
 985
 986 fail:
 987         if (fd >= 0)
 988                 close_nointr_nofail(fd);
 989
 990         return r;
 991 }
 992
 993 static int socket_open_fds(Socket *s) {
 994         SocketPort *p;
 995         int r;
 996         char *label = NULL;
 997         bool know_label = false;
 998
 999         assert(s);
1000
1001         LIST_FOREACH(port, p, s->ports) {
1002
1003                 if (p->fd >= 0)
1004                         continue;
1005
1006                 if (p->type == SOCKET_SOCKET) {
1007
1008                         if (!know_label) {
1009
1010                                 if ((r = socket_instantiate_service(s)) < 0)
1011                                         return r;
1012
1013                                 if (UNIT_ISSET(s->service) &&
1014                                     SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1015                                         r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1016
1017                                         if (r < 0) {
1018                                                 if (r != -EPERM)
1019                                                         return r;
1020                                         }
1021                                 }
1022
1023                                 know_label = true;
1024                         }
1025
1026                         r = socket_address_listen(
1027                                         &p->address,
1028                                         SOCK_CLOEXEC|SOCK_NONBLOCK,
1029                                         s->backlog,
1030                                         s->bind_ipv6_only,
1031                                         s->bind_to_device,
1032                                         s->free_bind,
1033                                         s->transparent,
1034                                         s->directory_mode,
1035                                         s->socket_mode,
1036                                         label);
1037                         if (r < 0)
1038                                 goto rollback;
1039
1040                         p->fd = r;
1041                         socket_apply_socket_options(s, p->fd);
1042
1043                 } else  if (p->type == SOCKET_SPECIAL) {
1044
1045                         r = special_address_create(
1046                                         p->path,
1047                                         &p->fd);
1048                         if (r < 0)
1049                                 goto rollback;
1050
1051                 } else  if (p->type == SOCKET_FIFO) {
1052
1053                         r = fifo_address_create(
1054                                         p->path,
1055                                         s->directory_mode,
1056                                         s->socket_mode,
1057                                         &p->fd);
1058                         if (r < 0)
1059                                 goto rollback;
1060
1061                         socket_apply_fifo_options(s, p->fd);
1062                 } else if (p->type == SOCKET_MQUEUE) {
1063
1064                         r = mq_address_create(
1065                                         p->path,
1066                                         s->socket_mode,
1067                                         s->mq_maxmsg,
1068                                         s->mq_msgsize,
1069                                         &p->fd);
1070                         if (r < 0)
1071                                 goto rollback;
1072                 } else
1073                         assert_not_reached("Unknown port type");
1074         }
1075
1076         label_free(label);
1077         return 0;
1078
1079 rollback:
1080         socket_close_fds(s);
1081         label_free(label);
1082         return r;
1083 }
1084
1085 static void socket_unwatch_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_OFF);
1097                         if (r < 0)
1098                                 log_debug_unit(UNIT(s)->id, "Failed to disable event source.");
1099                 }
1100         }
1101 }
1102
1103 static int socket_watch_fds(Socket *s) {
1104         SocketPort *p;
1105         int r;
1106
1107         assert(s);
1108
1109         LIST_FOREACH(port, p, s->ports) {
1110                 if (p->fd < 0)
1111                         continue;
1112
1113                 if (p->event_source)
1114                         r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1115                 else
1116                         r = sd_event_add_io(UNIT(s)->manager->event, p->fd, EPOLLIN, socket_dispatch_io, p, &p->event_source);
1117
1118                 if (r < 0) {
1119                         log_warning_unit(UNIT(s)->id, "Failed to watch listening fds: %s", strerror(-r));
1120                         goto fail;
1121                 }
1122         }
1123
1124         return 0;
1125
1126 fail:
1127         socket_unwatch_fds(s);
1128         return r;
1129 }
1130
1131 static void socket_set_state(Socket *s, SocketState state) {
1132         SocketState old_state;
1133         assert(s);
1134
1135         old_state = s->state;
1136         s->state = state;
1137
1138         if (state != SOCKET_START_PRE &&
1139             state != SOCKET_START_POST &&
1140             state != SOCKET_STOP_PRE &&
1141             state != SOCKET_STOP_PRE_SIGTERM &&
1142             state != SOCKET_STOP_PRE_SIGKILL &&
1143             state != SOCKET_STOP_POST &&
1144             state != SOCKET_FINAL_SIGTERM &&
1145             state != SOCKET_FINAL_SIGKILL) {
1146
1147                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1148                 socket_unwatch_control_pid(s);
1149                 s->control_command = NULL;
1150                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1151         }
1152
1153         if (state != SOCKET_LISTENING)
1154                 socket_unwatch_fds(s);
1155
1156         if (state != SOCKET_START_POST &&
1157             state != SOCKET_LISTENING &&
1158             state != SOCKET_RUNNING &&
1159             state != SOCKET_STOP_PRE &&
1160             state != SOCKET_STOP_PRE_SIGTERM &&
1161             state != SOCKET_STOP_PRE_SIGKILL)
1162                 socket_close_fds(s);
1163
1164         if (state != old_state)
1165                 log_debug_unit(UNIT(s)->id, "%s changed %s -> %s",
1166                                UNIT(s)->id, socket_state_to_string(old_state), socket_state_to_string(state));
1167
1168         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1169 }
1170
1171 static int socket_coldplug(Unit *u) {
1172         Socket *s = SOCKET(u);
1173         int r;
1174
1175         assert(s);
1176         assert(s->state == SOCKET_DEAD);
1177
1178         if (s->deserialized_state == s->state)
1179                 return 0;
1180
1181         if (s->deserialized_state == SOCKET_START_PRE ||
1182             s->deserialized_state == SOCKET_START_POST ||
1183             s->deserialized_state == SOCKET_STOP_PRE ||
1184             s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1185             s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1186             s->deserialized_state == SOCKET_STOP_POST ||
1187             s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1188             s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1189
1190                 if (s->control_pid <= 0)
1191                         return -EBADMSG;
1192
1193                 r = unit_watch_pid(UNIT(s), s->control_pid);
1194                 if (r < 0)
1195                         return r;
1196
1197                 r = socket_arm_timer(s);
1198                 if (r < 0)
1199                         return r;
1200         }
1201
1202         if (s->deserialized_state == SOCKET_START_POST ||
1203             s->deserialized_state == SOCKET_LISTENING ||
1204             s->deserialized_state == SOCKET_RUNNING ||
1205             s->deserialized_state == SOCKET_STOP_PRE ||
1206             s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1207             s->deserialized_state == SOCKET_STOP_PRE_SIGKILL) {
1208                 r = socket_open_fds(s);
1209                 if (r < 0)
1210                         return r;
1211         }
1212
1213         if (s->deserialized_state == SOCKET_LISTENING) {
1214                 r = socket_watch_fds(s);
1215                 if (r < 0)
1216                         return r;
1217         }
1218
1219         socket_set_state(s, s->deserialized_state);
1220         return 0;
1221 }
1222
1223 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1224         pid_t pid;
1225         int r;
1226         char **argv;
1227
1228         assert(s);
1229         assert(c);
1230         assert(_pid);
1231
1232         unit_realize_cgroup(UNIT(s));
1233
1234         r = unit_setup_exec_runtime(UNIT(s));
1235         if (r < 0)
1236                 goto fail;
1237
1238         r = socket_arm_timer(s);
1239         if (r < 0)
1240                 goto fail;
1241
1242         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1243         if (r < 0)
1244                 goto fail;
1245
1246         r = exec_spawn(c,
1247                        argv,
1248                        &s->exec_context,
1249                        NULL, 0,
1250                        UNIT(s)->manager->environment,
1251                        true,
1252                        true,
1253                        true,
1254                        UNIT(s)->manager->confirm_spawn,
1255                        UNIT(s)->manager->cgroup_supported,
1256                        UNIT(s)->cgroup_path,
1257                        UNIT(s)->id,
1258                        0,
1259                        NULL,
1260                        s->exec_runtime,
1261                        &pid);
1262
1263         strv_free(argv);
1264         if (r < 0)
1265                 goto fail;
1266
1267         r = unit_watch_pid(UNIT(s), pid);
1268         if (r < 0)
1269                 /* FIXME: we need to do something here */
1270                 goto fail;
1271
1272         *_pid = pid;
1273
1274         return 0;
1275
1276 fail:
1277         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1278
1279         return r;
1280 }
1281
1282 static void socket_enter_dead(Socket *s, SocketResult f) {
1283         assert(s);
1284
1285         if (f != SOCKET_SUCCESS)
1286                 s->result = f;
1287
1288         exec_runtime_destroy(s->exec_runtime);
1289         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1290
1291         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1292 }
1293
1294 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1295
1296 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1297         int r;
1298         assert(s);
1299
1300         if (f != SOCKET_SUCCESS)
1301                 s->result = f;
1302
1303         socket_unwatch_control_pid(s);
1304
1305         s->control_command_id = SOCKET_EXEC_STOP_POST;
1306
1307         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1308                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1309                         goto fail;
1310
1311                 socket_set_state(s, SOCKET_STOP_POST);
1312         } else
1313                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1314
1315         return;
1316
1317 fail:
1318         log_warning_unit(UNIT(s)->id,
1319                          "%s failed to run 'stop-post' task: %s",
1320                          UNIT(s)->id, strerror(-r));
1321         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1322 }
1323
1324 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1325         int r;
1326
1327         assert(s);
1328
1329         if (f != SOCKET_SUCCESS)
1330                 s->result = f;
1331
1332         r = unit_kill_context(
1333                         UNIT(s),
1334                         &s->kill_context,
1335                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1336                         -1,
1337                         s->control_pid,
1338                         false);
1339         if (r < 0)
1340                 goto fail;
1341
1342         if (r > 0) {
1343                 r = socket_arm_timer(s);
1344                 if (r < 0)
1345                         goto fail;
1346
1347                 socket_set_state(s, state);
1348         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1349                 socket_enter_stop_post(s, 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 const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2349         [SOCKET_DEAD] = "dead",
2350         [SOCKET_START_PRE] = "start-pre",
2351         [SOCKET_START_POST] = "start-post",
2352         [SOCKET_LISTENING] = "listening",
2353         [SOCKET_RUNNING] = "running",
2354         [SOCKET_STOP_PRE] = "stop-pre",
2355         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2356         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2357         [SOCKET_STOP_POST] = "stop-post",
2358         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2359         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2360         [SOCKET_FAILED] = "failed"
2361 };
2362
2363 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2364
2365 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2366         [SOCKET_EXEC_START_PRE] = "StartPre",
2367         [SOCKET_EXEC_START_POST] = "StartPost",
2368         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2369         [SOCKET_EXEC_STOP_POST] = "StopPost"
2370 };
2371
2372 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2373
2374 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2375         [SOCKET_SUCCESS] = "success",
2376         [SOCKET_FAILURE_RESOURCES] = "resources",
2377         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2378         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2379         [SOCKET_FAILURE_SIGNAL] = "signal",
2380         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2381         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2382 };
2383
2384 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2385
2386 const UnitVTable socket_vtable = {
2387         .object_size = sizeof(Socket),
2388         .exec_context_offset = offsetof(Socket, exec_context),
2389         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2390         .kill_context_offset = offsetof(Socket, kill_context),
2391         .exec_runtime_offset = offsetof(Socket, exec_runtime),
2392
2393         .sections =
2394                 "Unit\0"
2395                 "Socket\0"
2396                 "Install\0",
2397         .private_section = "Socket",
2398
2399         .init = socket_init,
2400         .done = socket_done,
2401         .load = socket_load,
2402
2403         .coldplug = socket_coldplug,
2404
2405         .dump = socket_dump,
2406
2407         .start = socket_start,
2408         .stop = socket_stop,
2409
2410         .kill = socket_kill,
2411
2412         .serialize = socket_serialize,
2413         .deserialize_item = socket_deserialize_item,
2414         .distribute_fds = socket_distribute_fds,
2415
2416         .active_state = socket_active_state,
2417         .sub_state_to_string = socket_sub_state_to_string,
2418
2419         .check_gc = socket_check_gc,
2420
2421         .sigchld_event = socket_sigchld_event,
2422
2423         .trigger_notify = socket_trigger_notify,
2424
2425         .reset_failed = socket_reset_failed,
2426
2427         .bus_interface = "org.freedesktop.systemd1.Socket",
2428         .bus_vtable = bus_socket_vtable,
2429         .bus_set_property = bus_socket_set_property,
2430         .bus_commit_properties = bus_socket_commit_properties,
2431
2432         .status_message_formats = {
2433                 /*.starting_stopping = {
2434                         [0] = "Starting socket %s...",
2435                         [1] = "Stopping socket %s...",
2436                 },*/
2437                 .finished_start_job = {
2438                         [JOB_DONE]       = "Listening on %s.",
2439                         [JOB_FAILED]     = "Failed to listen on %s.",
2440                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2441                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2442                 },
2443                 .finished_stop_job = {
2444                         [JOB_DONE]       = "Closed %s.",
2445                         [JOB_FAILED]     = "Failed stopping %s.",
2446                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2447                 },
2448         },
2449 };