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