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