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