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