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