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                        NULL,
1156                        &pid);
1157
1158         strv_free(argv);
1159         if (r < 0)
1160                 goto fail;
1161
1162         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1163                 /* FIXME: we need to do something here */
1164                 goto fail;
1165
1166         *_pid = pid;
1167
1168         return 0;
1169
1170 fail:
1171         unit_unwatch_timer(UNIT(s), &s->timer_watch);
1172
1173         return r;
1174 }
1175
1176 static void socket_enter_dead(Socket *s, SocketResult f) {
1177         assert(s);
1178
1179         if (f != SOCKET_SUCCESS)
1180                 s->result = f;
1181
1182         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1183 }
1184
1185 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1186
1187 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1188         int r;
1189         assert(s);
1190
1191         if (f != SOCKET_SUCCESS)
1192                 s->result = f;
1193
1194         socket_unwatch_control_pid(s);
1195
1196         s->control_command_id = SOCKET_EXEC_STOP_POST;
1197
1198         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1199                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1200                         goto fail;
1201
1202                 socket_set_state(s, SOCKET_STOP_POST);
1203         } else
1204                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1205
1206         return;
1207
1208 fail:
1209         log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
1210         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1211 }
1212
1213 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1214         int r;
1215         Set *pid_set = NULL;
1216         bool wait_for_exit = false;
1217
1218         assert(s);
1219
1220         if (f != SOCKET_SUCCESS)
1221                 s->result = f;
1222
1223         if (s->exec_context.kill_mode != KILL_NONE) {
1224                 int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1225
1226                 if (s->control_pid > 0) {
1227                         if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
1228
1229                                 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
1230                         else
1231                                 wait_for_exit = true;
1232                 }
1233
1234                 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
1235
1236                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
1237                                 r = -ENOMEM;
1238                                 goto fail;
1239                         }
1240
1241                         /* Exclude the control pid from being killed via the cgroup */
1242                         if (s->control_pid > 0)
1243                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1244                                         goto fail;
1245
1246                         r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
1247                         if (r < 0) {
1248                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1249                                         log_warning("Failed to kill control group: %s", strerror(-r));
1250                         } else if (r > 0)
1251                                 wait_for_exit = true;
1252
1253                         set_free(pid_set);
1254                         pid_set = NULL;
1255                 }
1256         }
1257
1258         if (wait_for_exit) {
1259                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
1260                         goto fail;
1261
1262                 socket_set_state(s, state);
1263         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1264                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1265         else
1266                 socket_enter_dead(s, SOCKET_SUCCESS);
1267
1268         return;
1269
1270 fail:
1271         log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1272
1273         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1274                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1275         else
1276                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1277
1278         if (pid_set)
1279                 set_free(pid_set);
1280 }
1281
1282 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1283         int r;
1284         assert(s);
1285
1286         if (f != SOCKET_SUCCESS)
1287                 s->result = f;
1288
1289         socket_unwatch_control_pid(s);
1290
1291         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1292
1293         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1294                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1295                         goto fail;
1296
1297                 socket_set_state(s, SOCKET_STOP_PRE);
1298         } else
1299                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1300
1301         return;
1302
1303 fail:
1304         log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1305         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1306 }
1307
1308 static void socket_enter_listening(Socket *s) {
1309         int r;
1310         assert(s);
1311
1312         r = socket_watch_fds(s);
1313         if (r < 0) {
1314                 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1315                 goto fail;
1316         }
1317
1318         socket_set_state(s, SOCKET_LISTENING);
1319         return;
1320
1321 fail:
1322         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1323 }
1324
1325 static void socket_enter_start_post(Socket *s) {
1326         int r;
1327         assert(s);
1328
1329         r = socket_open_fds(s);
1330         if (r < 0) {
1331                 log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1332                 goto fail;
1333         }
1334
1335         socket_unwatch_control_pid(s);
1336
1337         s->control_command_id = SOCKET_EXEC_START_POST;
1338
1339         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1340                 r = socket_spawn(s, s->control_command, &s->control_pid);
1341                 if (r < 0) {
1342                         log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1343                         goto fail;
1344                 }
1345
1346                 socket_set_state(s, SOCKET_START_POST);
1347         } else
1348                 socket_enter_listening(s);
1349
1350         return;
1351
1352 fail:
1353         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1354 }
1355
1356 static void socket_enter_start_pre(Socket *s) {
1357         int r;
1358         assert(s);
1359
1360         socket_unwatch_control_pid(s);
1361
1362         s->control_command_id = SOCKET_EXEC_START_PRE;
1363
1364         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1365                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1366                         goto fail;
1367
1368                 socket_set_state(s, SOCKET_START_PRE);
1369         } else
1370                 socket_enter_start_post(s);
1371
1372         return;
1373
1374 fail:
1375         log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1376         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1377 }
1378
1379 static void socket_enter_running(Socket *s, int cfd) {
1380         int r;
1381         DBusError error;
1382
1383         assert(s);
1384         dbus_error_init(&error);
1385
1386         /* We don't take connections anymore if we are supposed to
1387          * shut down anyway */
1388         if (unit_pending_inactive(UNIT(s))) {
1389                 log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1390
1391                 if (cfd >= 0)
1392                         close_nointr_nofail(cfd);
1393                 else  {
1394                         /* Flush all sockets by closing and reopening them */
1395                         socket_close_fds(s);
1396
1397                         r = socket_watch_fds(s);
1398                         if (r < 0) {
1399                                 log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1400                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1401                         }
1402                 }
1403
1404                 return;
1405         }
1406
1407         if (cfd < 0) {
1408                 Iterator i;
1409                 Unit *u;
1410                 bool pending = false;
1411
1412                 /* If there's already a start pending don't bother to
1413                  * do anything */
1414                 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1415                         if (unit_pending_active(u)) {
1416                                 pending = true;
1417                                 break;
1418                         }
1419
1420                 if (!pending) {
1421                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1422                         if (r < 0)
1423                                 goto fail;
1424                 }
1425
1426                 socket_set_state(s, SOCKET_RUNNING);
1427         } else {
1428                 char *prefix, *instance = NULL, *name;
1429                 Service *service;
1430
1431                 if (s->n_connections >= s->max_connections) {
1432                         log_warning("Too many incoming connections (%u)", s->n_connections);
1433                         close_nointr_nofail(cfd);
1434                         return;
1435                 }
1436
1437                 r = socket_instantiate_service(s);
1438                 if (r < 0)
1439                         goto fail;
1440
1441                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1442                 if (r < 0) {
1443                         if (r != -ENOTCONN)
1444                                 goto fail;
1445
1446                         /* ENOTCONN is legitimate if TCP RST was received.
1447                          * This connection is over, but the socket unit lives on. */
1448                         close_nointr_nofail(cfd);
1449                         return;
1450                 }
1451
1452                 prefix = unit_name_to_prefix(UNIT(s)->id);
1453                 if (!prefix) {
1454                         free(instance);
1455                         r = -ENOMEM;
1456                         goto fail;
1457                 }
1458
1459                 name = unit_name_build(prefix, instance, ".service");
1460                 free(prefix);
1461                 free(instance);
1462
1463                 if (!name) {
1464                         r = -ENOMEM;
1465                         goto fail;
1466                 }
1467
1468                 r = unit_add_name(UNIT_DEREF(s->service), name);
1469                 if (r < 0) {
1470                         free(name);
1471                         goto fail;
1472                 }
1473
1474                 service = SERVICE(UNIT_DEREF(s->service));
1475                 unit_ref_unset(&s->service);
1476                 s->n_accepted ++;
1477
1478                 UNIT(service)->no_gc = false;
1479
1480                 unit_choose_id(UNIT(service), name);
1481                 free(name);
1482
1483                 r = service_set_socket_fd(service, cfd, s);
1484                 if (r < 0)
1485                         goto fail;
1486
1487                 cfd = -1;
1488                 s->n_connections ++;
1489
1490                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1491                 if (r < 0)
1492                         goto fail;
1493
1494                 /* Notify clients about changed counters */
1495                 unit_add_to_dbus_queue(UNIT(s));
1496         }
1497
1498         return;
1499
1500 fail:
1501         log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1502         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1503
1504         if (cfd >= 0)
1505                 close_nointr_nofail(cfd);
1506
1507         dbus_error_free(&error);
1508 }
1509
1510 static void socket_run_next(Socket *s) {
1511         int r;
1512
1513         assert(s);
1514         assert(s->control_command);
1515         assert(s->control_command->command_next);
1516
1517         socket_unwatch_control_pid(s);
1518
1519         s->control_command = s->control_command->command_next;
1520
1521         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1522                 goto fail;
1523
1524         return;
1525
1526 fail:
1527         log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1528
1529         if (s->state == SOCKET_START_POST)
1530                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1531         else if (s->state == SOCKET_STOP_POST)
1532                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1533         else
1534                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1535 }
1536
1537 static int socket_start(Unit *u) {
1538         Socket *s = SOCKET(u);
1539
1540         assert(s);
1541
1542         /* We cannot fulfill this request right now, try again later
1543          * please! */
1544         if (s->state == SOCKET_STOP_PRE ||
1545             s->state == SOCKET_STOP_PRE_SIGKILL ||
1546             s->state == SOCKET_STOP_PRE_SIGTERM ||
1547             s->state == SOCKET_STOP_POST ||
1548             s->state == SOCKET_FINAL_SIGTERM ||
1549             s->state == SOCKET_FINAL_SIGKILL)
1550                 return -EAGAIN;
1551
1552         if (s->state == SOCKET_START_PRE ||
1553             s->state == SOCKET_START_POST)
1554                 return 0;
1555
1556         /* Cannot run this without the service being around */
1557         if (UNIT_DEREF(s->service)) {
1558                 Service *service;
1559
1560                 service = SERVICE(UNIT_DEREF(s->service));
1561
1562                 if (UNIT(service)->load_state != UNIT_LOADED) {
1563                         log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1564                         return -ENOENT;
1565                 }
1566
1567                 /* If the service is already active we cannot start the
1568                  * socket */
1569                 if (service->state != SERVICE_DEAD &&
1570                     service->state != SERVICE_FAILED &&
1571                     service->state != SERVICE_AUTO_RESTART) {
1572                         log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1573                         return -EBUSY;
1574                 }
1575
1576 #ifdef HAVE_SYSV_COMPAT
1577                 if (service->sysv_path) {
1578                         log_error("Using SysV services for socket activation is not supported. Refusing.");
1579                         return -ENOENT;
1580                 }
1581 #endif
1582         }
1583
1584         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1585
1586         s->result = SOCKET_SUCCESS;
1587         socket_enter_start_pre(s);
1588         return 0;
1589 }
1590
1591 static int socket_stop(Unit *u) {
1592         Socket *s = SOCKET(u);
1593
1594         assert(s);
1595
1596         /* Already on it */
1597         if (s->state == SOCKET_STOP_PRE ||
1598             s->state == SOCKET_STOP_PRE_SIGTERM ||
1599             s->state == SOCKET_STOP_PRE_SIGKILL ||
1600             s->state == SOCKET_STOP_POST ||
1601             s->state == SOCKET_FINAL_SIGTERM ||
1602             s->state == SOCKET_FINAL_SIGKILL)
1603                 return 0;
1604
1605         /* If there's already something running we go directly into
1606          * kill mode. */
1607         if (s->state == SOCKET_START_PRE ||
1608             s->state == SOCKET_START_POST) {
1609                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1610                 return -EAGAIN;
1611         }
1612
1613         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1614
1615         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1616         return 0;
1617 }
1618
1619 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1620         Socket *s = SOCKET(u);
1621         SocketPort *p;
1622         int r;
1623
1624         assert(u);
1625         assert(f);
1626         assert(fds);
1627
1628         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1629         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1630         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1631
1632         if (s->control_pid > 0)
1633                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1634
1635         if (s->control_command_id >= 0)
1636                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1637
1638         LIST_FOREACH(port, p, s->ports) {
1639                 int copy;
1640
1641                 if (p->fd < 0)
1642                         continue;
1643
1644                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1645                         return copy;
1646
1647                 if (p->type == SOCKET_SOCKET) {
1648                         char *t;
1649
1650                         if ((r = socket_address_print(&p->address, &t)) < 0)
1651                                 return r;
1652
1653                         if (socket_address_family(&p->address) == AF_NETLINK)
1654                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1655                         else
1656                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1657                         free(t);
1658                 } else if (p->type == SOCKET_SPECIAL)
1659                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1660                 else {
1661                         assert(p->type == SOCKET_FIFO);
1662                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1663                 }
1664         }
1665
1666         return 0;
1667 }
1668
1669 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1670         Socket *s = SOCKET(u);
1671
1672         assert(u);
1673         assert(key);
1674         assert(value);
1675         assert(fds);
1676
1677         if (streq(key, "state")) {
1678                 SocketState state;
1679
1680                 if ((state = socket_state_from_string(value)) < 0)
1681                         log_debug("Failed to parse state value %s", value);
1682                 else
1683                         s->deserialized_state = state;
1684         } else if (streq(key, "result")) {
1685                 SocketResult f;
1686
1687                 f = socket_result_from_string(value);
1688                 if (f < 0)
1689                         log_debug("Failed to parse result value %s", value);
1690                 else if (f != SOCKET_SUCCESS)
1691                         s->result = f;
1692
1693         } else if (streq(key, "n-accepted")) {
1694                 unsigned k;
1695
1696                 if (safe_atou(value, &k) < 0)
1697                         log_debug("Failed to parse n-accepted value %s", value);
1698                 else
1699                         s->n_accepted += k;
1700         } else if (streq(key, "control-pid")) {
1701                 pid_t pid;
1702
1703                 if (parse_pid(value, &pid) < 0)
1704                         log_debug("Failed to parse control-pid value %s", value);
1705                 else
1706                         s->control_pid = pid;
1707         } else if (streq(key, "control-command")) {
1708                 SocketExecCommand id;
1709
1710                 if ((id = socket_exec_command_from_string(value)) < 0)
1711                         log_debug("Failed to parse exec-command value %s", value);
1712                 else {
1713                         s->control_command_id = id;
1714                         s->control_command = s->exec_command[id];
1715                 }
1716         } else if (streq(key, "fifo")) {
1717                 int fd, skip = 0;
1718                 SocketPort *p;
1719
1720                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1721                         log_debug("Failed to parse fifo value %s", value);
1722                 else {
1723
1724                         LIST_FOREACH(port, p, s->ports)
1725                                 if (p->type == SOCKET_FIFO &&
1726                                     streq_ptr(p->path, value+skip))
1727                                         break;
1728
1729                         if (p) {
1730                                 if (p->fd >= 0)
1731                                         close_nointr_nofail(p->fd);
1732                                 p->fd = fdset_remove(fds, fd);
1733                         }
1734                 }
1735
1736         } else if (streq(key, "special")) {
1737                 int fd, skip = 0;
1738                 SocketPort *p;
1739
1740                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1741                         log_debug("Failed to parse special value %s", value);
1742                 else {
1743
1744                         LIST_FOREACH(port, p, s->ports)
1745                                 if (p->type == SOCKET_SPECIAL &&
1746                                     streq_ptr(p->path, value+skip))
1747                                         break;
1748
1749                         if (p) {
1750                                 if (p->fd >= 0)
1751                                         close_nointr_nofail(p->fd);
1752                                 p->fd = fdset_remove(fds, fd);
1753                         }
1754                 }
1755
1756         } else if (streq(key, "socket")) {
1757                 int fd, type, skip = 0;
1758                 SocketPort *p;
1759
1760                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1761                         log_debug("Failed to parse socket value %s", value);
1762                 else {
1763
1764                         LIST_FOREACH(port, p, s->ports)
1765                                 if (socket_address_is(&p->address, value+skip, type))
1766                                         break;
1767
1768                         if (p) {
1769                                 if (p->fd >= 0)
1770                                         close_nointr_nofail(p->fd);
1771                                 p->fd = fdset_remove(fds, fd);
1772                         }
1773                 }
1774
1775         } else if (streq(key, "netlink")) {
1776                 int fd, skip = 0;
1777                 SocketPort *p;
1778
1779                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1780                         log_debug("Failed to parse socket value %s", value);
1781                 else {
1782
1783                         LIST_FOREACH(port, p, s->ports)
1784                                 if (socket_address_is_netlink(&p->address, value+skip))
1785                                         break;
1786
1787                         if (p) {
1788                                 if (p->fd >= 0)
1789                                         close_nointr_nofail(p->fd);
1790                                 p->fd = fdset_remove(fds, fd);
1791                         }
1792                 }
1793
1794         } else
1795                 log_debug("Unknown serialization key '%s'", key);
1796
1797         return 0;
1798 }
1799
1800 static UnitActiveState socket_active_state(Unit *u) {
1801         assert(u);
1802
1803         return state_translation_table[SOCKET(u)->state];
1804 }
1805
1806 static const char *socket_sub_state_to_string(Unit *u) {
1807         assert(u);
1808
1809         return socket_state_to_string(SOCKET(u)->state);
1810 }
1811
1812 static bool socket_check_gc(Unit *u) {
1813         Socket *s = SOCKET(u);
1814
1815         assert(u);
1816
1817         return s->n_connections > 0;
1818 }
1819
1820 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1821         Socket *s = SOCKET(u);
1822         int cfd = -1;
1823
1824         assert(s);
1825         assert(fd >= 0);
1826
1827         if (s->state != SOCKET_LISTENING)
1828                 return;
1829
1830         log_debug("Incoming traffic on %s", u->id);
1831
1832         if (events != EPOLLIN) {
1833
1834                 if (events & EPOLLHUP)
1835                         log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1836                 else
1837                         log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1838
1839                 goto fail;
1840         }
1841
1842         if (w->socket_accept) {
1843                 for (;;) {
1844
1845                         if ((cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK)) < 0) {
1846
1847                                 if (errno == EINTR)
1848                                         continue;
1849
1850                                 log_error("Failed to accept socket: %m");
1851                                 goto fail;
1852                         }
1853
1854                         break;
1855                 }
1856
1857                 socket_apply_socket_options(s, cfd);
1858         }
1859
1860         socket_enter_running(s, cfd);
1861         return;
1862
1863 fail:
1864         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1865 }
1866
1867 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1868         Socket *s = SOCKET(u);
1869         SocketResult f;
1870
1871         assert(s);
1872         assert(pid >= 0);
1873
1874         if (pid != s->control_pid)
1875                 return;
1876
1877         s->control_pid = 0;
1878
1879         if (is_clean_exit(code, status))
1880                 f = SOCKET_SUCCESS;
1881         else if (code == CLD_EXITED)
1882                 f = SOCKET_FAILURE_EXIT_CODE;
1883         else if (code == CLD_KILLED)
1884                 f = SOCKET_FAILURE_SIGNAL;
1885         else if (code == CLD_DUMPED)
1886                 f = SOCKET_FAILURE_CORE_DUMP;
1887         else
1888                 assert_not_reached("Unknown code");
1889
1890         if (s->control_command) {
1891                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1892
1893                 if (s->control_command->ignore)
1894                         f = SOCKET_SUCCESS;
1895         }
1896
1897         log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1898                  "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1899
1900         if (f != SOCKET_SUCCESS)
1901                 s->result = f;
1902
1903         if (s->control_command &&
1904             s->control_command->command_next &&
1905             f == SOCKET_SUCCESS) {
1906
1907                 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1908                 socket_run_next(s);
1909         } else {
1910                 s->control_command = NULL;
1911                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1912
1913                 /* No further commands for this step, so let's figure
1914                  * out what to do next */
1915
1916                 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1917
1918                 switch (s->state) {
1919
1920                 case SOCKET_START_PRE:
1921                         if (f == SOCKET_SUCCESS)
1922                                 socket_enter_start_post(s);
1923                         else
1924                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1925                         break;
1926
1927                 case SOCKET_START_POST:
1928                         if (f == SOCKET_SUCCESS)
1929                                 socket_enter_listening(s);
1930                         else
1931                                 socket_enter_stop_pre(s, f);
1932                         break;
1933
1934                 case SOCKET_STOP_PRE:
1935                 case SOCKET_STOP_PRE_SIGTERM:
1936                 case SOCKET_STOP_PRE_SIGKILL:
1937                         socket_enter_stop_post(s, f);
1938                         break;
1939
1940                 case SOCKET_STOP_POST:
1941                 case SOCKET_FINAL_SIGTERM:
1942                 case SOCKET_FINAL_SIGKILL:
1943                         socket_enter_dead(s, f);
1944                         break;
1945
1946                 default:
1947                         assert_not_reached("Uh, control process died at wrong time.");
1948                 }
1949         }
1950
1951         /* Notify clients about changed exit status */
1952         unit_add_to_dbus_queue(u);
1953 }
1954
1955 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1956         Socket *s = SOCKET(u);
1957
1958         assert(s);
1959         assert(elapsed == 1);
1960         assert(w == &s->timer_watch);
1961
1962         switch (s->state) {
1963
1964         case SOCKET_START_PRE:
1965                 log_warning("%s starting timed out. Terminating.", u->id);
1966                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1967                 break;
1968
1969         case SOCKET_START_POST:
1970                 log_warning("%s starting timed out. Stopping.", u->id);
1971                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1972                 break;
1973
1974         case SOCKET_STOP_PRE:
1975                 log_warning("%s stopping timed out. Terminating.", u->id);
1976                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1977                 break;
1978
1979         case SOCKET_STOP_PRE_SIGTERM:
1980                 if (s->exec_context.send_sigkill) {
1981                         log_warning("%s stopping timed out. Killing.", u->id);
1982                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1983                 } else {
1984                         log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
1985                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1986                 }
1987                 break;
1988
1989         case SOCKET_STOP_PRE_SIGKILL:
1990                 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
1991                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1992                 break;
1993
1994         case SOCKET_STOP_POST:
1995                 log_warning("%s stopping timed out (2). Terminating.", u->id);
1996                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1997                 break;
1998
1999         case SOCKET_FINAL_SIGTERM:
2000                 if (s->exec_context.send_sigkill) {
2001                         log_warning("%s stopping timed out (2). Killing.", u->id);
2002                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2003                 } else {
2004                         log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2005                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2006                 }
2007                 break;
2008
2009         case SOCKET_FINAL_SIGKILL:
2010                 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2011                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2012                 break;
2013
2014         default:
2015                 assert_not_reached("Timeout at wrong time.");
2016         }
2017 }
2018
2019 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2020         int *rfds;
2021         unsigned rn_fds, k;
2022         SocketPort *p;
2023
2024         assert(s);
2025         assert(fds);
2026         assert(n_fds);
2027
2028         /* Called from the service code for requesting our fds */
2029
2030         rn_fds = 0;
2031         LIST_FOREACH(port, p, s->ports)
2032                 if (p->fd >= 0)
2033                         rn_fds++;
2034
2035         if (rn_fds <= 0) {
2036                 *fds = NULL;
2037                 *n_fds = 0;
2038                 return 0;
2039         }
2040
2041         if (!(rfds = new(int, rn_fds)))
2042                 return -ENOMEM;
2043
2044         k = 0;
2045         LIST_FOREACH(port, p, s->ports)
2046                 if (p->fd >= 0)
2047                         rfds[k++] = p->fd;
2048
2049         assert(k == rn_fds);
2050
2051         *fds = rfds;
2052         *n_fds = rn_fds;
2053
2054         return 0;
2055 }
2056
2057 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2058         assert(s);
2059
2060         /* The service is dead. Dang!
2061          *
2062          * This is strictly for one-instance-for-all-connections
2063          * services. */
2064
2065         if (s->state == SOCKET_RUNNING) {
2066                 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2067                 if (failed_permanent)
2068                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2069                 else
2070                         socket_enter_listening(s);
2071         }
2072 }
2073
2074 void socket_connection_unref(Socket *s) {
2075         assert(s);
2076
2077         /* The service is dead. Yay!
2078          *
2079          * This is strictly for one-instance-per-connection
2080          * services. */
2081
2082         assert(s->n_connections > 0);
2083         s->n_connections--;
2084
2085         log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2086 }
2087
2088 static void socket_reset_failed(Unit *u) {
2089         Socket *s = SOCKET(u);
2090
2091         assert(s);
2092
2093         if (s->state == SOCKET_FAILED)
2094                 socket_set_state(s, SOCKET_DEAD);
2095
2096         s->result = SOCKET_SUCCESS;
2097 }
2098
2099 static int socket_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
2100         Socket *s = SOCKET(u);
2101         int r = 0;
2102         Set *pid_set = NULL;
2103
2104         assert(s);
2105
2106         if (who == KILL_MAIN) {
2107                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2108                 return -ESRCH;
2109         }
2110
2111         if (s->control_pid <= 0 && who == KILL_CONTROL) {
2112                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2113                 return -ESRCH;
2114         }
2115
2116         if (who == KILL_CONTROL || who == KILL_ALL)
2117                 if (s->control_pid > 0)
2118                         if (kill(s->control_pid, signo) < 0)
2119                                 r = -errno;
2120
2121         if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
2122                 int q;
2123
2124                 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
2125                         return -ENOMEM;
2126
2127                 /* Exclude the control pid from being killed via the cgroup */
2128                 if (s->control_pid > 0)
2129                         if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
2130                                 r = q;
2131                                 goto finish;
2132                         }
2133
2134                 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2135                 if (q < 0)
2136                         if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2137                                 r = q;
2138         }
2139
2140 finish:
2141         if (pid_set)
2142                 set_free(pid_set);
2143
2144         return r;
2145 }
2146
2147 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2148         [SOCKET_DEAD] = "dead",
2149         [SOCKET_START_PRE] = "start-pre",
2150         [SOCKET_START_POST] = "start-post",
2151         [SOCKET_LISTENING] = "listening",
2152         [SOCKET_RUNNING] = "running",
2153         [SOCKET_STOP_PRE] = "stop-pre",
2154         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2155         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2156         [SOCKET_STOP_POST] = "stop-post",
2157         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2158         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2159         [SOCKET_FAILED] = "failed"
2160 };
2161
2162 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2163
2164 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2165         [SOCKET_EXEC_START_PRE] = "StartPre",
2166         [SOCKET_EXEC_START_POST] = "StartPost",
2167         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2168         [SOCKET_EXEC_STOP_POST] = "StopPost"
2169 };
2170
2171 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2172
2173 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2174         [SOCKET_SUCCESS] = "success",
2175         [SOCKET_FAILURE_RESOURCES] = "resources",
2176         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2177         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2178         [SOCKET_FAILURE_SIGNAL] = "signal",
2179         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2180         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2181 };
2182
2183 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2184
2185 const UnitVTable socket_vtable = {
2186         .suffix = ".socket",
2187         .object_size = sizeof(Socket),
2188         .sections =
2189                 "Unit\0"
2190                 "Socket\0"
2191                 "Install\0",
2192
2193         .init = socket_init,
2194         .done = socket_done,
2195         .load = socket_load,
2196
2197         .kill = socket_kill,
2198
2199         .coldplug = socket_coldplug,
2200
2201         .dump = socket_dump,
2202
2203         .start = socket_start,
2204         .stop = socket_stop,
2205
2206         .serialize = socket_serialize,
2207         .deserialize_item = socket_deserialize_item,
2208
2209         .active_state = socket_active_state,
2210         .sub_state_to_string = socket_sub_state_to_string,
2211
2212         .check_gc = socket_check_gc,
2213
2214         .fd_event = socket_fd_event,
2215         .sigchld_event = socket_sigchld_event,
2216         .timer_event = socket_timer_event,
2217
2218         .reset_failed = socket_reset_failed,
2219
2220         .bus_interface = "org.freedesktop.systemd1.Socket",
2221         .bus_message_handler = bus_socket_message_handler,
2222         .bus_invalidating_properties =  bus_socket_invalidating_properties
2223 };