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         if (s->smack_ip_in)
 779                 if (smack_label_ip_in_fd(fd, s->smack_ip_in) < 0)
 780                         log_error_unit(UNIT(s)->id, "smack_label_ip_in_fd: %m");
 781
 782         if (s->smack_ip_out)
 783                 if (smack_label_ip_out_fd(fd, s->smack_ip_out) < 0)
 784                         log_error_unit(UNIT(s)->id, "smack_label_ip_out_fd: %m");
 785 }
 786
 787 static void socket_apply_fifo_options(Socket *s, int fd) {
 788         assert(s);
 789         assert(fd >= 0);
 790
 791         if (s->pipe_size > 0)
 792                 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
 793                         log_warning_unit(UNIT(s)->id,
 794                                          "F_SETPIPE_SZ: %m");
 795
 796         if (s->smack)
 797                 if (smack_label_fd(fd, s->smack) < 0)
 798                         log_error_unit(UNIT(s)->id, "smack_label_fd: %m");
 799 }
 800
 801 static int fifo_address_create(
 802                 const char *path,
 803                 mode_t directory_mode,
 804                 mode_t socket_mode,
 805                 int *_fd) {
 806
 807         int fd = -1, r = 0;
 808         struct stat st;
 809         mode_t old_mask;
 810
 811         assert(path);
 812         assert(_fd);
 813
 814         mkdir_parents_label(path, directory_mode);
 815
 816         r = label_context_set(path, S_IFIFO);
 817         if (r < 0)
 818                 goto fail;
 819
 820         /* Enforce the right access mode for the fifo */
 821         old_mask = umask(~ socket_mode);
 822
 823         /* Include the original umask in our mask */
 824         umask(~socket_mode | old_mask);
 825
 826         r = mkfifo(path, socket_mode);
 827         umask(old_mask);
 828
 829         if (r < 0 && errno != EEXIST) {
 830                 r = -errno;
 831                 goto fail;
 832         }
 833
 834         if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 835                 r = -errno;
 836                 goto fail;
 837         }
 838
 839         label_context_clear();
 840
 841         if (fstat(fd, &st) < 0) {
 842                 r = -errno;
 843                 goto fail;
 844         }
 845
 846         if (!S_ISFIFO(st.st_mode) ||
 847             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
 848             st.st_uid != getuid() ||
 849             st.st_gid != getgid()) {
 850
 851                 r = -EEXIST;
 852                 goto fail;
 853         }
 854
 855         *_fd = fd;
 856         return 0;
 857
 858 fail:
 859         label_context_clear();
 860
 861         if (fd >= 0)
 862                 close_nointr_nofail(fd);
 863
 864         return r;
 865 }
 866
 867 static int special_address_create(
 868                 const char *path,
 869                 int *_fd) {
 870
 871         int fd = -1, r = 0;
 872         struct stat st;
 873
 874         assert(path);
 875         assert(_fd);
 876
 877         if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 878                 r = -errno;
 879                 goto fail;
 880         }
 881
 882         if (fstat(fd, &st) < 0) {
 883                 r = -errno;
 884                 goto fail;
 885         }
 886
 887         /* Check whether this is a /proc, /sys or /dev file or char device */
 888         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 889                 r = -EEXIST;
 890                 goto fail;
 891         }
 892
 893         *_fd = fd;
 894         return 0;
 895
 896 fail:
 897         if (fd >= 0)
 898                 close_nointr_nofail(fd);
 899
 900         return r;
 901 }
 902
 903 static int mq_address_create(
 904                 const char *path,
 905                 mode_t mq_mode,
 906                 long maxmsg,
 907                 long msgsize,
 908                 int *_fd) {
 909
 910         int fd = -1, r = 0;
 911         struct stat st;
 912         mode_t old_mask;
 913         struct mq_attr _attr, *attr = NULL;
 914
 915         assert(path);
 916         assert(_fd);
 917
 918         if (maxmsg > 0 && msgsize > 0) {
 919                 zero(_attr);
 920                 _attr.mq_flags = O_NONBLOCK;
 921                 _attr.mq_maxmsg = maxmsg;
 922                 _attr.mq_msgsize = msgsize;
 923                 attr = &_attr;
 924         }
 925
 926         /* Enforce the right access mode for the mq */
 927         old_mask = umask(~ mq_mode);
 928
 929         /* Include the original umask in our mask */
 930         umask(~mq_mode | old_mask);
 931
 932         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
 933         umask(old_mask);
 934
 935         if (fd < 0) {
 936                 r = -errno;
 937                 goto fail;
 938         }
 939
 940         if (fstat(fd, &st) < 0) {
 941                 r = -errno;
 942                 goto fail;
 943         }
 944
 945         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
 946             st.st_uid != getuid() ||
 947             st.st_gid != getgid()) {
 948
 949                 r = -EEXIST;
 950                 goto fail;
 951         }
 952
 953         *_fd = fd;
 954         return 0;
 955
 956 fail:
 957         if (fd >= 0)
 958                 close_nointr_nofail(fd);
 959
 960         return r;
 961 }
 962
 963 static int socket_open_fds(Socket *s) {
 964         SocketPort *p;
 965         int r;
 966         char *label = NULL;
 967         bool know_label = false;
 968
 969         assert(s);
 970
 971         LIST_FOREACH(port, p, s->ports) {
 972
 973                 if (p->fd >= 0)
 974                         continue;
 975
 976                 if (p->type == SOCKET_SOCKET) {
 977
 978                         if (!know_label) {
 979
 980                                 if ((r = socket_instantiate_service(s)) < 0)
 981                                         return r;
 982
 983                                 if (UNIT_ISSET(s->service) &&
 984                                     SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
 985                                         r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
 986
 987                                         if (r < 0) {
 988                                                 if (r != -EPERM)
 989                                                         return r;
 990                                         }
 991                                 }
 992
 993                                 know_label = true;
 994                         }
 995
 996                         if ((r = socket_address_listen(
 997                                              &p->address,
 998                                              s->backlog,
 999                                              s->bind_ipv6_only,
1000                                              s->bind_to_device,
1001                                              s->free_bind,
1002                                              s->transparent,
1003                                              s->directory_mode,
1004                                              s->socket_mode,
1005                                              label,
1006                                              &p->fd)) < 0)
1007                                 goto rollback;
1008
1009                         socket_apply_socket_options(s, p->fd);
1010
1011                 } else  if (p->type == SOCKET_SPECIAL) {
1012
1013                         if ((r = special_address_create(
1014                                              p->path,
1015                                              &p->fd)) < 0)
1016                                 goto rollback;
1017
1018                 } else  if (p->type == SOCKET_FIFO) {
1019
1020                         if ((r = fifo_address_create(
1021                                              p->path,
1022                                              s->directory_mode,
1023                                              s->socket_mode,
1024                                              &p->fd)) < 0)
1025                                 goto rollback;
1026
1027                         socket_apply_fifo_options(s, p->fd);
1028                 } else if (p->type == SOCKET_MQUEUE) {
1029
1030                         if ((r = mq_address_create(
1031                                              p->path,
1032                                              s->socket_mode,
1033                                              s->mq_maxmsg,
1034                                              s->mq_msgsize,
1035                                              &p->fd)) < 0)
1036                                 goto rollback;
1037                 } else
1038                         assert_not_reached("Unknown port type");
1039         }
1040
1041         label_free(label);
1042         return 0;
1043
1044 rollback:
1045         socket_close_fds(s);
1046         label_free(label);
1047         return r;
1048 }
1049
1050 static void socket_unwatch_fds(Socket *s) {
1051         SocketPort *p;
1052
1053         assert(s);
1054
1055         LIST_FOREACH(port, p, s->ports) {
1056                 if (p->fd < 0)
1057                         continue;
1058
1059                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1060         }
1061 }
1062
1063 static int socket_watch_fds(Socket *s) {
1064         SocketPort *p;
1065         int r;
1066
1067         assert(s);
1068
1069         LIST_FOREACH(port, p, s->ports) {
1070                 if (p->fd < 0)
1071                         continue;
1072
1073                 p->fd_watch.socket_accept =
1074                         s->accept &&
1075                         p->type == SOCKET_SOCKET &&
1076                         socket_address_can_accept(&p->address);
1077
1078                 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1079                         goto fail;
1080         }
1081
1082         return 0;
1083
1084 fail:
1085         socket_unwatch_fds(s);
1086         return r;
1087 }
1088
1089 static void socket_set_state(Socket *s, SocketState state) {
1090         SocketState old_state;
1091         assert(s);
1092
1093         old_state = s->state;
1094         s->state = state;
1095
1096         if (state != SOCKET_START_PRE &&
1097             state != SOCKET_START_POST &&
1098             state != SOCKET_STOP_PRE &&
1099             state != SOCKET_STOP_PRE_SIGTERM &&
1100             state != SOCKET_STOP_PRE_SIGKILL &&
1101             state != SOCKET_STOP_POST &&
1102             state != SOCKET_FINAL_SIGTERM &&
1103             state != SOCKET_FINAL_SIGKILL) {
1104                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1105                 socket_unwatch_control_pid(s);
1106                 s->control_command = NULL;
1107                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1108         }
1109
1110         if (state != SOCKET_LISTENING)
1111                 socket_unwatch_fds(s);
1112
1113         if (state != SOCKET_START_POST &&
1114             state != SOCKET_LISTENING &&
1115             state != SOCKET_RUNNING &&
1116             state != SOCKET_STOP_PRE &&
1117             state != SOCKET_STOP_PRE_SIGTERM &&
1118             state != SOCKET_STOP_PRE_SIGKILL)
1119                 socket_close_fds(s);
1120
1121         if (state != old_state)
1122                 log_debug_unit(UNIT(s)->id,
1123                                "%s changed %s -> %s", UNIT(s)->id,
1124                                socket_state_to_string(old_state),
1125                                socket_state_to_string(state));
1126
1127         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1128 }
1129
1130 static int socket_coldplug(Unit *u) {
1131         Socket *s = SOCKET(u);
1132         int r;
1133
1134         assert(s);
1135         assert(s->state == SOCKET_DEAD);
1136
1137         if (s->deserialized_state != s->state) {
1138
1139                 if (s->deserialized_state == SOCKET_START_PRE ||
1140                     s->deserialized_state == SOCKET_START_POST ||
1141                     s->deserialized_state == SOCKET_STOP_PRE ||
1142                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1143                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1144                     s->deserialized_state == SOCKET_STOP_POST ||
1145                     s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1146                     s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1147
1148                         if (s->control_pid <= 0)
1149                                 return -EBADMSG;
1150
1151                         r = unit_watch_pid(UNIT(s), s->control_pid);
1152                         if (r < 0)
1153                                 return r;
1154
1155                         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1156                         if (r < 0)
1157                                 return r;
1158                 }
1159
1160                 if (s->deserialized_state == SOCKET_START_POST ||
1161                     s->deserialized_state == SOCKET_LISTENING ||
1162                     s->deserialized_state == SOCKET_RUNNING ||
1163                     s->deserialized_state == SOCKET_STOP_PRE ||
1164                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1165                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1166                         if ((r = socket_open_fds(s)) < 0)
1167                                 return r;
1168
1169                 if (s->deserialized_state == SOCKET_LISTENING)
1170                         if ((r = socket_watch_fds(s)) < 0)
1171                                 return r;
1172
1173                 socket_set_state(s, s->deserialized_state);
1174         }
1175
1176         return 0;
1177 }
1178
1179 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1180         pid_t pid;
1181         int r;
1182         char **argv;
1183
1184         assert(s);
1185         assert(c);
1186         assert(_pid);
1187
1188         unit_realize_cgroup(UNIT(s));
1189
1190         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1191         if (r < 0)
1192                 goto fail;
1193
1194         r = unit_full_printf_strv(UNIT(s), c->argv, &argv);
1195         if (r < 0)
1196                 goto fail;
1197
1198         r = exec_spawn(c,
1199                        argv,
1200                        &s->exec_context,
1201                        NULL, 0,
1202                        UNIT(s)->manager->environment,
1203                        true,
1204                        true,
1205                        true,
1206                        UNIT(s)->manager->confirm_spawn,
1207                        UNIT(s)->manager->cgroup_supported,
1208                        UNIT(s)->cgroup_path,
1209                        UNIT(s)->id,
1210                        NULL,
1211                        &pid);
1212
1213         strv_free(argv);
1214         if (r < 0)
1215                 goto fail;
1216
1217         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1218                 /* FIXME: we need to do something here */
1219                 goto fail;
1220
1221         *_pid = pid;
1222
1223         return 0;
1224
1225 fail:
1226         unit_unwatch_timer(UNIT(s), &s->timer_watch);
1227
1228         return r;
1229 }
1230
1231 static void socket_enter_dead(Socket *s, SocketResult f) {
1232         assert(s);
1233
1234         if (f != SOCKET_SUCCESS)
1235                 s->result = f;
1236
1237         exec_context_tmp_dirs_done(&s->exec_context);
1238         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1239 }
1240
1241 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1242
1243 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1244         int r;
1245         assert(s);
1246
1247         if (f != SOCKET_SUCCESS)
1248                 s->result = f;
1249
1250         socket_unwatch_control_pid(s);
1251
1252         s->control_command_id = SOCKET_EXEC_STOP_POST;
1253
1254         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1255                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1256                         goto fail;
1257
1258                 socket_set_state(s, SOCKET_STOP_POST);
1259         } else
1260                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1261
1262         return;
1263
1264 fail:
1265         log_warning_unit(UNIT(s)->id,
1266                          "%s failed to run 'stop-post' task: %s",
1267                          UNIT(s)->id, strerror(-r));
1268         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1269 }
1270
1271 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1272         int r;
1273
1274         assert(s);
1275
1276         if (f != SOCKET_SUCCESS)
1277                 s->result = f;
1278
1279         r = unit_kill_context(
1280                         UNIT(s),
1281                         &s->kill_context,
1282                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1283                         -1,
1284                         s->control_pid,
1285                         false);
1286         if (r < 0)
1287                 goto fail;
1288
1289         if (r > 0) {
1290                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1291                 if (r < 0)
1292                         goto fail;
1293
1294                 socket_set_state(s, state);
1295         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1296                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1297         else
1298                 socket_enter_dead(s, SOCKET_SUCCESS);
1299
1300         return;
1301
1302 fail:
1303         log_warning_unit(UNIT(s)->id,
1304                          "%s failed to kill processes: %s",
1305                          UNIT(s)->id, strerror(-r));
1306
1307         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1308                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1309         else
1310                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1311 }
1312
1313 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1314         int r;
1315         assert(s);
1316
1317         if (f != SOCKET_SUCCESS)
1318                 s->result = f;
1319
1320         socket_unwatch_control_pid(s);
1321
1322         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1323
1324         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1325                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1326                         goto fail;
1327
1328                 socket_set_state(s, SOCKET_STOP_PRE);
1329         } else
1330                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1331
1332         return;
1333
1334 fail:
1335         log_warning_unit(UNIT(s)->id,
1336                          "%s failed to run 'stop-pre' task: %s",
1337                          UNIT(s)->id, strerror(-r));
1338         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1339 }
1340
1341 static void socket_enter_listening(Socket *s) {
1342         int r;
1343         assert(s);
1344
1345         r = socket_watch_fds(s);
1346         if (r < 0) {
1347                 log_warning_unit(UNIT(s)->id,
1348                                  "%s failed to watch sockets: %s",
1349                                  UNIT(s)->id, strerror(-r));
1350                 goto fail;
1351         }
1352
1353         socket_set_state(s, SOCKET_LISTENING);
1354         return;
1355
1356 fail:
1357         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1358 }
1359
1360 static void socket_enter_start_post(Socket *s) {
1361         int r;
1362         assert(s);
1363
1364         r = socket_open_fds(s);
1365         if (r < 0) {
1366                 log_warning_unit(UNIT(s)->id,
1367                                  "%s failed to listen on sockets: %s",
1368                                  UNIT(s)->id, strerror(-r));
1369                 goto fail;
1370         }
1371
1372         socket_unwatch_control_pid(s);
1373
1374         s->control_command_id = SOCKET_EXEC_START_POST;
1375
1376         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1377                 r = socket_spawn(s, s->control_command, &s->control_pid);
1378                 if (r < 0) {
1379                         log_warning_unit(UNIT(s)->id,
1380                                          "%s failed to run 'start-post' task: %s",
1381                                          UNIT(s)->id, strerror(-r));
1382                         goto fail;
1383                 }
1384
1385                 socket_set_state(s, SOCKET_START_POST);
1386         } else
1387                 socket_enter_listening(s);
1388
1389         return;
1390
1391 fail:
1392         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1393 }
1394
1395 static void socket_enter_start_pre(Socket *s) {
1396         int r;
1397         assert(s);
1398
1399         socket_unwatch_control_pid(s);
1400
1401         s->control_command_id = SOCKET_EXEC_START_PRE;
1402
1403         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1404                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1405                         goto fail;
1406
1407                 socket_set_state(s, SOCKET_START_PRE);
1408         } else
1409                 socket_enter_start_post(s);
1410
1411         return;
1412
1413 fail:
1414         log_warning_unit(UNIT(s)->id,
1415                          "%s failed to run 'start-pre' task: %s",
1416                          UNIT(s)->id, strerror(-r));
1417         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1418 }
1419
1420 static void socket_enter_running(Socket *s, int cfd) {
1421         int r;
1422         DBusError error;
1423
1424         assert(s);
1425         dbus_error_init(&error);
1426
1427         /* We don't take connections anymore if we are supposed to
1428          * shut down anyway */
1429         if (unit_stop_pending(UNIT(s))) {
1430                 log_debug_unit(UNIT(s)->id,
1431                                "Suppressing connection request on %s since unit stop is scheduled.",
1432                                UNIT(s)->id);
1433
1434                 if (cfd >= 0)
1435                         close_nointr_nofail(cfd);
1436                 else  {
1437                         /* Flush all sockets by closing and reopening them */
1438                         socket_close_fds(s);
1439
1440                         r = socket_watch_fds(s);
1441                         if (r < 0) {
1442                                 log_warning_unit(UNIT(s)->id,
1443                                                  "%s failed to watch sockets: %s",
1444                                                  UNIT(s)->id, strerror(-r));
1445                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1446                         }
1447                 }
1448
1449                 return;
1450         }
1451
1452         if (cfd < 0) {
1453                 Iterator i;
1454                 Unit *u;
1455                 bool pending = false;
1456
1457                 /* If there's already a start pending don't bother to
1458                  * do anything */
1459                 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1460                         if (unit_active_or_pending(u)) {
1461                                 pending = true;
1462                                 break;
1463                         }
1464
1465                 if (!pending) {
1466                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1467                         if (r < 0)
1468                                 goto fail;
1469                 }
1470
1471                 socket_set_state(s, SOCKET_RUNNING);
1472         } else {
1473                 char *prefix, *instance = NULL, *name;
1474                 Service *service;
1475
1476                 if (s->n_connections >= s->max_connections) {
1477                         log_warning_unit(UNIT(s)->id,
1478                                          "%s: Too many incoming connections (%u)",
1479                                          UNIT(s)->id, s->n_connections);
1480                         close_nointr_nofail(cfd);
1481                         return;
1482                 }
1483
1484                 r = socket_instantiate_service(s);
1485                 if (r < 0)
1486                         goto fail;
1487
1488                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1489                 if (r < 0) {
1490                         if (r != -ENOTCONN)
1491                                 goto fail;
1492
1493                         /* ENOTCONN is legitimate if TCP RST was received.
1494                          * This connection is over, but the socket unit lives on. */
1495                         close_nointr_nofail(cfd);
1496                         return;
1497                 }
1498
1499                 prefix = unit_name_to_prefix(UNIT(s)->id);
1500                 if (!prefix) {
1501                         free(instance);
1502                         r = -ENOMEM;
1503                         goto fail;
1504                 }
1505
1506                 name = unit_name_build(prefix, instance, ".service");
1507                 free(prefix);
1508                 free(instance);
1509
1510                 if (!name) {
1511                         r = -ENOMEM;
1512                         goto fail;
1513                 }
1514
1515                 r = unit_add_name(UNIT_DEREF(s->service), name);
1516                 if (r < 0) {
1517                         free(name);
1518                         goto fail;
1519                 }
1520
1521                 service = SERVICE(UNIT_DEREF(s->service));
1522                 unit_ref_unset(&s->service);
1523                 s->n_accepted ++;
1524
1525                 UNIT(service)->no_gc = false;
1526
1527                 unit_choose_id(UNIT(service), name);
1528                 free(name);
1529
1530                 r = service_set_socket_fd(service, cfd, s);
1531                 if (r < 0)
1532                         goto fail;
1533
1534                 cfd = -1;
1535                 s->n_connections ++;
1536
1537                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1538                 if (r < 0)
1539                         goto fail;
1540
1541                 /* Notify clients about changed counters */
1542                 unit_add_to_dbus_queue(UNIT(s));
1543         }
1544
1545         return;
1546
1547 fail:
1548         log_warning_unit(UNIT(s)->id,
1549                          "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1550                          UNIT(s)->id,
1551                          cfd >= 0 ? "template" : "non-template",
1552                          bus_error(&error, r));
1553         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1554
1555         if (cfd >= 0)
1556                 close_nointr_nofail(cfd);
1557
1558         dbus_error_free(&error);
1559 }
1560
1561 static void socket_run_next(Socket *s) {
1562         int r;
1563
1564         assert(s);
1565         assert(s->control_command);
1566         assert(s->control_command->command_next);
1567
1568         socket_unwatch_control_pid(s);
1569
1570         s->control_command = s->control_command->command_next;
1571
1572         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1573                 goto fail;
1574
1575         return;
1576
1577 fail:
1578         log_warning_unit(UNIT(s)->id,
1579                          "%s failed to run next task: %s",
1580                          UNIT(s)->id, strerror(-r));
1581
1582         if (s->state == SOCKET_START_POST)
1583                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1584         else if (s->state == SOCKET_STOP_POST)
1585                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1586         else
1587                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1588 }
1589
1590 static int socket_start(Unit *u) {
1591         Socket *s = SOCKET(u);
1592
1593         assert(s);
1594
1595         /* We cannot fulfill this request right now, try again later
1596          * please! */
1597         if (s->state == SOCKET_STOP_PRE ||
1598             s->state == SOCKET_STOP_PRE_SIGKILL ||
1599             s->state == SOCKET_STOP_PRE_SIGTERM ||
1600             s->state == SOCKET_STOP_POST ||
1601             s->state == SOCKET_FINAL_SIGTERM ||
1602             s->state == SOCKET_FINAL_SIGKILL)
1603                 return -EAGAIN;
1604
1605         if (s->state == SOCKET_START_PRE ||
1606             s->state == SOCKET_START_POST)
1607                 return 0;
1608
1609         /* Cannot run this without the service being around */
1610         if (UNIT_ISSET(s->service)) {
1611                 Service *service;
1612
1613                 service = SERVICE(UNIT_DEREF(s->service));
1614
1615                 if (UNIT(service)->load_state != UNIT_LOADED) {
1616                         log_error_unit(u->id,
1617                                        "Socket service %s not loaded, refusing.",
1618                                        UNIT(service)->id);
1619                         return -ENOENT;
1620                 }
1621
1622                 /* If the service is already active we cannot start the
1623                  * socket */
1624                 if (service->state != SERVICE_DEAD &&
1625                     service->state != SERVICE_FAILED &&
1626                     service->state != SERVICE_AUTO_RESTART) {
1627                         log_error_unit(u->id,
1628                                        "Socket service %s already active, refusing.",
1629                                        UNIT(service)->id);
1630                         return -EBUSY;
1631                 }
1632
1633 #ifdef HAVE_SYSV_COMPAT
1634                 if (service->is_sysv) {
1635                         log_error_unit(u->id,
1636                                        "Using SysV services for socket activation is not supported. Refusing.");
1637                         return -ENOENT;
1638                 }
1639 #endif
1640         }
1641
1642         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1643
1644         s->result = SOCKET_SUCCESS;
1645         socket_enter_start_pre(s);
1646         return 0;
1647 }
1648
1649 static int socket_stop(Unit *u) {
1650         Socket *s = SOCKET(u);
1651
1652         assert(s);
1653
1654         /* Already on it */
1655         if (s->state == SOCKET_STOP_PRE ||
1656             s->state == SOCKET_STOP_PRE_SIGTERM ||
1657             s->state == SOCKET_STOP_PRE_SIGKILL ||
1658             s->state == SOCKET_STOP_POST ||
1659             s->state == SOCKET_FINAL_SIGTERM ||
1660             s->state == SOCKET_FINAL_SIGKILL)
1661                 return 0;
1662
1663         /* If there's already something running we go directly into
1664          * kill mode. */
1665         if (s->state == SOCKET_START_PRE ||
1666             s->state == SOCKET_START_POST) {
1667                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1668                 return -EAGAIN;
1669         }
1670
1671         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1672
1673         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1674         return 0;
1675 }
1676
1677 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1678         Socket *s = SOCKET(u);
1679         SocketPort *p;
1680         int r;
1681
1682         assert(u);
1683         assert(f);
1684         assert(fds);
1685
1686         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1687         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1688         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1689
1690         if (s->control_pid > 0)
1691                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1692
1693         if (s->control_command_id >= 0)
1694                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1695
1696         LIST_FOREACH(port, p, s->ports) {
1697                 int copy;
1698
1699                 if (p->fd < 0)
1700                         continue;
1701
1702                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1703                         return copy;
1704
1705                 if (p->type == SOCKET_SOCKET) {
1706                         char *t;
1707
1708                         r = socket_address_print(&p->address, &t);
1709                         if (r < 0)
1710                                 return r;
1711
1712                         if (socket_address_family(&p->address) == AF_NETLINK)
1713                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1714                         else
1715                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1716                         free(t);
1717                 } else if (p->type == SOCKET_SPECIAL)
1718                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1719                 else if (p->type == SOCKET_MQUEUE)
1720                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1721                 else {
1722                         assert(p->type == SOCKET_FIFO);
1723                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1724                 }
1725         }
1726
1727         exec_context_serialize(&s->exec_context, UNIT(s), f);
1728
1729         return 0;
1730 }
1731
1732 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1733         Socket *s = SOCKET(u);
1734
1735         assert(u);
1736         assert(key);
1737         assert(value);
1738         assert(fds);
1739
1740         if (streq(key, "state")) {
1741                 SocketState state;
1742
1743                 state = socket_state_from_string(value);
1744                 if (state < 0)
1745                         log_debug_unit(u->id,
1746                                        "Failed to parse state value %s", value);
1747                 else
1748                         s->deserialized_state = state;
1749         } else if (streq(key, "result")) {
1750                 SocketResult f;
1751
1752                 f = socket_result_from_string(value);
1753                 if (f < 0)
1754                         log_debug_unit(u->id,
1755                                        "Failed to parse result value %s", value);
1756                 else if (f != SOCKET_SUCCESS)
1757                         s->result = f;
1758
1759         } else if (streq(key, "n-accepted")) {
1760                 unsigned k;
1761
1762                 if (safe_atou(value, &k) < 0)
1763                         log_debug_unit(u->id,
1764                                        "Failed to parse n-accepted value %s", value);
1765                 else
1766                         s->n_accepted += k;
1767         } else if (streq(key, "control-pid")) {
1768                 pid_t pid;
1769
1770                 if (parse_pid(value, &pid) < 0)
1771                         log_debug_unit(u->id,
1772                                        "Failed to parse control-pid value %s", value);
1773                 else
1774                         s->control_pid = pid;
1775         } else if (streq(key, "control-command")) {
1776                 SocketExecCommand id;
1777
1778                 id = socket_exec_command_from_string(value);
1779                 if (id < 0)
1780                         log_debug_unit(u->id,
1781                                        "Failed to parse exec-command value %s", value);
1782                 else {
1783                         s->control_command_id = id;
1784                         s->control_command = s->exec_command[id];
1785                 }
1786         } else if (streq(key, "fifo")) {
1787                 int fd, skip = 0;
1788                 SocketPort *p;
1789
1790                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1791                         log_debug_unit(u->id,
1792                                        "Failed to parse fifo value %s", value);
1793                 else {
1794
1795                         LIST_FOREACH(port, p, s->ports)
1796                                 if (p->type == SOCKET_FIFO &&
1797                                     streq_ptr(p->path, value+skip))
1798                                         break;
1799
1800                         if (p) {
1801                                 if (p->fd >= 0)
1802                                         close_nointr_nofail(p->fd);
1803                                 p->fd = fdset_remove(fds, fd);
1804                         }
1805                 }
1806
1807         } else if (streq(key, "special")) {
1808                 int fd, skip = 0;
1809                 SocketPort *p;
1810
1811                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1812                         log_debug_unit(u->id,
1813                                        "Failed to parse special value %s", value);
1814                 else {
1815
1816                         LIST_FOREACH(port, p, s->ports)
1817                                 if (p->type == SOCKET_SPECIAL &&
1818                                     streq_ptr(p->path, value+skip))
1819                                         break;
1820
1821                         if (p) {
1822                                 if (p->fd >= 0)
1823                                         close_nointr_nofail(p->fd);
1824                                 p->fd = fdset_remove(fds, fd);
1825                         }
1826                 }
1827
1828         } else if (streq(key, "mqueue")) {
1829                 int fd, skip = 0;
1830                 SocketPort *p;
1831
1832                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1833                         log_debug_unit(u->id,
1834                                        "Failed to parse mqueue value %s", value);
1835                 else {
1836
1837                         LIST_FOREACH(port, p, s->ports)
1838                                 if (p->type == SOCKET_MQUEUE &&
1839                                     streq_ptr(p->path, value+skip))
1840                                         break;
1841
1842                         if (p) {
1843                                 if (p->fd >= 0)
1844                                         close_nointr_nofail(p->fd);
1845                                 p->fd = fdset_remove(fds, fd);
1846                         }
1847                 }
1848
1849         } else if (streq(key, "socket")) {
1850                 int fd, type, skip = 0;
1851                 SocketPort *p;
1852
1853                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1854                         log_debug_unit(u->id,
1855                                        "Failed to parse socket value %s", value);
1856                 else {
1857
1858                         LIST_FOREACH(port, p, s->ports)
1859                                 if (socket_address_is(&p->address, value+skip, type))
1860                                         break;
1861
1862                         if (p) {
1863                                 if (p->fd >= 0)
1864                                         close_nointr_nofail(p->fd);
1865                                 p->fd = fdset_remove(fds, fd);
1866                         }
1867                 }
1868
1869         } else if (streq(key, "netlink")) {
1870                 int fd, skip = 0;
1871                 SocketPort *p;
1872
1873                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1874                         log_debug_unit(u->id,
1875                                        "Failed to parse socket value %s", value);
1876                 else {
1877
1878                         LIST_FOREACH(port, p, s->ports)
1879                                 if (socket_address_is_netlink(&p->address, value+skip))
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         } else if (streq(key, "tmp-dir")) {
1889                 char *t;
1890
1891                 t = strdup(value);
1892                 if (!t)
1893                         return log_oom();
1894
1895                 s->exec_context.tmp_dir = t;
1896         } else if (streq(key, "var-tmp-dir")) {
1897                 char *t;
1898
1899                 t = strdup(value);
1900                 if (!t)
1901                         return log_oom();
1902
1903                 s->exec_context.var_tmp_dir = t;
1904         } else
1905                 log_debug_unit(UNIT(s)->id,
1906                                "Unknown serialization key '%s'", key);
1907
1908         return 0;
1909 }
1910
1911 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1912         Socket *s = SOCKET(u);
1913         SocketPort *p;
1914
1915         assert(u);
1916
1917         LIST_FOREACH(port, p, s->ports) {
1918                 Iterator i;
1919                 int fd;
1920
1921                 if (p->type != SOCKET_SOCKET)
1922                         continue;
1923
1924                 if (p->fd >= 0)
1925                         continue;
1926
1927                 FDSET_FOREACH(fd, fds, i) {
1928                         if (socket_address_matches_fd(&p->address, fd)) {
1929                                 p->fd = fdset_remove(fds, fd);
1930                                 s->deserialized_state = SOCKET_LISTENING;
1931                                 break;
1932                         }
1933                 }
1934         }
1935
1936         return 0;
1937 }
1938
1939 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1940         assert(u);
1941
1942         return state_translation_table[SOCKET(u)->state];
1943 }
1944
1945 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1946         assert(u);
1947
1948         return socket_state_to_string(SOCKET(u)->state);
1949 }
1950
1951 const char* socket_port_type_to_string(SocketPort *p) {
1952
1953         assert(p);
1954
1955         switch (p->type) {
1956                 case SOCKET_SOCKET:
1957                         switch (p->address.type) {
1958                                 case SOCK_STREAM: return "Stream";
1959                                 case SOCK_DGRAM: return "Datagram";
1960                                 case SOCK_SEQPACKET: return "SequentialPacket";
1961                                 case SOCK_RAW:
1962                                         if (socket_address_family(&p->address) == AF_NETLINK)
1963                                                 return "Netlink";
1964                                 default: return "Invalid";
1965                         }
1966                 case SOCKET_SPECIAL: return "Special";
1967                 case SOCKET_MQUEUE: return "MessageQueue";
1968                 case SOCKET_FIFO: return "FIFO";
1969                 default: return NULL;
1970         }
1971 }
1972
1973 _pure_ static bool socket_check_gc(Unit *u) {
1974         Socket *s = SOCKET(u);
1975
1976         assert(u);
1977
1978         return s->n_connections > 0;
1979 }
1980
1981 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1982         Socket *s = SOCKET(u);
1983         int cfd = -1;
1984
1985         assert(s);
1986         assert(fd >= 0);
1987
1988         if (s->state != SOCKET_LISTENING)
1989                 return;
1990
1991         log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1992
1993         if (events != EPOLLIN) {
1994
1995                 if (events & EPOLLHUP)
1996                         log_error_unit(u->id,
1997                                        "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
1998                                        u->id);
1999                 else
2000                         log_error_unit(u->id,
2001                                        "%s: Got unexpected poll event (0x%x) on socket.",
2002                                        u->id, events);
2003
2004                 goto fail;
2005         }
2006
2007         if (w->socket_accept) {
2008                 for (;;) {
2009
2010                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2011                         if (cfd < 0) {
2012
2013                                 if (errno == EINTR)
2014                                         continue;
2015
2016                                 log_error_unit(u->id,
2017                                                "Failed to accept socket: %m");
2018                                 goto fail;
2019                         }
2020
2021                         break;
2022                 }
2023
2024                 socket_apply_socket_options(s, cfd);
2025         }
2026
2027         socket_enter_running(s, cfd);
2028         return;
2029
2030 fail:
2031         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2032 }
2033
2034 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2035         Socket *s = SOCKET(u);
2036         SocketResult f;
2037
2038         assert(s);
2039         assert(pid >= 0);
2040
2041         if (pid != s->control_pid)
2042                 return;
2043
2044         s->control_pid = 0;
2045
2046         if (is_clean_exit(code, status, NULL))
2047                 f = SOCKET_SUCCESS;
2048         else if (code == CLD_EXITED)
2049                 f = SOCKET_FAILURE_EXIT_CODE;
2050         else if (code == CLD_KILLED)
2051                 f = SOCKET_FAILURE_SIGNAL;
2052         else if (code == CLD_DUMPED)
2053                 f = SOCKET_FAILURE_CORE_DUMP;
2054         else
2055                 assert_not_reached("Unknown code");
2056
2057         if (s->control_command) {
2058                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2059
2060                 if (s->control_command->ignore)
2061                         f = SOCKET_SUCCESS;
2062         }
2063
2064         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2065                       u->id,
2066                       "%s control process exited, code=%s status=%i",
2067                       u->id, sigchld_code_to_string(code), status);
2068
2069         if (f != SOCKET_SUCCESS)
2070                 s->result = f;
2071
2072         if (s->control_command &&
2073             s->control_command->command_next &&
2074             f == SOCKET_SUCCESS) {
2075
2076                 log_debug_unit(u->id,
2077                                "%s running next command for state %s",
2078                                u->id, socket_state_to_string(s->state));
2079                 socket_run_next(s);
2080         } else {
2081                 s->control_command = NULL;
2082                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2083
2084                 /* No further commands for this step, so let's figure
2085                  * out what to do next */
2086
2087                 log_debug_unit(u->id,
2088                                "%s got final SIGCHLD for state %s",
2089                                u->id, socket_state_to_string(s->state));
2090
2091                 switch (s->state) {
2092
2093                 case SOCKET_START_PRE:
2094                         if (f == SOCKET_SUCCESS)
2095                                 socket_enter_start_post(s);
2096                         else
2097                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2098                         break;
2099
2100                 case SOCKET_START_POST:
2101                         if (f == SOCKET_SUCCESS)
2102                                 socket_enter_listening(s);
2103                         else
2104                                 socket_enter_stop_pre(s, f);
2105                         break;
2106
2107                 case SOCKET_STOP_PRE:
2108                 case SOCKET_STOP_PRE_SIGTERM:
2109                 case SOCKET_STOP_PRE_SIGKILL:
2110                         socket_enter_stop_post(s, f);
2111                         break;
2112
2113                 case SOCKET_STOP_POST:
2114                 case SOCKET_FINAL_SIGTERM:
2115                 case SOCKET_FINAL_SIGKILL:
2116                         socket_enter_dead(s, f);
2117                         break;
2118
2119                 default:
2120                         assert_not_reached("Uh, control process died at wrong time.");
2121                 }
2122         }
2123
2124         /* Notify clients about changed exit status */
2125         unit_add_to_dbus_queue(u);
2126 }
2127
2128 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2129         Socket *s = SOCKET(u);
2130
2131         assert(s);
2132         assert(elapsed == 1);
2133         assert(w == &s->timer_watch);
2134
2135         switch (s->state) {
2136
2137         case SOCKET_START_PRE:
2138                 log_warning_unit(u->id,
2139                                  "%s starting timed out. Terminating.", u->id);
2140                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2141                 break;
2142
2143         case SOCKET_START_POST:
2144                 log_warning_unit(u->id,
2145                                  "%s starting timed out. Stopping.", u->id);
2146                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2147                 break;
2148
2149         case SOCKET_STOP_PRE:
2150                 log_warning_unit(u->id,
2151                                  "%s stopping timed out. Terminating.", u->id);
2152                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2153                 break;
2154
2155         case SOCKET_STOP_PRE_SIGTERM:
2156                 if (s->kill_context.send_sigkill) {
2157                         log_warning_unit(u->id,
2158                                          "%s stopping timed out. Killing.", u->id);
2159                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2160                 } else {
2161                         log_warning_unit(u->id,
2162                                          "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2163                                          u->id);
2164                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2165                 }
2166                 break;
2167
2168         case SOCKET_STOP_PRE_SIGKILL:
2169                 log_warning_unit(u->id,
2170                                  "%s still around after SIGKILL. Ignoring.", u->id);
2171                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2172                 break;
2173
2174         case SOCKET_STOP_POST:
2175                 log_warning_unit(u->id,
2176                                  "%s stopping timed out (2). Terminating.", u->id);
2177                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2178                 break;
2179
2180         case SOCKET_FINAL_SIGTERM:
2181                 if (s->kill_context.send_sigkill) {
2182                         log_warning_unit(u->id,
2183                                          "%s stopping timed out (2). Killing.", u->id);
2184                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2185                 } else {
2186                         log_warning_unit(u->id,
2187                                          "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2188                                          u->id);
2189                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2190                 }
2191                 break;
2192
2193         case SOCKET_FINAL_SIGKILL:
2194                 log_warning_unit(u->id,
2195                                  "%s still around after SIGKILL (2). Entering failed mode.",
2196                                  u->id);
2197                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2198                 break;
2199
2200         default:
2201                 assert_not_reached("Timeout at wrong time.");
2202         }
2203 }
2204
2205 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2206         int *rfds;
2207         unsigned rn_fds, k;
2208         SocketPort *p;
2209
2210         assert(s);
2211         assert(fds);
2212         assert(n_fds);
2213
2214         /* Called from the service code for requesting our fds */
2215
2216         rn_fds = 0;
2217         LIST_FOREACH(port, p, s->ports)
2218                 if (p->fd >= 0)
2219                         rn_fds++;
2220
2221         if (rn_fds <= 0) {
2222                 *fds = NULL;
2223                 *n_fds = 0;
2224                 return 0;
2225         }
2226
2227         if (!(rfds = new(int, rn_fds)))
2228                 return -ENOMEM;
2229
2230         k = 0;
2231         LIST_FOREACH(port, p, s->ports)
2232                 if (p->fd >= 0)
2233                         rfds[k++] = p->fd;
2234
2235         assert(k == rn_fds);
2236
2237         *fds = rfds;
2238         *n_fds = rn_fds;
2239
2240         return 0;
2241 }
2242
2243 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2244         assert(s);
2245
2246         /* The service is dead. Dang!
2247          *
2248          * This is strictly for one-instance-for-all-connections
2249          * services. */
2250
2251         if (s->state == SOCKET_RUNNING) {
2252                 log_debug_unit(UNIT(s)->id,
2253                                "%s got notified about service death (failed permanently: %s)",
2254                                UNIT(s)->id, yes_no(failed_permanent));
2255                 if (failed_permanent)
2256                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2257                 else
2258                         socket_enter_listening(s);
2259         }
2260 }
2261
2262 void socket_connection_unref(Socket *s) {
2263         assert(s);
2264
2265         /* The service is dead. Yay!
2266          *
2267          * This is strictly for one-instance-per-connection
2268          * services. */
2269
2270         assert(s->n_connections > 0);
2271         s->n_connections--;
2272
2273         log_debug_unit(UNIT(s)->id,
2274                        "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2275 }
2276
2277 static void socket_reset_failed(Unit *u) {
2278         Socket *s = SOCKET(u);
2279
2280         assert(s);
2281
2282         if (s->state == SOCKET_FAILED)
2283                 socket_set_state(s, SOCKET_DEAD);
2284
2285         s->result = SOCKET_SUCCESS;
2286 }
2287
2288 static void socket_trigger_notify(Unit *u, Unit *other) {
2289         Socket *s = SOCKET(u);
2290         Service *se = SERVICE(other);
2291
2292         assert(u);
2293         assert(other);
2294
2295         /* Don't propagate state changes from the service if we are
2296            already down or accepting connections */
2297         if ((s->state !=  SOCKET_RUNNING &&
2298             s->state != SOCKET_LISTENING) ||
2299             s->accept)
2300                 return;
2301
2302         if (other->load_state != UNIT_LOADED ||
2303             other->type != UNIT_SERVICE)
2304                 return;
2305
2306         if (se->state == SERVICE_FAILED)
2307                 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2308
2309         if (se->state == SERVICE_DEAD ||
2310             se->state == SERVICE_STOP ||
2311             se->state == SERVICE_STOP_SIGTERM ||
2312             se->state == SERVICE_STOP_SIGKILL ||
2313             se->state == SERVICE_STOP_POST ||
2314             se->state == SERVICE_FINAL_SIGTERM ||
2315             se->state == SERVICE_FINAL_SIGKILL ||
2316             se->state == SERVICE_AUTO_RESTART)
2317                 socket_notify_service_dead(s, false);
2318
2319         if (se->state == SERVICE_RUNNING)
2320                 socket_set_state(s, SOCKET_RUNNING);
2321 }
2322
2323 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2324         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2325 }
2326
2327 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2328         [SOCKET_DEAD] = "dead",
2329         [SOCKET_START_PRE] = "start-pre",
2330         [SOCKET_START_POST] = "start-post",
2331         [SOCKET_LISTENING] = "listening",
2332         [SOCKET_RUNNING] = "running",
2333         [SOCKET_STOP_PRE] = "stop-pre",
2334         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2335         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2336         [SOCKET_STOP_POST] = "stop-post",
2337         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2338         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2339         [SOCKET_FAILED] = "failed"
2340 };
2341
2342 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2343
2344 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2345         [SOCKET_EXEC_START_PRE] = "StartPre",
2346         [SOCKET_EXEC_START_POST] = "StartPost",
2347         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2348         [SOCKET_EXEC_STOP_POST] = "StopPost"
2349 };
2350
2351 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2352
2353 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2354         [SOCKET_SUCCESS] = "success",
2355         [SOCKET_FAILURE_RESOURCES] = "resources",
2356         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2357         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2358         [SOCKET_FAILURE_SIGNAL] = "signal",
2359         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2360         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2361 };
2362
2363 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2364
2365 const UnitVTable socket_vtable = {
2366         .object_size = sizeof(Socket),
2367
2368         .sections =
2369                 "Unit\0"
2370                 "Socket\0"
2371                 "Install\0",
2372
2373         .private_section = "Socket",
2374         .exec_context_offset = offsetof(Socket, exec_context),
2375         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2376
2377         .init = socket_init,
2378         .done = socket_done,
2379         .load = socket_load,
2380
2381         .kill = socket_kill,
2382
2383         .coldplug = socket_coldplug,
2384
2385         .dump = socket_dump,
2386
2387         .start = socket_start,
2388         .stop = socket_stop,
2389
2390         .serialize = socket_serialize,
2391         .deserialize_item = socket_deserialize_item,
2392         .distribute_fds = socket_distribute_fds,
2393
2394         .active_state = socket_active_state,
2395         .sub_state_to_string = socket_sub_state_to_string,
2396
2397         .check_gc = socket_check_gc,
2398
2399         .fd_event = socket_fd_event,
2400         .sigchld_event = socket_sigchld_event,
2401         .timer_event = socket_timer_event,
2402
2403         .trigger_notify = socket_trigger_notify,
2404
2405         .reset_failed = socket_reset_failed,
2406
2407         .bus_interface = "org.freedesktop.systemd1.Socket",
2408         .bus_message_handler = bus_socket_message_handler,
2409         .bus_invalidating_properties =  bus_socket_invalidating_properties,
2410         .bus_set_property = bus_socket_set_property,
2411         .bus_commit_properties = bus_socket_commit_properties,
2412
2413         .status_message_formats = {
2414                 /*.starting_stopping = {
2415                         [0] = "Starting socket %s...",
2416                         [1] = "Stopping socket %s...",
2417                 },*/
2418                 .finished_start_job = {
2419                         [JOB_DONE]       = "Listening on %s.",
2420                         [JOB_FAILED]     = "Failed to listen on %s.",
2421                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2422                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2423                 },
2424                 .finished_stop_job = {
2425                         [JOB_DONE]       = "Closed %s.",
2426                         [JOB_FAILED]     = "Failed stopping %s.",
2427                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2428                 },
2429         },
2430 };