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