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