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