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