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