src/core/socket.c

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