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