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