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         exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
 138         cgroup_context_init(&s->cgroup_context);
 139
 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 = socket_arm_timer(s);
1236         if (r < 0)
1237                 goto fail;
1238
1239         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1240         if (r < 0)
1241                 goto fail;
1242
1243         r = exec_spawn(c,
1244                        argv,
1245                        &s->exec_context,
1246                        NULL, 0,
1247                        UNIT(s)->manager->environment,
1248                        true,
1249                        true,
1250                        true,
1251                        UNIT(s)->manager->confirm_spawn,
1252                        UNIT(s)->manager->cgroup_supported,
1253                        UNIT(s)->cgroup_path,
1254                        UNIT(s)->id,
1255                        NULL,
1256                        &pid);
1257
1258         strv_free(argv);
1259         if (r < 0)
1260                 goto fail;
1261
1262         r = unit_watch_pid(UNIT(s), pid);
1263         if (r < 0)
1264                 /* FIXME: we need to do something here */
1265                 goto fail;
1266
1267         *_pid = pid;
1268
1269         return 0;
1270
1271 fail:
1272         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1273
1274         return r;
1275 }
1276
1277 static void socket_enter_dead(Socket *s, SocketResult f) {
1278         assert(s);
1279
1280         if (f != SOCKET_SUCCESS)
1281                 s->result = f;
1282
1283         exec_context_tmp_dirs_done(&s->exec_context);
1284         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1285 }
1286
1287 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1288
1289 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1290         int r;
1291         assert(s);
1292
1293         if (f != SOCKET_SUCCESS)
1294                 s->result = f;
1295
1296         socket_unwatch_control_pid(s);
1297
1298         s->control_command_id = SOCKET_EXEC_STOP_POST;
1299
1300         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1301                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1302                         goto fail;
1303
1304                 socket_set_state(s, SOCKET_STOP_POST);
1305         } else
1306                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1307
1308         return;
1309
1310 fail:
1311         log_warning_unit(UNIT(s)->id,
1312                          "%s failed to run 'stop-post' task: %s",
1313                          UNIT(s)->id, strerror(-r));
1314         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1315 }
1316
1317 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1318         int r;
1319
1320         assert(s);
1321
1322         if (f != SOCKET_SUCCESS)
1323                 s->result = f;
1324
1325         r = unit_kill_context(
1326                         UNIT(s),
1327                         &s->kill_context,
1328                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1329                         -1,
1330                         s->control_pid,
1331                         false);
1332         if (r < 0)
1333                 goto fail;
1334
1335         if (r > 0) {
1336                 r = socket_arm_timer(s);
1337                 if (r < 0)
1338                         goto fail;
1339
1340                 socket_set_state(s, state);
1341         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1342                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1343         else
1344                 socket_enter_dead(s, SOCKET_SUCCESS);
1345
1346         return;
1347
1348 fail:
1349         log_warning_unit(UNIT(s)->id,
1350                          "%s failed to kill processes: %s",
1351                          UNIT(s)->id, strerror(-r));
1352
1353         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1354                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1355         else
1356                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1357 }
1358
1359 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1360         int r;
1361         assert(s);
1362
1363         if (f != SOCKET_SUCCESS)
1364                 s->result = f;
1365
1366         socket_unwatch_control_pid(s);
1367
1368         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1369
1370         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1371                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1372                         goto fail;
1373
1374                 socket_set_state(s, SOCKET_STOP_PRE);
1375         } else
1376                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1377
1378         return;
1379
1380 fail:
1381         log_warning_unit(UNIT(s)->id,
1382                          "%s failed to run 'stop-pre' task: %s",
1383                          UNIT(s)->id, strerror(-r));
1384         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1385 }
1386
1387 static void socket_enter_listening(Socket *s) {
1388         int r;
1389         assert(s);
1390
1391         r = socket_watch_fds(s);
1392         if (r < 0) {
1393                 log_warning_unit(UNIT(s)->id,
1394                                  "%s failed to watch sockets: %s",
1395                                  UNIT(s)->id, strerror(-r));
1396                 goto fail;
1397         }
1398
1399         socket_set_state(s, SOCKET_LISTENING);
1400         return;
1401
1402 fail:
1403         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1404 }
1405
1406 static void socket_enter_start_post(Socket *s) {
1407         int r;
1408         assert(s);
1409
1410         r = socket_open_fds(s);
1411         if (r < 0) {
1412                 log_warning_unit(UNIT(s)->id,
1413                                  "%s failed to listen on sockets: %s",
1414                                  UNIT(s)->id, strerror(-r));
1415                 goto fail;
1416         }
1417
1418         socket_unwatch_control_pid(s);
1419
1420         s->control_command_id = SOCKET_EXEC_START_POST;
1421
1422         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1423                 r = socket_spawn(s, s->control_command, &s->control_pid);
1424                 if (r < 0) {
1425                         log_warning_unit(UNIT(s)->id,
1426                                          "%s failed to run 'start-post' task: %s",
1427                                          UNIT(s)->id, strerror(-r));
1428                         goto fail;
1429                 }
1430
1431                 socket_set_state(s, SOCKET_START_POST);
1432         } else
1433                 socket_enter_listening(s);
1434
1435         return;
1436
1437 fail:
1438         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1439 }
1440
1441 static void socket_enter_start_pre(Socket *s) {
1442         int r;
1443         assert(s);
1444
1445         socket_unwatch_control_pid(s);
1446
1447         s->control_command_id = SOCKET_EXEC_START_PRE;
1448
1449         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1450                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1451                         goto fail;
1452
1453                 socket_set_state(s, SOCKET_START_PRE);
1454         } else
1455                 socket_enter_start_post(s);
1456
1457         return;
1458
1459 fail:
1460         log_warning_unit(UNIT(s)->id,
1461                          "%s failed to run 'start-pre' task: %s",
1462                          UNIT(s)->id, strerror(-r));
1463         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1464 }
1465
1466 static void socket_enter_running(Socket *s, int cfd) {
1467         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1468         int r;
1469
1470         assert(s);
1471
1472         /* We don't take connections anymore if we are supposed to
1473          * shut down anyway */
1474         if (unit_stop_pending(UNIT(s))) {
1475                 log_debug_unit(UNIT(s)->id,
1476                                "Suppressing connection request on %s since unit stop is scheduled.",
1477                                UNIT(s)->id);
1478
1479                 if (cfd >= 0)
1480                         close_nointr_nofail(cfd);
1481                 else  {
1482                         /* Flush all sockets by closing and reopening them */
1483                         socket_close_fds(s);
1484
1485                         r = socket_watch_fds(s);
1486                         if (r < 0) {
1487                                 log_warning_unit(UNIT(s)->id,
1488                                                  "%s failed to watch sockets: %s",
1489                                                  UNIT(s)->id, strerror(-r));
1490                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1491                         }
1492                 }
1493
1494                 return;
1495         }
1496
1497         if (cfd < 0) {
1498                 Iterator i;
1499                 Unit *u;
1500                 bool pending = false;
1501
1502                 /* If there's already a start pending don't bother to
1503                  * do anything */
1504                 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1505                         if (unit_active_or_pending(u)) {
1506                                 pending = true;
1507                                 break;
1508                         }
1509
1510                 if (!pending) {
1511                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1512                         if (r < 0)
1513                                 goto fail;
1514                 }
1515
1516                 socket_set_state(s, SOCKET_RUNNING);
1517         } else {
1518                 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1519                 Service *service;
1520
1521                 if (s->n_connections >= s->max_connections) {
1522                         log_warning_unit(UNIT(s)->id,
1523                                          "%s: Too many incoming connections (%u)",
1524                                          UNIT(s)->id, s->n_connections);
1525                         close_nointr_nofail(cfd);
1526                         return;
1527                 }
1528
1529                 r = socket_instantiate_service(s);
1530                 if (r < 0)
1531                         goto fail;
1532
1533                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1534                 if (r < 0) {
1535                         if (r != -ENOTCONN)
1536                                 goto fail;
1537
1538                         /* ENOTCONN is legitimate if TCP RST was received.
1539                          * This connection is over, but the socket unit lives on. */
1540                         close_nointr_nofail(cfd);
1541                         return;
1542                 }
1543
1544                 prefix = unit_name_to_prefix(UNIT(s)->id);
1545                 if (!prefix) {
1546                         r = -ENOMEM;
1547                         goto fail;
1548                 }
1549
1550                 name = unit_name_build(prefix, instance, ".service");
1551
1552                 if (!name) {
1553                         r = -ENOMEM;
1554                         goto fail;
1555                 }
1556
1557                 r = unit_add_name(UNIT_DEREF(s->service), name);
1558                 if (r < 0)
1559                         goto fail;
1560
1561                 service = SERVICE(UNIT_DEREF(s->service));
1562                 unit_ref_unset(&s->service);
1563                 s->n_accepted ++;
1564
1565                 UNIT(service)->no_gc = false;
1566
1567                 unit_choose_id(UNIT(service), name);
1568
1569                 r = service_set_socket_fd(service, cfd, s);
1570                 if (r < 0)
1571                         goto fail;
1572
1573                 cfd = -1;
1574                 s->n_connections ++;
1575
1576                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1577                 if (r < 0)
1578                         goto fail;
1579
1580                 /* Notify clients about changed counters */
1581                 unit_add_to_dbus_queue(UNIT(s));
1582         }
1583
1584         return;
1585
1586 fail:
1587         log_warning_unit(UNIT(s)->id,
1588                          "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1589                          UNIT(s)->id,
1590                          cfd >= 0 ? "template" : "non-template",
1591                          bus_error_message(&error, r));
1592         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1593
1594         if (cfd >= 0)
1595                 close_nointr_nofail(cfd);
1596 }
1597
1598 static void socket_run_next(Socket *s) {
1599         int r;
1600
1601         assert(s);
1602         assert(s->control_command);
1603         assert(s->control_command->command_next);
1604
1605         socket_unwatch_control_pid(s);
1606
1607         s->control_command = s->control_command->command_next;
1608
1609         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1610                 goto fail;
1611
1612         return;
1613
1614 fail:
1615         log_warning_unit(UNIT(s)->id,
1616                          "%s failed to run next task: %s",
1617                          UNIT(s)->id, strerror(-r));
1618
1619         if (s->state == SOCKET_START_POST)
1620                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1621         else if (s->state == SOCKET_STOP_POST)
1622                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1623         else
1624                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1625 }
1626
1627 static int socket_start(Unit *u) {
1628         Socket *s = SOCKET(u);
1629
1630         assert(s);
1631
1632         /* We cannot fulfill this request right now, try again later
1633          * please! */
1634         if (s->state == SOCKET_STOP_PRE ||
1635             s->state == SOCKET_STOP_PRE_SIGKILL ||
1636             s->state == SOCKET_STOP_PRE_SIGTERM ||
1637             s->state == SOCKET_STOP_POST ||
1638             s->state == SOCKET_FINAL_SIGTERM ||
1639             s->state == SOCKET_FINAL_SIGKILL)
1640                 return -EAGAIN;
1641
1642         if (s->state == SOCKET_START_PRE ||
1643             s->state == SOCKET_START_POST)
1644                 return 0;
1645
1646         /* Cannot run this without the service being around */
1647         if (UNIT_ISSET(s->service)) {
1648                 Service *service;
1649
1650                 service = SERVICE(UNIT_DEREF(s->service));
1651
1652                 if (UNIT(service)->load_state != UNIT_LOADED) {
1653                         log_error_unit(u->id,
1654                                        "Socket service %s not loaded, refusing.",
1655                                        UNIT(service)->id);
1656                         return -ENOENT;
1657                 }
1658
1659                 /* If the service is already active we cannot start the
1660                  * socket */
1661                 if (service->state != SERVICE_DEAD &&
1662                     service->state != SERVICE_FAILED &&
1663                     service->state != SERVICE_AUTO_RESTART) {
1664                         log_error_unit(u->id,
1665                                        "Socket service %s already active, refusing.",
1666                                        UNIT(service)->id);
1667                         return -EBUSY;
1668                 }
1669
1670 #ifdef HAVE_SYSV_COMPAT
1671                 if (service->is_sysv) {
1672                         log_error_unit(u->id,
1673                                        "Using SysV services for socket activation is not supported. Refusing.");
1674                         return -ENOENT;
1675                 }
1676 #endif
1677         }
1678
1679         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1680
1681         s->result = SOCKET_SUCCESS;
1682         socket_enter_start_pre(s);
1683         return 0;
1684 }
1685
1686 static int socket_stop(Unit *u) {
1687         Socket *s = SOCKET(u);
1688
1689         assert(s);
1690
1691         /* Already on it */
1692         if (s->state == SOCKET_STOP_PRE ||
1693             s->state == SOCKET_STOP_PRE_SIGTERM ||
1694             s->state == SOCKET_STOP_PRE_SIGKILL ||
1695             s->state == SOCKET_STOP_POST ||
1696             s->state == SOCKET_FINAL_SIGTERM ||
1697             s->state == SOCKET_FINAL_SIGKILL)
1698                 return 0;
1699
1700         /* If there's already something running we go directly into
1701          * kill mode. */
1702         if (s->state == SOCKET_START_PRE ||
1703             s->state == SOCKET_START_POST) {
1704                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1705                 return -EAGAIN;
1706         }
1707
1708         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1709
1710         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1711         return 0;
1712 }
1713
1714 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1715         Socket *s = SOCKET(u);
1716         SocketPort *p;
1717         int r;
1718
1719         assert(u);
1720         assert(f);
1721         assert(fds);
1722
1723         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1724         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1725         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1726
1727         if (s->control_pid > 0)
1728                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1729
1730         if (s->control_command_id >= 0)
1731                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1732
1733         LIST_FOREACH(port, p, s->ports) {
1734                 int copy;
1735
1736                 if (p->fd < 0)
1737                         continue;
1738
1739                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1740                         return copy;
1741
1742                 if (p->type == SOCKET_SOCKET) {
1743                         char *t;
1744
1745                         r = socket_address_print(&p->address, &t);
1746                         if (r < 0)
1747                                 return r;
1748
1749                         if (socket_address_family(&p->address) == AF_NETLINK)
1750                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1751                         else
1752                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1753                         free(t);
1754                 } else if (p->type == SOCKET_SPECIAL)
1755                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1756                 else if (p->type == SOCKET_MQUEUE)
1757                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1758                 else {
1759                         assert(p->type == SOCKET_FIFO);
1760                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1761                 }
1762         }
1763
1764         exec_context_serialize(&s->exec_context, UNIT(s), f);
1765
1766         return 0;
1767 }
1768
1769 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1770         Socket *s = SOCKET(u);
1771
1772         assert(u);
1773         assert(key);
1774         assert(value);
1775         assert(fds);
1776
1777         if (streq(key, "state")) {
1778                 SocketState state;
1779
1780                 state = socket_state_from_string(value);
1781                 if (state < 0)
1782                         log_debug_unit(u->id,
1783                                        "Failed to parse state value %s", value);
1784                 else
1785                         s->deserialized_state = state;
1786         } else if (streq(key, "result")) {
1787                 SocketResult f;
1788
1789                 f = socket_result_from_string(value);
1790                 if (f < 0)
1791                         log_debug_unit(u->id,
1792                                        "Failed to parse result value %s", value);
1793                 else if (f != SOCKET_SUCCESS)
1794                         s->result = f;
1795
1796         } else if (streq(key, "n-accepted")) {
1797                 unsigned k;
1798
1799                 if (safe_atou(value, &k) < 0)
1800                         log_debug_unit(u->id,
1801                                        "Failed to parse n-accepted value %s", value);
1802                 else
1803                         s->n_accepted += k;
1804         } else if (streq(key, "control-pid")) {
1805                 pid_t pid;
1806
1807                 if (parse_pid(value, &pid) < 0)
1808                         log_debug_unit(u->id,
1809                                        "Failed to parse control-pid value %s", value);
1810                 else
1811                         s->control_pid = pid;
1812         } else if (streq(key, "control-command")) {
1813                 SocketExecCommand id;
1814
1815                 id = socket_exec_command_from_string(value);
1816                 if (id < 0)
1817                         log_debug_unit(u->id,
1818                                        "Failed to parse exec-command value %s", value);
1819                 else {
1820                         s->control_command_id = id;
1821                         s->control_command = s->exec_command[id];
1822                 }
1823         } else if (streq(key, "fifo")) {
1824                 int fd, skip = 0;
1825                 SocketPort *p;
1826
1827                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1828                         log_debug_unit(u->id,
1829                                        "Failed to parse fifo value %s", value);
1830                 else {
1831
1832                         LIST_FOREACH(port, p, s->ports)
1833                                 if (p->type == SOCKET_FIFO &&
1834                                     streq_ptr(p->path, value+skip))
1835                                         break;
1836
1837                         if (p) {
1838                                 if (p->fd >= 0)
1839                                         close_nointr_nofail(p->fd);
1840                                 p->fd = fdset_remove(fds, fd);
1841                         }
1842                 }
1843
1844         } else if (streq(key, "special")) {
1845                 int fd, skip = 0;
1846                 SocketPort *p;
1847
1848                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1849                         log_debug_unit(u->id,
1850                                        "Failed to parse special value %s", value);
1851                 else {
1852
1853                         LIST_FOREACH(port, p, s->ports)
1854                                 if (p->type == SOCKET_SPECIAL &&
1855                                     streq_ptr(p->path, value+skip))
1856                                         break;
1857
1858                         if (p) {
1859                                 if (p->fd >= 0)
1860                                         close_nointr_nofail(p->fd);
1861                                 p->fd = fdset_remove(fds, fd);
1862                         }
1863                 }
1864
1865         } else if (streq(key, "mqueue")) {
1866                 int fd, skip = 0;
1867                 SocketPort *p;
1868
1869                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1870                         log_debug_unit(u->id,
1871                                        "Failed to parse mqueue value %s", value);
1872                 else {
1873
1874                         LIST_FOREACH(port, p, s->ports)
1875                                 if (p->type == SOCKET_MQUEUE &&
1876                                     streq_ptr(p->path, value+skip))
1877                                         break;
1878
1879                         if (p) {
1880                                 if (p->fd >= 0)
1881                                         close_nointr_nofail(p->fd);
1882                                 p->fd = fdset_remove(fds, fd);
1883                         }
1884                 }
1885
1886         } else if (streq(key, "socket")) {
1887                 int fd, type, skip = 0;
1888                 SocketPort *p;
1889
1890                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1891                         log_debug_unit(u->id,
1892                                        "Failed to parse socket value %s", value);
1893                 else {
1894
1895                         LIST_FOREACH(port, p, s->ports)
1896                                 if (socket_address_is(&p->address, value+skip, type))
1897                                         break;
1898
1899                         if (p) {
1900                                 if (p->fd >= 0)
1901                                         close_nointr_nofail(p->fd);
1902                                 p->fd = fdset_remove(fds, fd);
1903                         }
1904                 }
1905
1906         } else if (streq(key, "netlink")) {
1907                 int fd, skip = 0;
1908                 SocketPort *p;
1909
1910                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1911                         log_debug_unit(u->id,
1912                                        "Failed to parse socket value %s", value);
1913                 else {
1914
1915                         LIST_FOREACH(port, p, s->ports)
1916                                 if (socket_address_is_netlink(&p->address, value+skip))
1917                                         break;
1918
1919                         if (p) {
1920                                 if (p->fd >= 0)
1921                                         close_nointr_nofail(p->fd);
1922                                 p->fd = fdset_remove(fds, fd);
1923                         }
1924                 }
1925         } else if (streq(key, "tmp-dir")) {
1926                 char *t;
1927
1928                 t = strdup(value);
1929                 if (!t)
1930                         return log_oom();
1931
1932                 s->exec_context.tmp_dir = t;
1933         } else if (streq(key, "var-tmp-dir")) {
1934                 char *t;
1935
1936                 t = strdup(value);
1937                 if (!t)
1938                         return log_oom();
1939
1940                 s->exec_context.var_tmp_dir = t;
1941         } else
1942                 log_debug_unit(UNIT(s)->id,
1943                                "Unknown serialization key '%s'", key);
1944
1945         return 0;
1946 }
1947
1948 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1949         Socket *s = SOCKET(u);
1950         SocketPort *p;
1951
1952         assert(u);
1953
1954         LIST_FOREACH(port, p, s->ports) {
1955                 Iterator i;
1956                 int fd;
1957
1958                 if (p->type != SOCKET_SOCKET)
1959                         continue;
1960
1961                 if (p->fd >= 0)
1962                         continue;
1963
1964                 FDSET_FOREACH(fd, fds, i) {
1965                         if (socket_address_matches_fd(&p->address, fd)) {
1966                                 p->fd = fdset_remove(fds, fd);
1967                                 s->deserialized_state = SOCKET_LISTENING;
1968                                 break;
1969                         }
1970                 }
1971         }
1972
1973         return 0;
1974 }
1975
1976 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1977         assert(u);
1978
1979         return state_translation_table[SOCKET(u)->state];
1980 }
1981
1982 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1983         assert(u);
1984
1985         return socket_state_to_string(SOCKET(u)->state);
1986 }
1987
1988 const char* socket_port_type_to_string(SocketPort *p) {
1989
1990         assert(p);
1991
1992         switch (p->type) {
1993
1994         case SOCKET_SOCKET:
1995
1996                 switch (p->address.type) {
1997
1998                 case SOCK_STREAM:
1999                         return "Stream";
2000
2001                 case SOCK_DGRAM:
2002                         return "Datagram";
2003
2004                 case SOCK_SEQPACKET:
2005                         return "SequentialPacket";
2006
2007                 case SOCK_RAW:
2008                         if (socket_address_family(&p->address) == AF_NETLINK)
2009                                 return "Netlink";
2010
2011                 default:
2012                         return NULL;
2013                 }
2014
2015         case SOCKET_SPECIAL:
2016                 return "Special";
2017
2018         case SOCKET_MQUEUE:
2019                 return "MessageQueue";
2020
2021         case SOCKET_FIFO:
2022                 return "FIFO";
2023
2024         default:
2025                 return NULL;
2026         }
2027 }
2028
2029 _pure_ static bool socket_check_gc(Unit *u) {
2030         Socket *s = SOCKET(u);
2031
2032         assert(u);
2033
2034         return s->n_connections > 0;
2035 }
2036
2037 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2038         SocketPort *p = userdata;
2039         int cfd = -1;
2040
2041         assert(p);
2042         assert(fd >= 0);
2043
2044         if (p->socket->state != SOCKET_LISTENING)
2045                 return 0;
2046
2047         log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2048
2049         if (revents != EPOLLIN) {
2050
2051                 if (revents & EPOLLHUP)
2052                         log_error_unit(UNIT(p->socket)->id,
2053                                        "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2054                                        UNIT(p->socket)->id);
2055                 else
2056                         log_error_unit(UNIT(p->socket)->id,
2057                                        "%s: Got unexpected poll event (0x%x) on socket.",
2058                                        UNIT(p->socket)->id, revents);
2059
2060                 goto fail;
2061         }
2062
2063         if (p->socket->accept &&
2064             p->type == SOCKET_SOCKET &&
2065             socket_address_can_accept(&p->address)) {
2066
2067                 for (;;) {
2068
2069                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2070                         if (cfd < 0) {
2071
2072                                 if (errno == EINTR)
2073                                         continue;
2074
2075                                 log_error_unit(UNIT(p->socket)->id,
2076                                                "Failed to accept socket: %m");
2077                                 goto fail;
2078                         }
2079
2080                         break;
2081                 }
2082
2083                 socket_apply_socket_options(p->socket, cfd);
2084         }
2085
2086         socket_enter_running(p->socket, cfd);
2087         return 0;
2088
2089 fail:
2090         socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2091         return 0;
2092 }
2093
2094 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2095         Socket *s = SOCKET(u);
2096         SocketResult f;
2097
2098         assert(s);
2099         assert(pid >= 0);
2100
2101         if (pid != s->control_pid)
2102                 return;
2103
2104         s->control_pid = 0;
2105
2106         if (is_clean_exit(code, status, NULL))
2107                 f = SOCKET_SUCCESS;
2108         else if (code == CLD_EXITED)
2109                 f = SOCKET_FAILURE_EXIT_CODE;
2110         else if (code == CLD_KILLED)
2111                 f = SOCKET_FAILURE_SIGNAL;
2112         else if (code == CLD_DUMPED)
2113                 f = SOCKET_FAILURE_CORE_DUMP;
2114         else
2115                 assert_not_reached("Unknown code");
2116
2117         if (s->control_command) {
2118                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2119
2120                 if (s->control_command->ignore)
2121                         f = SOCKET_SUCCESS;
2122         }
2123
2124         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2125                       u->id,
2126                       "%s control process exited, code=%s status=%i",
2127                       u->id, sigchld_code_to_string(code), status);
2128
2129         if (f != SOCKET_SUCCESS)
2130                 s->result = f;
2131
2132         if (s->control_command &&
2133             s->control_command->command_next &&
2134             f == SOCKET_SUCCESS) {
2135
2136                 log_debug_unit(u->id,
2137                                "%s running next command for state %s",
2138                                u->id, socket_state_to_string(s->state));
2139                 socket_run_next(s);
2140         } else {
2141                 s->control_command = NULL;
2142                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2143
2144                 /* No further commands for this step, so let's figure
2145                  * out what to do next */
2146
2147                 log_debug_unit(u->id,
2148                                "%s got final SIGCHLD for state %s",
2149                                u->id, socket_state_to_string(s->state));
2150
2151                 switch (s->state) {
2152
2153                 case SOCKET_START_PRE:
2154                         if (f == SOCKET_SUCCESS)
2155                                 socket_enter_start_post(s);
2156                         else
2157                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2158                         break;
2159
2160                 case SOCKET_START_POST:
2161                         if (f == SOCKET_SUCCESS)
2162                                 socket_enter_listening(s);
2163                         else
2164                                 socket_enter_stop_pre(s, f);
2165                         break;
2166
2167                 case SOCKET_STOP_PRE:
2168                 case SOCKET_STOP_PRE_SIGTERM:
2169                 case SOCKET_STOP_PRE_SIGKILL:
2170                         socket_enter_stop_post(s, f);
2171                         break;
2172
2173                 case SOCKET_STOP_POST:
2174                 case SOCKET_FINAL_SIGTERM:
2175                 case SOCKET_FINAL_SIGKILL:
2176                         socket_enter_dead(s, f);
2177                         break;
2178
2179                 default:
2180                         assert_not_reached("Uh, control process died at wrong time.");
2181                 }
2182         }
2183
2184         /* Notify clients about changed exit status */
2185         unit_add_to_dbus_queue(u);
2186 }
2187
2188 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2189         Socket *s = SOCKET(userdata);
2190
2191         assert(s);
2192         assert(s->timer_event_source == source);
2193
2194         switch (s->state) {
2195
2196         case SOCKET_START_PRE:
2197                 log_warning_unit(UNIT(s)->id,
2198                                  "%s starting timed out. Terminating.", UNIT(s)->id);
2199                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2200                 break;
2201
2202         case SOCKET_START_POST:
2203                 log_warning_unit(UNIT(s)->id,
2204                                  "%s starting timed out. Stopping.", UNIT(s)->id);
2205                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2206                 break;
2207
2208         case SOCKET_STOP_PRE:
2209                 log_warning_unit(UNIT(s)->id,
2210                                  "%s stopping timed out. Terminating.", UNIT(s)->id);
2211                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2212                 break;
2213
2214         case SOCKET_STOP_PRE_SIGTERM:
2215                 if (s->kill_context.send_sigkill) {
2216                         log_warning_unit(UNIT(s)->id,
2217                                          "%s stopping timed out. Killing.", UNIT(s)->id);
2218                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2219                 } else {
2220                         log_warning_unit(UNIT(s)->id,
2221                                          "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2222                                          UNIT(s)->id);
2223                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2224                 }
2225                 break;
2226
2227         case SOCKET_STOP_PRE_SIGKILL:
2228                 log_warning_unit(UNIT(s)->id,
2229                                  "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2230                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2231                 break;
2232
2233         case SOCKET_STOP_POST:
2234                 log_warning_unit(UNIT(s)->id,
2235                                  "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2236                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2237                 break;
2238
2239         case SOCKET_FINAL_SIGTERM:
2240                 if (s->kill_context.send_sigkill) {
2241                         log_warning_unit(UNIT(s)->id,
2242                                          "%s stopping timed out (2). Killing.", UNIT(s)->id);
2243                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2244                 } else {
2245                         log_warning_unit(UNIT(s)->id,
2246                                          "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2247                                          UNIT(s)->id);
2248                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2249                 }
2250                 break;
2251
2252         case SOCKET_FINAL_SIGKILL:
2253                 log_warning_unit(UNIT(s)->id,
2254                                  "%s still around after SIGKILL (2). Entering failed mode.",
2255                                  UNIT(s)->id);
2256                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2257                 break;
2258
2259         default:
2260                 assert_not_reached("Timeout at wrong time.");
2261         }
2262
2263         return 0;
2264 }
2265
2266 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2267         int *rfds;
2268         unsigned rn_fds, k;
2269         SocketPort *p;
2270
2271         assert(s);
2272         assert(fds);
2273         assert(n_fds);
2274
2275         /* Called from the service code for requesting our fds */
2276
2277         rn_fds = 0;
2278         LIST_FOREACH(port, p, s->ports)
2279                 if (p->fd >= 0)
2280                         rn_fds++;
2281
2282         if (rn_fds <= 0) {
2283                 *fds = NULL;
2284                 *n_fds = 0;
2285                 return 0;
2286         }
2287
2288         if (!(rfds = new(int, rn_fds)))
2289                 return -ENOMEM;
2290
2291         k = 0;
2292         LIST_FOREACH(port, p, s->ports)
2293                 if (p->fd >= 0)
2294                         rfds[k++] = p->fd;
2295
2296         assert(k == rn_fds);
2297
2298         *fds = rfds;
2299         *n_fds = rn_fds;
2300
2301         return 0;
2302 }
2303
2304 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2305         assert(s);
2306
2307         /* The service is dead. Dang!
2308          *
2309          * This is strictly for one-instance-for-all-connections
2310          * services. */
2311
2312         if (s->state == SOCKET_RUNNING) {
2313                 log_debug_unit(UNIT(s)->id,
2314                                "%s got notified about service death (failed permanently: %s)",
2315                                UNIT(s)->id, yes_no(failed_permanent));
2316                 if (failed_permanent)
2317                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2318                 else
2319                         socket_enter_listening(s);
2320         }
2321 }
2322
2323 void socket_connection_unref(Socket *s) {
2324         assert(s);
2325
2326         /* The service is dead. Yay!
2327          *
2328          * This is strictly for one-instance-per-connection
2329          * services. */
2330
2331         assert(s->n_connections > 0);
2332         s->n_connections--;
2333
2334         log_debug_unit(UNIT(s)->id,
2335                        "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2336 }
2337
2338 static void socket_reset_failed(Unit *u) {
2339         Socket *s = SOCKET(u);
2340
2341         assert(s);
2342
2343         if (s->state == SOCKET_FAILED)
2344                 socket_set_state(s, SOCKET_DEAD);
2345
2346         s->result = SOCKET_SUCCESS;
2347 }
2348
2349 static void socket_trigger_notify(Unit *u, Unit *other) {
2350         Socket *s = SOCKET(u);
2351         Service *se = SERVICE(other);
2352
2353         assert(u);
2354         assert(other);
2355
2356         /* Don't propagate state changes from the service if we are
2357            already down or accepting connections */
2358         if ((s->state !=  SOCKET_RUNNING &&
2359             s->state != SOCKET_LISTENING) ||
2360             s->accept)
2361                 return;
2362
2363         if (other->load_state != UNIT_LOADED ||
2364             other->type != UNIT_SERVICE)
2365                 return;
2366
2367         if (se->state == SERVICE_FAILED)
2368                 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2369
2370         if (se->state == SERVICE_DEAD ||
2371             se->state == SERVICE_STOP ||
2372             se->state == SERVICE_STOP_SIGTERM ||
2373             se->state == SERVICE_STOP_SIGKILL ||
2374             se->state == SERVICE_STOP_POST ||
2375             se->state == SERVICE_FINAL_SIGTERM ||
2376             se->state == SERVICE_FINAL_SIGKILL ||
2377             se->state == SERVICE_AUTO_RESTART)
2378                 socket_notify_service_dead(s, false);
2379
2380         if (se->state == SERVICE_RUNNING)
2381                 socket_set_state(s, SOCKET_RUNNING);
2382 }
2383
2384 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2385         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2386 }
2387
2388 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2389         [SOCKET_DEAD] = "dead",
2390         [SOCKET_START_PRE] = "start-pre",
2391         [SOCKET_START_POST] = "start-post",
2392         [SOCKET_LISTENING] = "listening",
2393         [SOCKET_RUNNING] = "running",
2394         [SOCKET_STOP_PRE] = "stop-pre",
2395         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2396         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2397         [SOCKET_STOP_POST] = "stop-post",
2398         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2399         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2400         [SOCKET_FAILED] = "failed"
2401 };
2402
2403 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2404
2405 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2406         [SOCKET_EXEC_START_PRE] = "StartPre",
2407         [SOCKET_EXEC_START_POST] = "StartPost",
2408         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2409         [SOCKET_EXEC_STOP_POST] = "StopPost"
2410 };
2411
2412 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2413
2414 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2415         [SOCKET_SUCCESS] = "success",
2416         [SOCKET_FAILURE_RESOURCES] = "resources",
2417         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2418         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2419         [SOCKET_FAILURE_SIGNAL] = "signal",
2420         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2421         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2422 };
2423
2424 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2425
2426 const UnitVTable socket_vtable = {
2427         .object_size = sizeof(Socket),
2428         .exec_context_offset = offsetof(Socket, exec_context),
2429         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2430         .kill_context_offset = offsetof(Socket, kill_context),
2431
2432         .sections =
2433                 "Unit\0"
2434                 "Socket\0"
2435                 "Install\0",
2436         .private_section = "Socket",
2437
2438         .init = socket_init,
2439         .done = socket_done,
2440         .load = socket_load,
2441
2442         .coldplug = socket_coldplug,
2443
2444         .dump = socket_dump,
2445
2446         .start = socket_start,
2447         .stop = socket_stop,
2448
2449         .kill = socket_kill,
2450
2451         .serialize = socket_serialize,
2452         .deserialize_item = socket_deserialize_item,
2453         .distribute_fds = socket_distribute_fds,
2454
2455         .active_state = socket_active_state,
2456         .sub_state_to_string = socket_sub_state_to_string,
2457
2458         .check_gc = socket_check_gc,
2459
2460         .sigchld_event = socket_sigchld_event,
2461
2462         .trigger_notify = socket_trigger_notify,
2463
2464         .reset_failed = socket_reset_failed,
2465
2466         .bus_interface = "org.freedesktop.systemd1.Socket",
2467         .bus_vtable = bus_socket_vtable,
2468         .bus_changing_properties = bus_socket_changing_properties,
2469         .bus_set_property = bus_socket_set_property,
2470         .bus_commit_properties = bus_socket_commit_properties,
2471
2472         .status_message_formats = {
2473                 /*.starting_stopping = {
2474                         [0] = "Starting socket %s...",
2475                         [1] = "Stopping socket %s...",
2476                 },*/
2477                 .finished_start_job = {
2478                         [JOB_DONE]       = "Listening on %s.",
2479                         [JOB_FAILED]     = "Failed to listen on %s.",
2480                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2481                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2482                 },
2483                 .finished_stop_job = {
2484                         [JOB_DONE]       = "Closed %s.",
2485                         [JOB_FAILED]     = "Failed stopping %s.",
2486                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2487                 },
2488         },
2489 };