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