src/core/socket.c

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