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