src/core/socket.c

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