src/core/socket.c

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