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