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