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