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