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         if ((r = label_fifofile_set(path)) < 0)
 766                 goto fail;
 767
 768         /* Enforce the right access mode for the fifo */
 769         old_mask = umask(~ socket_mode);
 770
 771         /* Include the original umask in our mask */
 772         umask(~socket_mode | old_mask);
 773
 774         r = mkfifo(path, socket_mode);
 775         umask(old_mask);
 776
 777         if (r < 0 && errno != EEXIST) {
 778                 r = -errno;
 779                 goto fail;
 780         }
 781
 782         if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 783                 r = -errno;
 784                 goto fail;
 785         }
 786
 787         label_file_clear();
 788
 789         if (fstat(fd, &st) < 0) {
 790                 r = -errno;
 791                 goto fail;
 792         }
 793
 794         if (!S_ISFIFO(st.st_mode) ||
 795             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
 796             st.st_uid != getuid() ||
 797             st.st_gid != getgid()) {
 798
 799                 r = -EEXIST;
 800                 goto fail;
 801         }
 802
 803         *_fd = fd;
 804         return 0;
 805
 806 fail:
 807         label_file_clear();
 808
 809         if (fd >= 0)
 810                 close_nointr_nofail(fd);
 811
 812         return r;
 813 }
 814
 815 static int special_address_create(
 816                 const char *path,
 817                 int *_fd) {
 818
 819         int fd = -1, r = 0;
 820         struct stat st;
 821
 822         assert(path);
 823         assert(_fd);
 824
 825         if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 826                 r = -errno;
 827                 goto fail;
 828         }
 829
 830         if (fstat(fd, &st) < 0) {
 831                 r = -errno;
 832                 goto fail;
 833         }
 834
 835         /* Check whether this is a /proc, /sys or /dev file or char device */
 836         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 837                 r = -EEXIST;
 838                 goto fail;
 839         }
 840
 841         *_fd = fd;
 842         return 0;
 843
 844 fail:
 845         if (fd >= 0)
 846                 close_nointr_nofail(fd);
 847
 848         return r;
 849 }
 850
 851 static int mq_address_create(
 852                 const char *path,
 853                 mode_t mq_mode,
 854                 long maxmsg,
 855                 long msgsize,
 856                 int *_fd) {
 857
 858         int fd = -1, r = 0;
 859         struct stat st;
 860         mode_t old_mask;
 861         struct mq_attr _attr, *attr = NULL;
 862
 863         assert(path);
 864         assert(_fd);
 865
 866         if (maxmsg > 0 && msgsize > 0) {
 867                 zero(_attr);
 868                 _attr.mq_flags = O_NONBLOCK;
 869                 _attr.mq_maxmsg = maxmsg;
 870                 _attr.mq_msgsize = msgsize;
 871                 attr = &_attr;
 872         }
 873
 874         /* Enforce the right access mode for the mq */
 875         old_mask = umask(~ mq_mode);
 876
 877         /* Include the original umask in our mask */
 878         umask(~mq_mode | old_mask);
 879
 880         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
 881         umask(old_mask);
 882
 883         if (fd < 0) {
 884                 r = -errno;
 885                 goto fail;
 886         }
 887
 888         if (fstat(fd, &st) < 0) {
 889                 r = -errno;
 890                 goto fail;
 891         }
 892
 893         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
 894             st.st_uid != getuid() ||
 895             st.st_gid != getgid()) {
 896
 897                 r = -EEXIST;
 898                 goto fail;
 899         }
 900
 901         *_fd = fd;
 902         return 0;
 903
 904 fail:
 905         if (fd >= 0)
 906                 close_nointr_nofail(fd);
 907
 908         return r;
 909 }
 910
 911 static int socket_open_fds(Socket *s) {
 912         SocketPort *p;
 913         int r;
 914         char *label = NULL;
 915         bool know_label = false;
 916
 917         assert(s);
 918
 919         LIST_FOREACH(port, p, s->ports) {
 920
 921                 if (p->fd >= 0)
 922                         continue;
 923
 924                 if (p->type == SOCKET_SOCKET) {
 925
 926                         if (!know_label) {
 927
 928                                 if ((r = socket_instantiate_service(s)) < 0)
 929                                         return r;
 930
 931                                 if (UNIT_DEREF(s->service) &&
 932                                     SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
 933                                         r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
 934
 935                                         if (r < 0) {
 936                                                 if (r != -EPERM)
 937                                                         return r;
 938                                         }
 939                                 }
 940
 941                                 know_label = true;
 942                         }
 943
 944                         if ((r = socket_address_listen(
 945                                              &p->address,
 946                                              s->backlog,
 947                                              s->bind_ipv6_only,
 948                                              s->bind_to_device,
 949                                              s->free_bind,
 950                                              s->transparent,
 951                                              s->directory_mode,
 952                                              s->socket_mode,
 953                                              label,
 954                                              &p->fd)) < 0)
 955                                 goto rollback;
 956
 957                         socket_apply_socket_options(s, p->fd);
 958
 959                 } else  if (p->type == SOCKET_SPECIAL) {
 960
 961                         if ((r = special_address_create(
 962                                              p->path,
 963                                              &p->fd)) < 0)
 964                                 goto rollback;
 965
 966                 } else  if (p->type == SOCKET_FIFO) {
 967
 968                         if ((r = fifo_address_create(
 969                                              p->path,
 970                                              s->directory_mode,
 971                                              s->socket_mode,
 972                                              &p->fd)) < 0)
 973                                 goto rollback;
 974
 975                         socket_apply_fifo_options(s, p->fd);
 976                 } else if (p->type == SOCKET_MQUEUE) {
 977
 978                         if ((r = mq_address_create(
 979                                              p->path,
 980                                              s->socket_mode,
 981                                              s->mq_maxmsg,
 982                                              s->mq_msgsize,
 983                                              &p->fd)) < 0)
 984                                 goto rollback;
 985                 } else
 986                         assert_not_reached("Unknown port type");
 987         }
 988
 989         label_free(label);
 990         return 0;
 991
 992 rollback:
 993         socket_close_fds(s);
 994         label_free(label);
 995         return r;
 996 }
 997
 998 static void socket_unwatch_fds(Socket *s) {
 999         SocketPort *p;
1000
1001         assert(s);
1002
1003         LIST_FOREACH(port, p, s->ports) {
1004                 if (p->fd < 0)
1005                         continue;
1006
1007                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1008         }
1009 }
1010
1011 static int socket_watch_fds(Socket *s) {
1012         SocketPort *p;
1013         int r;
1014
1015         assert(s);
1016
1017         LIST_FOREACH(port, p, s->ports) {
1018                 if (p->fd < 0)
1019                         continue;
1020
1021                 p->fd_watch.socket_accept =
1022                         s->accept &&
1023                         p->type == SOCKET_SOCKET &&
1024                         socket_address_can_accept(&p->address);
1025
1026                 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1027                         goto fail;
1028         }
1029
1030         return 0;
1031
1032 fail:
1033         socket_unwatch_fds(s);
1034         return r;
1035 }
1036
1037 static void socket_set_state(Socket *s, SocketState state) {
1038         SocketState old_state;
1039         assert(s);
1040
1041         old_state = s->state;
1042         s->state = state;
1043
1044         if (state != SOCKET_START_PRE &&
1045             state != SOCKET_START_POST &&
1046             state != SOCKET_STOP_PRE &&
1047             state != SOCKET_STOP_PRE_SIGTERM &&
1048             state != SOCKET_STOP_PRE_SIGKILL &&
1049             state != SOCKET_STOP_POST &&
1050             state != SOCKET_FINAL_SIGTERM &&
1051             state != SOCKET_FINAL_SIGKILL) {
1052                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1053                 socket_unwatch_control_pid(s);
1054                 s->control_command = NULL;
1055                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1056         }
1057
1058         if (state != SOCKET_LISTENING)
1059                 socket_unwatch_fds(s);
1060
1061         if (state != SOCKET_START_POST &&
1062             state != SOCKET_LISTENING &&
1063             state != SOCKET_RUNNING &&
1064             state != SOCKET_STOP_PRE &&
1065             state != SOCKET_STOP_PRE_SIGTERM &&
1066             state != SOCKET_STOP_PRE_SIGKILL)
1067                 socket_close_fds(s);
1068
1069         if (state != old_state)
1070                 log_debug("%s changed %s -> %s",
1071                           UNIT(s)->id,
1072                           socket_state_to_string(old_state),
1073                           socket_state_to_string(state));
1074
1075         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1076 }
1077
1078 static int socket_coldplug(Unit *u) {
1079         Socket *s = SOCKET(u);
1080         int r;
1081
1082         assert(s);
1083         assert(s->state == SOCKET_DEAD);
1084
1085         if (s->deserialized_state != s->state) {
1086
1087                 if (s->deserialized_state == SOCKET_START_PRE ||
1088                     s->deserialized_state == SOCKET_START_POST ||
1089                     s->deserialized_state == SOCKET_STOP_PRE ||
1090                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1091                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1092                     s->deserialized_state == SOCKET_STOP_POST ||
1093                     s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1094                     s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1095
1096                         if (s->control_pid <= 0)
1097                                 return -EBADMSG;
1098
1099                         if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
1100                                 return r;
1101
1102                         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1103                                 return r;
1104                 }
1105
1106                 if (s->deserialized_state == SOCKET_START_POST ||
1107                     s->deserialized_state == SOCKET_LISTENING ||
1108                     s->deserialized_state == SOCKET_RUNNING ||
1109                     s->deserialized_state == SOCKET_STOP_PRE ||
1110                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1111                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1112                         if ((r = socket_open_fds(s)) < 0)
1113                                 return r;
1114
1115                 if (s->deserialized_state == SOCKET_LISTENING)
1116                         if ((r = socket_watch_fds(s)) < 0)
1117                                 return r;
1118
1119                 socket_set_state(s, s->deserialized_state);
1120         }
1121
1122         return 0;
1123 }
1124
1125 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1126         pid_t pid;
1127         int r;
1128         char **argv;
1129
1130         assert(s);
1131         assert(c);
1132         assert(_pid);
1133
1134         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1135                 goto fail;
1136
1137         if (!(argv = unit_full_printf_strv(UNIT(s), c->argv))) {
1138                 r = -ENOMEM;
1139                 goto fail;
1140         }
1141
1142         r = exec_spawn(c,
1143                        argv,
1144                        &s->exec_context,
1145                        NULL, 0,
1146                        UNIT(s)->manager->environment,
1147                        true,
1148                        true,
1149                        true,
1150                        UNIT(s)->manager->confirm_spawn,
1151                        UNIT(s)->cgroup_bondings,
1152                        UNIT(s)->cgroup_attributes,
1153                        NULL,
1154                        &pid);
1155
1156         strv_free(argv);
1157         if (r < 0)
1158                 goto fail;
1159
1160         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1161                 /* FIXME: we need to do something here */
1162                 goto fail;
1163
1164         *_pid = pid;
1165
1166         return 0;
1167
1168 fail:
1169         unit_unwatch_timer(UNIT(s), &s->timer_watch);
1170
1171         return r;
1172 }
1173
1174 static void socket_enter_dead(Socket *s, SocketResult f) {
1175         assert(s);
1176
1177         if (f != SOCKET_SUCCESS)
1178                 s->result = f;
1179
1180         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1181 }
1182
1183 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1184
1185 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1186         int r;
1187         assert(s);
1188
1189         if (f != SOCKET_SUCCESS)
1190                 s->result = f;
1191
1192         socket_unwatch_control_pid(s);
1193
1194         s->control_command_id = SOCKET_EXEC_STOP_POST;
1195
1196         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1197                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1198                         goto fail;
1199
1200                 socket_set_state(s, SOCKET_STOP_POST);
1201         } else
1202                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1203
1204         return;
1205
1206 fail:
1207         log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1208         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1209 }
1210
1211 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1212         int r;
1213         Set *pid_set = NULL;
1214         bool wait_for_exit = false;
1215
1216         assert(s);
1217
1218         if (f != SOCKET_SUCCESS)
1219                 s->result = f;
1220
1221         if (s->exec_context.kill_mode != KILL_NONE) {
1222                 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1223
1224                 if (s->control_pid > 0) {
1225                         if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1226
1227                                 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1228                         else
1229                                 wait_for_exit = true;
1230                 }
1231
1232                 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1233
1234                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1235                                 r = -ENOMEM;
1236                                 goto fail;
1237                         }
1238
1239                         /* Exclude the control pid from being killed via the cgroup */
1240                         if (s->control_pid > 0)
1241                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1242                                         goto fail;
1243
1244                         r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, pid_set, NULL);
1245                         if (r < 0) {
1246                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1247                                         log_warning("Failed to kill control group: %s", strerror(-r));
1248                         } else if (r > 0)
1249                                 wait_for_exit = true;
1250
1251                         set_free(pid_set);
1252                         pid_set = NULL;
1253                 }
1254         }
1255
1256         if (wait_for_exit) {
1257                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1258                         goto fail;
1259
1260                 socket_set_state(s, state);
1261         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1262                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1263         else
1264                 socket_enter_dead(s, SOCKET_SUCCESS);
1265
1266         return;
1267
1268 fail:
1269         log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1270
1271         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1272                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1273         else
1274                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1275
1276         if (pid_set)
1277                 set_free(pid_set);
1278 }
1279
1280 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1281         int r;
1282         assert(s);
1283
1284         if (f != SOCKET_SUCCESS)
1285                 s->result = f;
1286
1287         socket_unwatch_control_pid(s);
1288
1289         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1290
1291         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1292                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1293                         goto fail;
1294
1295                 socket_set_state(s, SOCKET_STOP_PRE);
1296         } else
1297                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1298
1299         return;
1300
1301 fail:
1302         log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1303         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1304 }
1305
1306 static void socket_enter_listening(Socket *s) {
1307         int r;
1308         assert(s);
1309
1310         r = socket_watch_fds(s);
1311         if (r < 0) {
1312                 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1313                 goto fail;
1314         }
1315
1316         socket_set_state(s, SOCKET_LISTENING);
1317         return;
1318
1319 fail:
1320         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1321 }
1322
1323 static void socket_enter_start_post(Socket *s) {
1324         int r;
1325         assert(s);
1326
1327         r = socket_open_fds(s);
1328         if (r < 0) {
1329                 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1330                 goto fail;
1331         }
1332
1333         socket_unwatch_control_pid(s);
1334
1335         s->control_command_id = SOCKET_EXEC_START_POST;
1336
1337         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1338                 r = socket_spawn(s, s->control_command, &s->control_pid);
1339                 if (r < 0) {
1340                         log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1341                         goto fail;
1342                 }
1343
1344                 socket_set_state(s, SOCKET_START_POST);
1345         } else
1346                 socket_enter_listening(s);
1347
1348         return;
1349
1350 fail:
1351         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1352 }
1353
1354 static void socket_enter_start_pre(Socket *s) {
1355         int r;
1356         assert(s);
1357
1358         socket_unwatch_control_pid(s);
1359
1360         s->control_command_id = SOCKET_EXEC_START_PRE;
1361
1362         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1363                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1364                         goto fail;
1365
1366                 socket_set_state(s, SOCKET_START_PRE);
1367         } else
1368                 socket_enter_start_post(s);
1369
1370         return;
1371
1372 fail:
1373         log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1374         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1375 }
1376
1377 static void socket_enter_running(Socket *s, int cfd) {
1378         int r;
1379         DBusError error;
1380
1381         assert(s);
1382         dbus_error_init(&error);
1383
1384         /* We don't take connections anymore if we are supposed to
1385          * shut down anyway */
1386         if (unit_pending_inactive(UNIT(s))) {
1387                 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1388
1389                 if (cfd >= 0)
1390                         close_nointr_nofail(cfd);
1391                 else  {
1392                         /* Flush all sockets by closing and reopening them */
1393                         socket_close_fds(s);
1394
1395                         r = socket_watch_fds(s);
1396                         if (r < 0) {
1397                                 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1398                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1399                         }
1400                 }
1401
1402                 return;
1403         }
1404
1405         if (cfd < 0) {
1406                 Iterator i;
1407                 Unit *u;
1408                 bool pending = false;
1409
1410                 /* If there's already a start pending don't bother to
1411                  * do anything */
1412                 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1413                         if (unit_pending_active(u)) {
1414                                 pending = true;
1415                                 break;
1416                         }
1417
1418                 if (!pending) {
1419                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1420                         if (r < 0)
1421                                 goto fail;
1422                 }
1423
1424                 socket_set_state(s, SOCKET_RUNNING);
1425         } else {
1426                 char *prefix, *instance = NULL, *name;
1427                 Service *service;
1428
1429                 if (s->n_connections >= s->max_connections) {
1430                         log_warning("Too many incoming connections (%u)", s->n_connections);
1431                         close_nointr_nofail(cfd);
1432                         return;
1433                 }
1434
1435                 r = socket_instantiate_service(s);
1436                 if (r < 0)
1437                         goto fail;
1438
1439                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1440                 if (r < 0) {
1441                         if (r != -ENOTCONN)
1442                                 goto fail;
1443
1444                         /* ENOTCONN is legitimate if TCP RST was received.
1445                          * This connection is over, but the socket unit lives on. */
1446                         close_nointr_nofail(cfd);
1447                         return;
1448                 }
1449
1450                 prefix = unit_name_to_prefix(UNIT(s)->id);
1451                 if (!prefix) {
1452                         free(instance);
1453                         r = -ENOMEM;
1454                         goto fail;
1455                 }
1456
1457                 name = unit_name_build(prefix, instance, ".service");
1458                 free(prefix);
1459                 free(instance);
1460
1461                 if (!name) {
1462                         r = -ENOMEM;
1463                         goto fail;
1464                 }
1465
1466                 r = unit_add_name(UNIT_DEREF(s->service), name);
1467                 if (r < 0) {
1468                         free(name);
1469                         goto fail;
1470                 }
1471
1472                 service = SERVICE(UNIT_DEREF(s->service));
1473                 unit_ref_unset(&s->service);
1474                 s->n_accepted ++;
1475
1476                 UNIT(service)->no_gc = false;
1477
1478                 unit_choose_id(UNIT(service), name);
1479                 free(name);
1480
1481                 r = service_set_socket_fd(service, cfd, s);
1482                 if (r < 0)
1483                         goto fail;
1484
1485                 cfd = -1;
1486                 s->n_connections ++;
1487
1488                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1489                 if (r < 0)
1490                         goto fail;
1491
1492                 /* Notify clients about changed counters */
1493                 unit_add_to_dbus_queue(UNIT(s));
1494         }
1495
1496         return;
1497
1498 fail:
1499         log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1500         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1501
1502         if (cfd >= 0)
1503                 close_nointr_nofail(cfd);
1504
1505         dbus_error_free(&error);
1506 }
1507
1508 static void socket_run_next(Socket *s) {
1509         int r;
1510
1511         assert(s);
1512         assert(s->control_command);
1513         assert(s->control_command->command_next);
1514
1515         socket_unwatch_control_pid(s);
1516
1517         s->control_command = s->control_command->command_next;
1518
1519         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1520                 goto fail;
1521
1522         return;
1523
1524 fail:
1525         log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1526
1527         if (s->state == SOCKET_START_POST)
1528                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1529         else if (s->state == SOCKET_STOP_POST)
1530                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1531         else
1532                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1533 }
1534
1535 static int socket_start(Unit *u) {
1536         Socket *s = SOCKET(u);
1537
1538         assert(s);
1539
1540         /* We cannot fulfill this request right now, try again later
1541          * please! */
1542         if (s->state == SOCKET_STOP_PRE ||
1543             s->state == SOCKET_STOP_PRE_SIGKILL ||
1544             s->state == SOCKET_STOP_PRE_SIGTERM ||
1545             s->state == SOCKET_STOP_POST ||
1546             s->state == SOCKET_FINAL_SIGTERM ||
1547             s->state == SOCKET_FINAL_SIGKILL)
1548                 return -EAGAIN;
1549
1550         if (s->state == SOCKET_START_PRE ||
1551             s->state == SOCKET_START_POST)
1552                 return 0;
1553
1554         /* Cannot run this without the service being around */
1555         if (UNIT_DEREF(s->service)) {
1556                 Service *service;
1557
1558                 service = SERVICE(UNIT_DEREF(s->service));
1559
1560                 if (UNIT(service)->load_state != UNIT_LOADED) {
1561                         log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1562                         return -ENOENT;
1563                 }
1564
1565                 /* If the service is already active we cannot start the
1566                  * socket */
1567                 if (service->state != SERVICE_DEAD &&
1568                     service->state != SERVICE_FAILED &&
1569                     service->state != SERVICE_AUTO_RESTART) {
1570                         log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1571                         return -EBUSY;
1572                 }
1573
1574 #ifdef HAVE_SYSV_COMPAT
1575                 if (service->sysv_path) {
1576                         log_error("Using SysV services for socket activation is not supported. Refusing.");
1577                         return -ENOENT;
1578                 }
1579 #endif
1580         }
1581
1582         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1583
1584         s->result = SOCKET_SUCCESS;
1585         socket_enter_start_pre(s);
1586         return 0;
1587 }
1588
1589 static int socket_stop(Unit *u) {
1590         Socket *s = SOCKET(u);
1591
1592         assert(s);
1593
1594         /* Already on it */
1595         if (s->state == SOCKET_STOP_PRE ||
1596             s->state == SOCKET_STOP_PRE_SIGTERM ||
1597             s->state == SOCKET_STOP_PRE_SIGKILL ||
1598             s->state == SOCKET_STOP_POST ||
1599             s->state == SOCKET_FINAL_SIGTERM ||
1600             s->state == SOCKET_FINAL_SIGKILL)
1601                 return 0;
1602
1603         /* If there's already something running we go directly into
1604          * kill mode. */
1605         if (s->state == SOCKET_START_PRE ||
1606             s->state == SOCKET_START_POST) {
1607                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1608                 return -EAGAIN;
1609         }
1610
1611         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1612
1613         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1614         return 0;
1615 }
1616
1617 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1618         Socket *s = SOCKET(u);
1619         SocketPort *p;
1620         int r;
1621
1622         assert(u);
1623         assert(f);
1624         assert(fds);
1625
1626         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1627         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1628         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1629
1630         if (s->control_pid > 0)
1631                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1632
1633         if (s->control_command_id >= 0)
1634                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1635
1636         LIST_FOREACH(port, p, s->ports) {
1637                 int copy;
1638
1639                 if (p->fd < 0)
1640                         continue;
1641
1642                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1643                         return copy;
1644
1645                 if (p->type == SOCKET_SOCKET) {
1646                         char *t;
1647
1648                         if ((r = socket_address_print(&p->address, &t)) < 0)
1649                                 return r;
1650
1651                         if (socket_address_family(&p->address) == AF_NETLINK)
1652                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1653                         else
1654                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1655                         free(t);
1656                 } else if (p->type == SOCKET_SPECIAL)
1657                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1658                 else {
1659                         assert(p->type == SOCKET_FIFO);
1660                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1661                 }
1662         }
1663
1664         return 0;
1665 }
1666
1667 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1668         Socket *s = SOCKET(u);
1669
1670         assert(u);
1671         assert(key);
1672         assert(value);
1673         assert(fds);
1674
1675         if (streq(key, "state")) {
1676                 SocketState state;
1677
1678                 if ((state = socket_state_from_string(value)) < 0)
1679                         log_debug("Failed to parse state value %s", value);
1680                 else
1681                         s->deserialized_state = state;
1682         } else if (streq(key, "result")) {
1683                 SocketResult f;
1684
1685                 f = socket_result_from_string(value);
1686                 if (f < 0)
1687                         log_debug("Failed to parse result value %s", value);
1688                 else if (f != SOCKET_SUCCESS)
1689                         s->result = f;
1690
1691         } else if (streq(key, "n-accepted")) {
1692                 unsigned k;
1693
1694                 if (safe_atou(value, &k) < 0)
1695                         log_debug("Failed to parse n-accepted value %s", value);
1696                 else
1697                         s->n_accepted += k;
1698         } else if (streq(key, "control-pid")) {
1699                 pid_t pid;
1700
1701                 if (parse_pid(value, &pid) < 0)
1702                         log_debug("Failed to parse control-pid value %s", value);
1703                 else
1704                         s->control_pid = pid;
1705         } else if (streq(key, "control-command")) {
1706                 SocketExecCommand id;
1707
1708                 if ((id = socket_exec_command_from_string(value)) < 0)
1709                         log_debug("Failed to parse exec-command value %s", value);
1710                 else {
1711                         s->control_command_id = id;
1712                         s->control_command = s->exec_command[id];
1713                 }
1714         } else if (streq(key, "fifo")) {
1715                 int fd, skip = 0;
1716                 SocketPort *p;
1717
1718                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1719                         log_debug("Failed to parse fifo value %s", value);
1720                 else {
1721
1722                         LIST_FOREACH(port, p, s->ports)
1723                                 if (p->type == SOCKET_FIFO &&
1724                                     streq_ptr(p->path, value+skip))
1725                                         break;
1726
1727                         if (p) {
1728                                 if (p->fd >= 0)
1729                                         close_nointr_nofail(p->fd);
1730                                 p->fd = fdset_remove(fds, fd);
1731                         }
1732                 }
1733
1734         } else if (streq(key, "special")) {
1735                 int fd, skip = 0;
1736                 SocketPort *p;
1737
1738                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1739                         log_debug("Failed to parse special value %s", value);
1740                 else {
1741
1742                         LIST_FOREACH(port, p, s->ports)
1743                                 if (p->type == SOCKET_SPECIAL &&
1744                                     streq_ptr(p->path, value+skip))
1745                                         break;
1746
1747                         if (p) {
1748                                 if (p->fd >= 0)
1749                                         close_nointr_nofail(p->fd);
1750                                 p->fd = fdset_remove(fds, fd);
1751                         }
1752                 }
1753
1754         } else if (streq(key, "socket")) {
1755                 int fd, type, skip = 0;
1756                 SocketPort *p;
1757
1758                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1759                         log_debug("Failed to parse socket value %s", value);
1760                 else {
1761
1762                         LIST_FOREACH(port, p, s->ports)
1763                                 if (socket_address_is(&p->address, value+skip, type))
1764                                         break;
1765
1766                         if (p) {
1767                                 if (p->fd >= 0)
1768                                         close_nointr_nofail(p->fd);
1769                                 p->fd = fdset_remove(fds, fd);
1770                         }
1771                 }
1772
1773         } else if (streq(key, "netlink")) {
1774                 int fd, skip = 0;
1775                 SocketPort *p;
1776
1777                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1778                         log_debug("Failed to parse socket value %s", value);
1779                 else {
1780
1781                         LIST_FOREACH(port, p, s->ports)
1782                                 if (socket_address_is_netlink(&p->address, value+skip))
1783                                         break;
1784
1785                         if (p) {
1786                                 if (p->fd >= 0)
1787                                         close_nointr_nofail(p->fd);
1788                                 p->fd = fdset_remove(fds, fd);
1789                         }
1790                 }
1791
1792         } else
1793                 log_debug("Unknown serialization key '%s'", key);
1794
1795         return 0;
1796 }
1797
1798 static UnitActiveState socket_active_state(Unit *u) {
1799         assert(u);
1800
1801         return state_translation_table[SOCKET(u)->state];
1802 }
1803
1804 static const char *socket_sub_state_to_string(Unit *u) {
1805         assert(u);
1806
1807         return socket_state_to_string(SOCKET(u)->state);
1808 }
1809
1810 static bool socket_check_gc(Unit *u) {
1811         Socket *s = SOCKET(u);
1812
1813         assert(u);
1814
1815         return s->n_connections > 0;
1816 }
1817
1818 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1819         Socket *s = SOCKET(u);
1820         int cfd = -1;
1821
1822         assert(s);
1823         assert(fd >= 0);
1824
1825         if (s->state != SOCKET_LISTENING)
1826                 return;
1827
1828         log_debug("Incoming traffic on %s", u->id);
1829
1830         if (events != EPOLLIN) {
1831
1832                 if (events & EPOLLHUP)
1833                         log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1834                 else
1835                         log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1836
1837                 goto fail;
1838         }
1839
1840         if (w->socket_accept) {
1841                 for (;;) {
1842
1843                         if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1844
1845                                 if (errno == EINTR)
1846                                         continue;
1847
1848                                 log_error("Failed to accept socket: %m");
1849                                 goto fail;
1850                         }
1851
1852                         break;
1853                 }
1854
1855                 socket_apply_socket_options(s, cfd);
1856         }
1857
1858         socket_enter_running(s, cfd);
1859         return;
1860
1861 fail:
1862         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1863 }
1864
1865 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1866         Socket *s = SOCKET(u);
1867         SocketResult f;
1868
1869         assert(s);
1870         assert(pid >= 0);
1871
1872         if (pid != s->control_pid)
1873                 return;
1874
1875         s->control_pid = 0;
1876
1877         if (is_clean_exit(code, status))
1878                 f = SOCKET_SUCCESS;
1879         else if (code == CLD_EXITED)
1880                 f = SOCKET_FAILURE_EXIT_CODE;
1881         else if (code == CLD_KILLED)
1882                 f = SOCKET_FAILURE_SIGNAL;
1883         else if (code == CLD_DUMPED)
1884                 f = SOCKET_FAILURE_CORE_DUMP;
1885         else
1886                 assert_not_reached("Unknown code");
1887
1888         if (s->control_command) {
1889                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1890
1891                 if (s->control_command->ignore)
1892                         f = SOCKET_SUCCESS;
1893         }
1894
1895         log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1896                  "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1897
1898         if (f != SOCKET_SUCCESS)
1899                 s->result = f;
1900
1901         if (s->control_command &&
1902             s->control_command->command_next &&
1903             f == SOCKET_SUCCESS) {
1904
1905                 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1906                 socket_run_next(s);
1907         } else {
1908                 s->control_command = NULL;
1909                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1910
1911                 /* No further commands for this step, so let's figure
1912                  * out what to do next */
1913
1914                 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1915
1916                 switch (s->state) {
1917
1918                 case SOCKET_START_PRE:
1919                         if (f == SOCKET_SUCCESS)
1920                                 socket_enter_start_post(s);
1921                         else
1922                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1923                         break;
1924
1925                 case SOCKET_START_POST:
1926                         if (f == SOCKET_SUCCESS)
1927                                 socket_enter_listening(s);
1928                         else
1929                                 socket_enter_stop_pre(s, f);
1930                         break;
1931
1932                 case SOCKET_STOP_PRE:
1933                 case SOCKET_STOP_PRE_SIGTERM:
1934                 case SOCKET_STOP_PRE_SIGKILL:
1935                         socket_enter_stop_post(s, f);
1936                         break;
1937
1938                 case SOCKET_STOP_POST:
1939                 case SOCKET_FINAL_SIGTERM:
1940                 case SOCKET_FINAL_SIGKILL:
1941                         socket_enter_dead(s, f);
1942                         break;
1943
1944                 default:
1945                         assert_not_reached("Uh, control process died at wrong time.");
1946                 }
1947         }
1948
1949         /* Notify clients about changed exit status */
1950         unit_add_to_dbus_queue(u);
1951 }
1952
1953 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1954         Socket *s = SOCKET(u);
1955
1956         assert(s);
1957         assert(elapsed == 1);
1958         assert(w == &s->timer_watch);
1959
1960         switch (s->state) {
1961
1962         case SOCKET_START_PRE:
1963                 log_warning("%s starting timed out. Terminating.", u->id);
1964                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1965                 break;
1966
1967         case SOCKET_START_POST:
1968                 log_warning("%s starting timed out. Stopping.", u->id);
1969                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1970                 break;
1971
1972         case SOCKET_STOP_PRE:
1973                 log_warning("%s stopping timed out. Terminating.", u->id);
1974                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1975                 break;
1976
1977         case SOCKET_STOP_PRE_SIGTERM:
1978                 if (s->exec_context.send_sigkill) {
1979                         log_warning("%s stopping timed out. Killing.", u->id);
1980                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1981                 } else {
1982                         log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1983                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1984                 }
1985                 break;
1986
1987         case SOCKET_STOP_PRE_SIGKILL:
1988                 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
1989                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1990                 break;
1991
1992         case SOCKET_STOP_POST:
1993                 log_warning("%s stopping timed out (2). Terminating.", u->id);
1994                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1995                 break;
1996
1997         case SOCKET_FINAL_SIGTERM:
1998                 if (s->exec_context.send_sigkill) {
1999                         log_warning("%s stopping timed out (2). Killing.", u->id);
2000                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2001                 } else {
2002                         log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2003                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2004                 }
2005                 break;
2006
2007         case SOCKET_FINAL_SIGKILL:
2008                 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2009                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2010                 break;
2011
2012         default:
2013                 assert_not_reached("Timeout at wrong time.");
2014         }
2015 }
2016
2017 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2018         int *rfds;
2019         unsigned rn_fds, k;
2020         SocketPort *p;
2021
2022         assert(s);
2023         assert(fds);
2024         assert(n_fds);
2025
2026         /* Called from the service code for requesting our fds */
2027
2028         rn_fds = 0;
2029         LIST_FOREACH(port, p, s->ports)
2030                 if (p->fd >= 0)
2031                         rn_fds++;
2032
2033         if (rn_fds <= 0) {
2034                 *fds = NULL;
2035                 *n_fds = 0;
2036                 return 0;
2037         }
2038
2039         if (!(rfds = new(int, rn_fds)))
2040                 return -ENOMEM;
2041
2042         k = 0;
2043         LIST_FOREACH(port, p, s->ports)
2044                 if (p->fd >= 0)
2045                         rfds[k++] = p->fd;
2046
2047         assert(k == rn_fds);
2048
2049         *fds = rfds;
2050         *n_fds = rn_fds;
2051
2052         return 0;
2053 }
2054
2055 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2056         assert(s);
2057
2058         /* The service is dead. Dang!
2059          *
2060          * This is strictly for one-instance-for-all-connections
2061          * services. */
2062
2063         if (s->state == SOCKET_RUNNING) {
2064                 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2065                 if (failed_permanent)
2066                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2067                 else
2068                         socket_enter_listening(s);
2069         }
2070 }
2071
2072 void socket_connection_unref(Socket *s) {
2073         assert(s);
2074
2075         /* The service is dead. Yay!
2076          *
2077          * This is strictly for one-instance-per-connection
2078          * services. */
2079
2080         assert(s->n_connections > 0);
2081         s->n_connections--;
2082
2083         log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2084 }
2085
2086 static void socket_reset_failed(Unit *u) {
2087         Socket *s = SOCKET(u);
2088
2089         assert(s);
2090
2091         if (s->state == SOCKET_FAILED)
2092                 socket_set_state(s, SOCKET_DEAD);
2093
2094         s->result = SOCKET_SUCCESS;
2095 }
2096
2097 static int socket_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
2098         Socket *s = SOCKET(u);
2099         int r = 0;
2100         Set *pid_set = NULL;
2101
2102         assert(s);
2103
2104         if (who == KILL_MAIN) {
2105                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2106                 return -ESRCH;
2107         }
2108
2109         if (s->control_pid <= 0 && who == KILL_CONTROL) {
2110                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2111                 return -ESRCH;
2112         }
2113
2114         if (who == KILL_CONTROL || who == KILL_ALL)
2115                 if (s->control_pid > 0)
2116                         if (kill(s->control_pid, signo) < 0)
2117                                 r = -errno;
2118
2119         if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
2120                 int q;
2121
2122                 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
2123                         return -ENOMEM;
2124
2125                 /* Exclude the control pid from being killed via the cgroup */
2126                 if (s->control_pid > 0)
2127                         if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
2128                                 r = q;
2129                                 goto finish;
2130                         }
2131
2132                 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, pid_set, NULL);
2133                 if (q < 0)
2134                         if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2135                                 r = q;
2136         }
2137
2138 finish:
2139         if (pid_set)
2140                 set_free(pid_set);
2141
2142         return r;
2143 }
2144
2145 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2146         [SOCKET_DEAD] = "dead",
2147         [SOCKET_START_PRE] = "start-pre",
2148         [SOCKET_START_POST] = "start-post",
2149         [SOCKET_LISTENING] = "listening",
2150         [SOCKET_RUNNING] = "running",
2151         [SOCKET_STOP_PRE] = "stop-pre",
2152         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2153         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2154         [SOCKET_STOP_POST] = "stop-post",
2155         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2156         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2157         [SOCKET_FAILED] = "failed"
2158 };
2159
2160 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2161
2162 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2163         [SOCKET_EXEC_START_PRE] = "StartPre",
2164         [SOCKET_EXEC_START_POST] = "StartPost",
2165         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2166         [SOCKET_EXEC_STOP_POST] = "StopPost"
2167 };
2168
2169 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2170
2171 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2172         [SOCKET_SUCCESS] = "success",
2173         [SOCKET_FAILURE_RESOURCES] = "resources",
2174         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2175         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2176         [SOCKET_FAILURE_SIGNAL] = "signal",
2177         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2178         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2179 };
2180
2181 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2182
2183 const UnitVTable socket_vtable = {
2184         .suffix = ".socket",
2185         .object_size = sizeof(Socket),
2186         .sections =
2187                 "Unit\0"
2188                 "Socket\0"
2189                 "Install\0",
2190
2191         .init = socket_init,
2192         .done = socket_done,
2193         .load = socket_load,
2194
2195         .kill = socket_kill,
2196
2197         .coldplug = socket_coldplug,
2198
2199         .dump = socket_dump,
2200
2201         .start = socket_start,
2202         .stop = socket_stop,
2203
2204         .serialize = socket_serialize,
2205         .deserialize_item = socket_deserialize_item,
2206
2207         .active_state = socket_active_state,
2208         .sub_state_to_string = socket_sub_state_to_string,
2209
2210         .check_gc = socket_check_gc,
2211
2212         .fd_event = socket_fd_event,
2213         .sigchld_event = socket_sigchld_event,
2214         .timer_event = socket_timer_event,
2215
2216         .reset_failed = socket_reset_failed,
2217
2218         .bus_interface = "org.freedesktop.systemd1.Socket",
2219         .bus_message_handler = bus_socket_message_handler,
2220         .bus_invalidating_properties =  bus_socket_invalidating_properties
2221 };