src/core/socket.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <arpa/inet.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <mqueue.h>
  24 #include <netinet/tcp.h>
  25 #include <signal.h>
  26 #include <sys/epoll.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29 #include <linux/sctp.h>
  30
  31 #include "alloc-util.h"
  32 #include "bpf-firewall.h"
  33 #include "bus-error.h"
  34 #include "bus-util.h"
  35 #include "copy.h"
  36 #include "dbus-socket.h"
  37 #include "def.h"
  38 #include "exit-status.h"
  39 #include "fd-util.h"
  40 #include "format-util.h"
  41 #include "fs-util.h"
  42 #include "in-addr-util.h"
  43 #include "io-util.h"
  44 #include "label.h"
  45 #include "log.h"
  46 #include "missing.h"
  47 #include "mkdir.h"
  48 #include "parse-util.h"
  49 #include "path-util.h"
  50 #include "process-util.h"
  51 #include "selinux-util.h"
  52 #include "signal-util.h"
  53 #include "smack-util.h"
  54 #include "socket.h"
  55 #include "special.h"
  56 #include "string-table.h"
  57 #include "string-util.h"
  58 #include "strv.h"
  59 #include "unit-name.h"
  60 #include "unit.h"
  61 #include "user-util.h"
  62
  63 struct SocketPeer {
  64         unsigned n_ref;
  65
  66         Socket *socket;
  67         union sockaddr_union peer;
  68         socklen_t peer_salen;
  69 };
  70
  71 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
  72         [SOCKET_DEAD] = UNIT_INACTIVE,
  73         [SOCKET_START_PRE] = UNIT_ACTIVATING,
  74         [SOCKET_START_CHOWN] = UNIT_ACTIVATING,
  75         [SOCKET_START_POST] = UNIT_ACTIVATING,
  76         [SOCKET_LISTENING] = UNIT_ACTIVE,
  77         [SOCKET_RUNNING] = UNIT_ACTIVE,
  78         [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
  79         [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
  80         [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
  81         [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
  82         [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  83         [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  84         [SOCKET_FAILED] = UNIT_FAILED
  85 };
  86
  87 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  88 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  89
  90 static void socket_init(Unit *u) {
  91         Socket *s = SOCKET(u);
  92
  93         assert(u);
  94         assert(u->load_state == UNIT_STUB);
  95
  96         s->backlog = SOMAXCONN;
  97         s->timeout_usec = u->manager->default_timeout_start_usec;
  98         s->directory_mode = 0755;
  99         s->socket_mode = 0666;
 100
 101         s->max_connections = 64;
 102
 103         s->priority = -1;
 104         s->ip_tos = -1;
 105         s->ip_ttl = -1;
 106         s->mark = -1;
 107
 108         s->exec_context.std_output = u->manager->default_std_output;
 109         s->exec_context.std_error = u->manager->default_std_error;
 110
 111         s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
 112
 113         s->trigger_limit.interval = USEC_INFINITY;
 114         s->trigger_limit.burst = (unsigned) -1;
 115 }
 116
 117 static void socket_unwatch_control_pid(Socket *s) {
 118         assert(s);
 119
 120         if (s->control_pid <= 0)
 121                 return;
 122
 123         unit_unwatch_pid(UNIT(s), s->control_pid);
 124         s->control_pid = 0;
 125 }
 126
 127 static void socket_cleanup_fd_list(SocketPort *p) {
 128         assert(p);
 129
 130         close_many(p->auxiliary_fds, p->n_auxiliary_fds);
 131         p->auxiliary_fds = mfree(p->auxiliary_fds);
 132         p->n_auxiliary_fds = 0;
 133 }
 134
 135 void socket_free_ports(Socket *s) {
 136         SocketPort *p;
 137
 138         assert(s);
 139
 140         while ((p = s->ports)) {
 141                 LIST_REMOVE(port, s->ports, p);
 142
 143                 sd_event_source_unref(p->event_source);
 144
 145                 socket_cleanup_fd_list(p);
 146                 safe_close(p->fd);
 147                 free(p->path);
 148                 free(p);
 149         }
 150 }
 151
 152 static void socket_done(Unit *u) {
 153         Socket *s = SOCKET(u);
 154         SocketPeer *p;
 155
 156         assert(s);
 157
 158         socket_free_ports(s);
 159
 160         while ((p = set_steal_first(s->peers_by_address)))
 161                 p->socket = NULL;
 162
 163         s->peers_by_address = set_free(s->peers_by_address);
 164
 165         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
 166         exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
 167         s->control_command = NULL;
 168
 169         dynamic_creds_unref(&s->dynamic_creds);
 170
 171         socket_unwatch_control_pid(s);
 172
 173         unit_ref_unset(&s->service);
 174
 175         s->tcp_congestion = mfree(s->tcp_congestion);
 176         s->bind_to_device = mfree(s->bind_to_device);
 177
 178         s->smack = mfree(s->smack);
 179         s->smack_ip_in = mfree(s->smack_ip_in);
 180         s->smack_ip_out = mfree(s->smack_ip_out);
 181
 182         strv_free(s->symlinks);
 183
 184         s->user = mfree(s->user);
 185         s->group = mfree(s->group);
 186
 187         s->fdname = mfree(s->fdname);
 188
 189         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 190 }
 191
 192 static int socket_arm_timer(Socket *s, usec_t usec) {
 193         int r;
 194
 195         assert(s);
 196
 197         if (s->timer_event_source) {
 198                 r = sd_event_source_set_time(s->timer_event_source, usec);
 199                 if (r < 0)
 200                         return r;
 201
 202                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
 203         }
 204
 205         if (usec == USEC_INFINITY)
 206                 return 0;
 207
 208         r = sd_event_add_time(
 209                         UNIT(s)->manager->event,
 210                         &s->timer_event_source,
 211                         CLOCK_MONOTONIC,
 212                         usec, 0,
 213                         socket_dispatch_timer, s);
 214         if (r < 0)
 215                 return r;
 216
 217         (void) sd_event_source_set_description(s->timer_event_source, "socket-timer");
 218
 219         return 0;
 220 }
 221
 222 int socket_instantiate_service(Socket *s) {
 223         _cleanup_free_ char *prefix = NULL, *name = NULL;
 224         int r;
 225         Unit *u;
 226
 227         assert(s);
 228
 229         /* This fills in s->service if it isn't filled in yet. For
 230          * Accept=yes sockets we create the next connection service
 231          * here. For Accept=no this is mostly a NOP since the service
 232          * is figured out at load time anyway. */
 233
 234         if (UNIT_DEREF(s->service))
 235                 return 0;
 236
 237         if (!s->accept)
 238                 return 0;
 239
 240         r = unit_name_to_prefix(UNIT(s)->id, &prefix);
 241         if (r < 0)
 242                 return r;
 243
 244         if (asprintf(&name, "%s@%u.service", prefix, s->n_accepted) < 0)
 245                 return -ENOMEM;
 246
 247         r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
 248         if (r < 0)
 249                 return r;
 250
 251         unit_ref_set(&s->service, u);
 252
 253         return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false, UNIT_DEPENDENCY_IMPLICIT);
 254 }
 255
 256 static bool have_non_accept_socket(Socket *s) {
 257         SocketPort *p;
 258
 259         assert(s);
 260
 261         if (!s->accept)
 262                 return true;
 263
 264         LIST_FOREACH(port, p, s->ports) {
 265
 266                 if (p->type != SOCKET_SOCKET)
 267                         return true;
 268
 269                 if (!socket_address_can_accept(&p->address))
 270                         return true;
 271         }
 272
 273         return false;
 274 }
 275
 276 static int socket_add_mount_dependencies(Socket *s) {
 277         SocketPort *p;
 278         int r;
 279
 280         assert(s);
 281
 282         LIST_FOREACH(port, p, s->ports) {
 283                 const char *path = NULL;
 284
 285                 if (p->type == SOCKET_SOCKET)
 286                         path = socket_address_get_path(&p->address);
 287                 else if (IN_SET(p->type, SOCKET_FIFO, SOCKET_SPECIAL, SOCKET_USB_FUNCTION))
 288                         path = p->path;
 289
 290                 if (!path)
 291                         continue;
 292
 293                 r = unit_require_mounts_for(UNIT(s), path, UNIT_DEPENDENCY_FILE);
 294                 if (r < 0)
 295                         return r;
 296         }
 297
 298         return 0;
 299 }
 300
 301 static int socket_add_device_dependencies(Socket *s) {
 302         char *t;
 303
 304         assert(s);
 305
 306         if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
 307                 return 0;
 308
 309         t = strjoina("/sys/subsystem/net/devices/", s->bind_to_device);
 310         return unit_add_node_dependency(UNIT(s), t, false, UNIT_BINDS_TO, UNIT_DEPENDENCY_FILE);
 311 }
 312
 313 static int socket_add_default_dependencies(Socket *s) {
 314         int r;
 315         assert(s);
 316
 317         if (!UNIT(s)->default_dependencies)
 318                 return 0;
 319
 320         r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
 321         if (r < 0)
 322                 return r;
 323
 324         if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
 325                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
 326                 if (r < 0)
 327                         return r;
 328         }
 329
 330         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
 331 }
 332
 333 _pure_ static bool socket_has_exec(Socket *s) {
 334         unsigned i;
 335         assert(s);
 336
 337         for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
 338                 if (s->exec_command[i])
 339                         return true;
 340
 341         return false;
 342 }
 343
 344 static int socket_add_extras(Socket *s) {
 345         Unit *u = UNIT(s);
 346         int r;
 347
 348         assert(s);
 349
 350         /* Pick defaults for the trigger limit, if nothing was explicitly configured. We pick a relatively high limit
 351          * in Accept=yes mode, and a lower limit for Accept=no. Reason: in Accept=yes mode we are invoking accept()
 352          * ourselves before the trigger limit can hit, thus incoming connections are taken off the socket queue quickly
 353          * and reliably. This is different for Accept=no, where the spawned service has to take the incoming traffic
 354          * off the queues, which it might not necessarily do. Moreover, while Accept=no services are supposed to
 355          * process whatever is queued in one go, and thus should normally never have to be started frequently. This is
 356          * different for Accept=yes where each connection is processed by a new service instance, and thus frequent
 357          * service starts are typical. */
 358
 359         if (s->trigger_limit.interval == USEC_INFINITY)
 360                 s->trigger_limit.interval = 2 * USEC_PER_SEC;
 361
 362         if (s->trigger_limit.burst == (unsigned) -1) {
 363                 if (s->accept)
 364                         s->trigger_limit.burst = 200;
 365                 else
 366                         s->trigger_limit.burst = 20;
 367         }
 368
 369         if (have_non_accept_socket(s)) {
 370
 371                 if (!UNIT_DEREF(s->service)) {
 372                         Unit *x;
 373
 374                         r = unit_load_related_unit(u, ".service", &x);
 375                         if (r < 0)
 376                                 return r;
 377
 378                         unit_ref_set(&s->service, x);
 379                 }
 380
 381                 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true, UNIT_DEPENDENCY_IMPLICIT);
 382                 if (r < 0)
 383                         return r;
 384         }
 385
 386         r = socket_add_mount_dependencies(s);
 387         if (r < 0)
 388                 return r;
 389
 390         r = socket_add_device_dependencies(s);
 391         if (r < 0)
 392                 return r;
 393
 394         r = unit_patch_contexts(u);
 395         if (r < 0)
 396                 return r;
 397
 398         if (socket_has_exec(s)) {
 399                 r = unit_add_exec_dependencies(u, &s->exec_context);
 400                 if (r < 0)
 401                         return r;
 402         }
 403
 404         r = unit_set_default_slice(u);
 405         if (r < 0)
 406                 return r;
 407
 408         r = socket_add_default_dependencies(s);
 409         if (r < 0)
 410                 return r;
 411
 412         return 0;
 413 }
 414
 415 static const char *socket_find_symlink_target(Socket *s) {
 416         const char *found = NULL;
 417         SocketPort *p;
 418
 419         LIST_FOREACH(port, p, s->ports) {
 420                 const char *f = NULL;
 421
 422                 switch (p->type) {
 423
 424                 case SOCKET_FIFO:
 425                         f = p->path;
 426                         break;
 427
 428                 case SOCKET_SOCKET:
 429                         f = socket_address_get_path(&p->address);
 430                         break;
 431
 432                 default:
 433                         break;
 434                 }
 435
 436                 if (f) {
 437                         if (found)
 438                                 return NULL;
 439
 440                         found = f;
 441                 }
 442         }
 443
 444         return found;
 445 }
 446
 447 static int socket_verify(Socket *s) {
 448         assert(s);
 449
 450         if (UNIT(s)->load_state != UNIT_LOADED)
 451                 return 0;
 452
 453         if (!s->ports) {
 454                 log_unit_error(UNIT(s), "Unit has no Listen setting (ListenStream=, ListenDatagram=, ListenFIFO=, ...). Refusing.");
 455                 return -EINVAL;
 456         }
 457
 458         if (s->accept && have_non_accept_socket(s)) {
 459                 log_unit_error(UNIT(s), "Unit configured for accepting sockets, but sockets are non-accepting. Refusing.");
 460                 return -EINVAL;
 461         }
 462
 463         if (s->accept && s->max_connections <= 0) {
 464                 log_unit_error(UNIT(s), "MaxConnection= setting too small. Refusing.");
 465                 return -EINVAL;
 466         }
 467
 468         if (s->accept && UNIT_DEREF(s->service)) {
 469                 log_unit_error(UNIT(s), "Explicit service configuration for accepting socket units not supported. Refusing.");
 470                 return -EINVAL;
 471         }
 472
 473         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 474                 log_unit_error(UNIT(s), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing.");
 475                 return -EINVAL;
 476         }
 477
 478         if (!strv_isempty(s->symlinks) && !socket_find_symlink_target(s)) {
 479                 log_unit_error(UNIT(s), "Unit has symlinks set but none or more than one node in the file system. Refusing.");
 480                 return -EINVAL;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static void peer_address_hash_func(const void *p, struct siphash *state) {
 487         const SocketPeer *s = p;
 488
 489         assert(s);
 490
 491         if (s->peer.sa.sa_family == AF_INET)
 492                 siphash24_compress(&s->peer.in.sin_addr, sizeof(s->peer.in.sin_addr), state);
 493         else if (s->peer.sa.sa_family == AF_INET6)
 494                 siphash24_compress(&s->peer.in6.sin6_addr, sizeof(s->peer.in6.sin6_addr), state);
 495         else if (s->peer.sa.sa_family == AF_VSOCK)
 496                 siphash24_compress(&s->peer.vm.svm_cid, sizeof(s->peer.vm.svm_cid), state);
 497         else
 498                 assert_not_reached("Unknown address family.");
 499 }
 500
 501 static int peer_address_compare_func(const void *a, const void *b) {
 502         const SocketPeer *x = a, *y = b;
 503
 504         if (x->peer.sa.sa_family < y->peer.sa.sa_family)
 505                 return -1;
 506         if (x->peer.sa.sa_family > y->peer.sa.sa_family)
 507                 return 1;
 508
 509         switch(x->peer.sa.sa_family) {
 510         case AF_INET:
 511                 return memcmp(&x->peer.in.sin_addr, &y->peer.in.sin_addr, sizeof(x->peer.in.sin_addr));
 512         case AF_INET6:
 513                 return memcmp(&x->peer.in6.sin6_addr, &y->peer.in6.sin6_addr, sizeof(x->peer.in6.sin6_addr));
 514         case AF_VSOCK:
 515                 if (x->peer.vm.svm_cid < y->peer.vm.svm_cid)
 516                         return -1;
 517                 if (x->peer.vm.svm_cid > y->peer.vm.svm_cid)
 518                         return 1;
 519                 return 0;
 520         }
 521         assert_not_reached("Black sheep in the family!");
 522 }
 523
 524 const struct hash_ops peer_address_hash_ops = {
 525         .hash = peer_address_hash_func,
 526         .compare = peer_address_compare_func
 527 };
 528
 529 static int socket_load(Unit *u) {
 530         Socket *s = SOCKET(u);
 531         int r;
 532
 533         assert(u);
 534         assert(u->load_state == UNIT_STUB);
 535
 536         r = set_ensure_allocated(&s->peers_by_address, &peer_address_hash_ops);
 537         if (r < 0)
 538                 return r;
 539
 540         r = unit_load_fragment_and_dropin(u);
 541         if (r < 0)
 542                 return r;
 543
 544         if (u->load_state == UNIT_LOADED) {
 545                 /* This is a new unit? Then let's add in some extras */
 546                 r = socket_add_extras(s);
 547                 if (r < 0)
 548                         return r;
 549         }
 550
 551         return socket_verify(s);
 552 }
 553
 554 static SocketPeer *socket_peer_new(void) {
 555         SocketPeer *p;
 556
 557         p = new0(SocketPeer, 1);
 558         if (!p)
 559                 return NULL;
 560
 561         p->n_ref = 1;
 562
 563         return p;
 564 }
 565
 566 SocketPeer *socket_peer_ref(SocketPeer *p) {
 567         if (!p)
 568                 return NULL;
 569
 570         assert(p->n_ref > 0);
 571         p->n_ref++;
 572
 573         return p;
 574 }
 575
 576 SocketPeer *socket_peer_unref(SocketPeer *p) {
 577         if (!p)
 578                 return NULL;
 579
 580         assert(p->n_ref > 0);
 581
 582         p->n_ref--;
 583
 584         if (p->n_ref > 0)
 585                 return NULL;
 586
 587         if (p->socket)
 588                 set_remove(p->socket->peers_by_address, p);
 589
 590         return mfree(p);
 591 }
 592
 593 int socket_acquire_peer(Socket *s, int fd, SocketPeer **p) {
 594         _cleanup_(socket_peer_unrefp) SocketPeer *remote = NULL;
 595         SocketPeer sa = {}, *i;
 596         socklen_t salen = sizeof(sa.peer);
 597         int r;
 598
 599         assert(fd >= 0);
 600         assert(s);
 601
 602         r = getpeername(fd, &sa.peer.sa, &salen);
 603         if (r < 0)
 604                 return log_error_errno(errno, "getpeername failed: %m");
 605
 606         if (!IN_SET(sa.peer.sa.sa_family, AF_INET, AF_INET6, AF_VSOCK)) {
 607                 *p = NULL;
 608                 return 0;
 609         }
 610
 611         i = set_get(s->peers_by_address, &sa);
 612         if (i) {
 613                 *p = socket_peer_ref(i);
 614                 return 1;
 615         }
 616
 617         remote = socket_peer_new();
 618         if (!remote)
 619                 return log_oom();
 620
 621         remote->peer = sa.peer;
 622         remote->peer_salen = salen;
 623
 624         r = set_put(s->peers_by_address, remote);
 625         if (r < 0)
 626                 return r;
 627
 628         remote->socket = s;
 629
 630         *p = remote;
 631         remote = NULL;
 632
 633         return 1;
 634 }
 635
 636 _const_ static const char* listen_lookup(int family, int type) {
 637
 638         if (family == AF_NETLINK)
 639                 return "ListenNetlink";
 640
 641         if (type == SOCK_STREAM)
 642                 return "ListenStream";
 643         else if (type == SOCK_DGRAM)
 644                 return "ListenDatagram";
 645         else if (type == SOCK_SEQPACKET)
 646                 return "ListenSequentialPacket";
 647
 648         assert_not_reached("Unknown socket type");
 649         return NULL;
 650 }
 651
 652 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
 653         char time_string[FORMAT_TIMESPAN_MAX];
 654         SocketExecCommand c;
 655         Socket *s = SOCKET(u);
 656         SocketPort *p;
 657         const char *prefix2;
 658
 659         assert(s);
 660         assert(f);
 661
 662         prefix = strempty(prefix);
 663         prefix2 = strjoina(prefix, "\t");
 664
 665         fprintf(f,
 666                 "%sSocket State: %s\n"
 667                 "%sResult: %s\n"
 668                 "%sBindIPv6Only: %s\n"
 669                 "%sBacklog: %u\n"
 670                 "%sSocketMode: %04o\n"
 671                 "%sDirectoryMode: %04o\n"
 672                 "%sKeepAlive: %s\n"
 673                 "%sNoDelay: %s\n"
 674                 "%sFreeBind: %s\n"
 675                 "%sTransparent: %s\n"
 676                 "%sBroadcast: %s\n"
 677                 "%sPassCredentials: %s\n"
 678                 "%sPassSecurity: %s\n"
 679                 "%sTCPCongestion: %s\n"
 680                 "%sRemoveOnStop: %s\n"
 681                 "%sWritable: %s\n"
 682                 "%sFDName: %s\n"
 683                 "%sSELinuxContextFromNet: %s\n",
 684                 prefix, socket_state_to_string(s->state),
 685                 prefix, socket_result_to_string(s->result),
 686                 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
 687                 prefix, s->backlog,
 688                 prefix, s->socket_mode,
 689                 prefix, s->directory_mode,
 690                 prefix, yes_no(s->keep_alive),
 691                 prefix, yes_no(s->no_delay),
 692                 prefix, yes_no(s->free_bind),
 693                 prefix, yes_no(s->transparent),
 694                 prefix, yes_no(s->broadcast),
 695                 prefix, yes_no(s->pass_cred),
 696                 prefix, yes_no(s->pass_sec),
 697                 prefix, strna(s->tcp_congestion),
 698                 prefix, yes_no(s->remove_on_stop),
 699                 prefix, yes_no(s->writable),
 700                 prefix, socket_fdname(s),
 701                 prefix, yes_no(s->selinux_context_from_net));
 702
 703         if (s->control_pid > 0)
 704                 fprintf(f,
 705                         "%sControl PID: "PID_FMT"\n",
 706                         prefix, s->control_pid);
 707
 708         if (s->bind_to_device)
 709                 fprintf(f,
 710                         "%sBindToDevice: %s\n",
 711                         prefix, s->bind_to_device);
 712
 713         if (s->accept)
 714                 fprintf(f,
 715                         "%sAccepted: %u\n"
 716                         "%sNConnections: %u\n"
 717                         "%sMaxConnections: %u\n",
 718                         prefix, s->n_accepted,
 719                         prefix, s->n_connections,
 720                         prefix, s->max_connections);
 721
 722         if (s->priority >= 0)
 723                 fprintf(f,
 724                         "%sPriority: %i\n",
 725                         prefix, s->priority);
 726
 727         if (s->receive_buffer > 0)
 728                 fprintf(f,
 729                         "%sReceiveBuffer: %zu\n",
 730                         prefix, s->receive_buffer);
 731
 732         if (s->send_buffer > 0)
 733                 fprintf(f,
 734                         "%sSendBuffer: %zu\n",
 735                         prefix, s->send_buffer);
 736
 737         if (s->ip_tos >= 0)
 738                 fprintf(f,
 739                         "%sIPTOS: %i\n",
 740                         prefix, s->ip_tos);
 741
 742         if (s->ip_ttl >= 0)
 743                 fprintf(f,
 744                         "%sIPTTL: %i\n",
 745                         prefix, s->ip_ttl);
 746
 747         if (s->pipe_size > 0)
 748                 fprintf(f,
 749                         "%sPipeSize: %zu\n",
 750                         prefix, s->pipe_size);
 751
 752         if (s->mark >= 0)
 753                 fprintf(f,
 754                         "%sMark: %i\n",
 755                         prefix, s->mark);
 756
 757         if (s->mq_maxmsg > 0)
 758                 fprintf(f,
 759                         "%sMessageQueueMaxMessages: %li\n",
 760                         prefix, s->mq_maxmsg);
 761
 762         if (s->mq_msgsize > 0)
 763                 fprintf(f,
 764                         "%sMessageQueueMessageSize: %li\n",
 765                         prefix, s->mq_msgsize);
 766
 767         if (s->reuse_port)
 768                 fprintf(f,
 769                         "%sReusePort: %s\n",
 770                          prefix, yes_no(s->reuse_port));
 771
 772         if (s->smack)
 773                 fprintf(f,
 774                         "%sSmackLabel: %s\n",
 775                         prefix, s->smack);
 776
 777         if (s->smack_ip_in)
 778                 fprintf(f,
 779                         "%sSmackLabelIPIn: %s\n",
 780                         prefix, s->smack_ip_in);
 781
 782         if (s->smack_ip_out)
 783                 fprintf(f,
 784                         "%sSmackLabelIPOut: %s\n",
 785                         prefix, s->smack_ip_out);
 786
 787         if (!isempty(s->user) || !isempty(s->group))
 788                 fprintf(f,
 789                         "%sSocketUser: %s\n"
 790                         "%sSocketGroup: %s\n",
 791                         prefix, strna(s->user),
 792                         prefix, strna(s->group));
 793
 794         if (s->keep_alive_time > 0)
 795                 fprintf(f,
 796                         "%sKeepAliveTimeSec: %s\n",
 797                         prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_time, USEC_PER_SEC));
 798
 799         if (s->keep_alive_interval)
 800                 fprintf(f,
 801                         "%sKeepAliveIntervalSec: %s\n",
 802                         prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->keep_alive_interval, USEC_PER_SEC));
 803
 804         if (s->keep_alive_cnt)
 805                 fprintf(f,
 806                         "%sKeepAliveProbes: %u\n",
 807                         prefix, s->keep_alive_cnt);
 808
 809         if (s->defer_accept)
 810                 fprintf(f,
 811                         "%sDeferAcceptSec: %s\n",
 812                         prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->defer_accept, USEC_PER_SEC));
 813
 814         LIST_FOREACH(port, p, s->ports) {
 815
 816                 if (p->type == SOCKET_SOCKET) {
 817                         const char *t;
 818                         int r;
 819                         char *k = NULL;
 820
 821                         r = socket_address_print(&p->address, &k);
 822                         if (r < 0)
 823                                 t = strerror(-r);
 824                         else
 825                                 t = k;
 826
 827                         fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
 828                         free(k);
 829                 } else if (p->type == SOCKET_SPECIAL)
 830                         fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
 831                 else if (p->type == SOCKET_USB_FUNCTION)
 832                         fprintf(f, "%sListenUSBFunction: %s\n", prefix, p->path);
 833                 else if (p->type == SOCKET_MQUEUE)
 834                         fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
 835                 else
 836                         fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
 837         }
 838
 839         fprintf(f,
 840                 "%sTriggerLimitIntervalSec: %s\n"
 841                 "%sTriggerLimitBurst: %u\n",
 842                 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, s->trigger_limit.interval, USEC_PER_SEC),
 843                 prefix, s->trigger_limit.burst);
 844
 845         exec_context_dump(&s->exec_context, f, prefix);
 846         kill_context_dump(&s->kill_context, f, prefix);
 847
 848         for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
 849                 if (!s->exec_command[c])
 850                         continue;
 851
 852                 fprintf(f, "%s-> %s:\n",
 853                         prefix, socket_exec_command_to_string(c));
 854
 855                 exec_command_dump_list(s->exec_command[c], f, prefix2);
 856         }
 857
 858         cgroup_context_dump(&s->cgroup_context, f, prefix);
 859 }
 860
 861 static int instance_from_socket(int fd, unsigned nr, char **instance) {
 862         socklen_t l;
 863         char *r;
 864         union sockaddr_union local, remote;
 865
 866         assert(fd >= 0);
 867         assert(instance);
 868
 869         l = sizeof(local);
 870         if (getsockname(fd, &local.sa, &l) < 0)
 871                 return -errno;
 872
 873         l = sizeof(remote);
 874         if (getpeername(fd, &remote.sa, &l) < 0)
 875                 return -errno;
 876
 877         switch (local.sa.sa_family) {
 878
 879         case AF_INET: {
 880                 uint32_t
 881                         a = be32toh(local.in.sin_addr.s_addr),
 882                         b = be32toh(remote.in.sin_addr.s_addr);
 883
 884                 if (asprintf(&r,
 885                              "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 886                              nr,
 887                              a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
 888                              be16toh(local.in.sin_port),
 889                              b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
 890                              be16toh(remote.in.sin_port)) < 0)
 891                         return -ENOMEM;
 892
 893                 break;
 894         }
 895
 896         case AF_INET6: {
 897                 static const unsigned char ipv4_prefix[] = {
 898                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
 899                 };
 900
 901                 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
 902                     memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
 903                         const uint8_t
 904                                 *a = local.in6.sin6_addr.s6_addr+12,
 905                                 *b = remote.in6.sin6_addr.s6_addr+12;
 906
 907                         if (asprintf(&r,
 908                                      "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 909                                      nr,
 910                                      a[0], a[1], a[2], a[3],
 911                                      be16toh(local.in6.sin6_port),
 912                                      b[0], b[1], b[2], b[3],
 913                                      be16toh(remote.in6.sin6_port)) < 0)
 914                                 return -ENOMEM;
 915                 } else {
 916                         char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
 917
 918                         if (asprintf(&r,
 919                                      "%u-%s:%u-%s:%u",
 920                                      nr,
 921                                      inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
 922                                      be16toh(local.in6.sin6_port),
 923                                      inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
 924                                      be16toh(remote.in6.sin6_port)) < 0)
 925                                 return -ENOMEM;
 926                 }
 927
 928                 break;
 929         }
 930
 931         case AF_UNIX: {
 932                 struct ucred ucred;
 933                 int k;
 934
 935                 k = getpeercred(fd, &ucred);
 936                 if (k >= 0) {
 937                         if (asprintf(&r,
 938                                      "%u-"PID_FMT"-"UID_FMT,
 939                                      nr, ucred.pid, ucred.uid) < 0)
 940                                 return -ENOMEM;
 941                 } else if (k == -ENODATA) {
 942                         /* This handles the case where somebody is
 943                          * connecting from another pid/uid namespace
 944                          * (e.g. from outside of our container). */
 945                         if (asprintf(&r,
 946                                      "%u-unknown",
 947                                      nr) < 0)
 948                                 return -ENOMEM;
 949                 } else
 950                         return k;
 951
 952                 break;
 953         }
 954
 955         case AF_VSOCK:
 956                 if (asprintf(&r,
 957                              "%u-%u:%u-%u:%u",
 958                              nr,
 959                              local.vm.svm_cid, local.vm.svm_port,
 960                              remote.vm.svm_cid, remote.vm.svm_port) < 0)
 961                         return -ENOMEM;
 962
 963                 break;
 964
 965         default:
 966                 assert_not_reached("Unhandled socket type.");
 967         }
 968
 969         *instance = r;
 970         return 0;
 971 }
 972
 973 static void socket_close_fds(Socket *s) {
 974         SocketPort *p;
 975         char **i;
 976
 977         assert(s);
 978
 979         LIST_FOREACH(port, p, s->ports) {
 980                 bool was_open;
 981
 982                 was_open = p->fd >= 0;
 983
 984                 p->event_source = sd_event_source_unref(p->event_source);
 985                 p->fd = safe_close(p->fd);
 986                 socket_cleanup_fd_list(p);
 987
 988                 /* One little note: we should normally not delete any sockets in the file system here! After all some
 989                  * other process we spawned might still have a reference of this fd and wants to continue to use
 990                  * it. Therefore we normally delete sockets in the file system before we create a new one, not after we
 991                  * stopped using one! That all said, if the user explicitly requested this, we'll delete them here
 992                  * anyway, but only then. */
 993
 994                 if (!was_open || !s->remove_on_stop)
 995                         continue;
 996
 997                 switch (p->type) {
 998
 999                 case SOCKET_FIFO:
1000                         (void) unlink(p->path);
1001                         break;
1002
1003                 case SOCKET_MQUEUE:
1004                         (void) mq_unlink(p->path);
1005                         break;
1006
1007                 case SOCKET_SOCKET:
1008                         (void) socket_address_unlink(&p->address);
1009                         break;
1010
1011                 default:
1012                         break;
1013                 }
1014         }
1015
1016         if (s->remove_on_stop)
1017                 STRV_FOREACH(i, s->symlinks)
1018                         (void) unlink(*i);
1019 }
1020
1021 static void socket_apply_socket_options(Socket *s, int fd) {
1022         int r;
1023
1024         assert(s);
1025         assert(fd >= 0);
1026
1027         if (s->keep_alive) {
1028                 int b = s->keep_alive;
1029                 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
1030                         log_unit_warning_errno(UNIT(s), errno, "SO_KEEPALIVE failed: %m");
1031         }
1032
1033         if (s->keep_alive_time) {
1034                 int value = s->keep_alive_time / USEC_PER_SEC;
1035                 if (setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, &value, sizeof(value)) < 0)
1036                         log_unit_warning_errno(UNIT(s), errno, "TCP_KEEPIDLE failed: %m");
1037         }
1038
1039         if (s->keep_alive_interval) {
1040                 int value = s->keep_alive_interval / USEC_PER_SEC;
1041                 if (setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &value, sizeof(value)) < 0)
1042                         log_unit_warning_errno(UNIT(s), errno, "TCP_KEEPINTVL failed: %m");
1043         }
1044
1045         if (s->keep_alive_cnt) {
1046                 int value = s->keep_alive_cnt;
1047                 if (setsockopt(fd, SOL_TCP, TCP_KEEPCNT, &value, sizeof(value)) < 0)
1048                         log_unit_warning_errno(UNIT(s), errno, "TCP_KEEPCNT failed: %m");
1049         }
1050
1051         if (s->defer_accept) {
1052                 int value = s->defer_accept / USEC_PER_SEC;
1053                 if (setsockopt(fd, SOL_TCP, TCP_DEFER_ACCEPT, &value, sizeof(value)) < 0)
1054                         log_unit_warning_errno(UNIT(s), errno, "TCP_DEFER_ACCEPT failed: %m");
1055         }
1056
1057         if (s->no_delay) {
1058                 int b = s->no_delay;
1059
1060                 if (s->socket_protocol == IPPROTO_SCTP) {
1061                         if (setsockopt(fd, SOL_SCTP, SCTP_NODELAY, &b, sizeof(b)) < 0)
1062                                 log_unit_warning_errno(UNIT(s), errno, "SCTP_NODELAY failed: %m");
1063                 } else {
1064                         if (setsockopt(fd, SOL_TCP, TCP_NODELAY, &b, sizeof(b)) < 0)
1065                                 log_unit_warning_errno(UNIT(s), errno, "TCP_NODELAY failed: %m");
1066                 }
1067         }
1068
1069         if (s->broadcast) {
1070                 int one = 1;
1071                 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
1072                         log_unit_warning_errno(UNIT(s), errno, "SO_BROADCAST failed: %m");
1073         }
1074
1075         if (s->pass_cred) {
1076                 int one = 1;
1077                 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
1078                         log_unit_warning_errno(UNIT(s), errno, "SO_PASSCRED failed: %m");
1079         }
1080
1081         if (s->pass_sec) {
1082                 int one = 1;
1083                 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
1084                         log_unit_warning_errno(UNIT(s), errno, "SO_PASSSEC failed: %m");
1085         }
1086
1087         if (s->priority >= 0)
1088                 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
1089                         log_unit_warning_errno(UNIT(s), errno, "SO_PRIORITY failed: %m");
1090
1091         if (s->receive_buffer > 0) {
1092                 int value = (int) s->receive_buffer;
1093
1094                 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
1095
1096                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
1097                         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
1098                                 log_unit_warning_errno(UNIT(s), errno, "SO_RCVBUF failed: %m");
1099         }
1100
1101         if (s->send_buffer > 0) {
1102                 int value = (int) s->send_buffer;
1103                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
1104                         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
1105                                 log_unit_warning_errno(UNIT(s), errno, "SO_SNDBUF failed: %m");
1106         }
1107
1108         if (s->mark >= 0)
1109                 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
1110                         log_unit_warning_errno(UNIT(s), errno, "SO_MARK failed: %m");
1111
1112         if (s->ip_tos >= 0)
1113                 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
1114                         log_unit_warning_errno(UNIT(s), errno, "IP_TOS failed: %m");
1115
1116         if (s->ip_ttl >= 0) {
1117                 int x;
1118
1119                 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
1120
1121                 if (socket_ipv6_is_supported())
1122                         x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
1123                 else {
1124                         x = -1;
1125                         errno = EAFNOSUPPORT;
1126                 }
1127
1128                 if (r < 0 && x < 0)
1129                         log_unit_warning_errno(UNIT(s), errno, "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
1130         }
1131
1132         if (s->tcp_congestion)
1133                 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
1134                         log_unit_warning_errno(UNIT(s), errno, "TCP_CONGESTION failed: %m");
1135
1136         if (s->smack_ip_in) {
1137                 r = mac_smack_apply_fd(fd, SMACK_ATTR_IPIN, s->smack_ip_in);
1138                 if (r < 0)
1139                         log_unit_error_errno(UNIT(s), r, "mac_smack_apply_ip_in_fd: %m");
1140         }
1141
1142         if (s->smack_ip_out) {
1143                 r = mac_smack_apply_fd(fd, SMACK_ATTR_IPOUT, s->smack_ip_out);
1144                 if (r < 0)
1145                         log_unit_error_errno(UNIT(s), r, "mac_smack_apply_ip_out_fd: %m");
1146         }
1147 }
1148
1149 static void socket_apply_fifo_options(Socket *s, int fd) {
1150         int r;
1151
1152         assert(s);
1153         assert(fd >= 0);
1154
1155         if (s->pipe_size > 0)
1156                 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
1157                         log_unit_warning_errno(UNIT(s), errno, "Setting pipe size failed, ignoring: %m");
1158
1159         if (s->smack) {
1160                 r = mac_smack_apply_fd(fd, SMACK_ATTR_ACCESS, s->smack);
1161                 if (r < 0)
1162                         log_unit_error_errno(UNIT(s), r, "SMACK relabelling failed, ignoring: %m");
1163         }
1164 }
1165
1166 static int fifo_address_create(
1167                 const char *path,
1168                 mode_t directory_mode,
1169                 mode_t socket_mode) {
1170
1171         _cleanup_close_ int fd = -1;
1172         mode_t old_mask;
1173         struct stat st;
1174         int r;
1175
1176         assert(path);
1177
1178         (void) mkdir_parents_label(path, directory_mode);
1179
1180         r = mac_selinux_create_file_prepare(path, S_IFIFO);
1181         if (r < 0)
1182                 return r;
1183
1184         /* Enforce the right access mode for the fifo */
1185         old_mask = umask(~ socket_mode);
1186
1187         /* Include the original umask in our mask */
1188         (void) umask(~socket_mode | old_mask);
1189
1190         r = mkfifo(path, socket_mode);
1191         (void) umask(old_mask);
1192
1193         if (r < 0 && errno != EEXIST) {
1194                 r = -errno;
1195                 goto fail;
1196         }
1197
1198         fd = open(path, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK | O_NOFOLLOW);
1199         if (fd < 0) {
1200                 r = -errno;
1201                 goto fail;
1202         }
1203
1204         mac_selinux_create_file_clear();
1205
1206         if (fstat(fd, &st) < 0) {
1207                 r = -errno;
1208                 goto fail;
1209         }
1210
1211         if (!S_ISFIFO(st.st_mode) ||
1212             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
1213             st.st_uid != getuid() ||
1214             st.st_gid != getgid()) {
1215                 r = -EEXIST;
1216                 goto fail;
1217         }
1218
1219         r = fd;
1220         fd = -1;
1221
1222         return r;
1223
1224 fail:
1225         mac_selinux_create_file_clear();
1226         return r;
1227 }
1228
1229 static int special_address_create(const char *path, bool writable) {
1230         _cleanup_close_ int fd = -1;
1231         struct stat st;
1232         int r;
1233
1234         assert(path);
1235
1236         fd = open(path, (writable ? O_RDWR : O_RDONLY)|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
1237         if (fd < 0)
1238                 return -errno;
1239
1240         if (fstat(fd, &st) < 0)
1241                 return -errno;
1242
1243         /* Check whether this is a /proc, /sys or /dev file or char device */
1244         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode))
1245                 return -EEXIST;
1246
1247         r = fd;
1248         fd = -1;
1249
1250         return r;
1251 }
1252
1253 static int usbffs_address_create(const char *path) {
1254         _cleanup_close_ int fd = -1;
1255         struct stat st;
1256         int r;
1257
1258         assert(path);
1259
1260         fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW);
1261         if (fd < 0)
1262                 return -errno;
1263
1264         if (fstat(fd, &st) < 0)
1265                 return -errno;
1266
1267         /* Check whether this is a regular file (ffs endpoint) */
1268         if (!S_ISREG(st.st_mode))
1269                 return -EEXIST;
1270
1271         r = fd;
1272         fd = -1;
1273
1274         return r;
1275 }
1276
1277 static int mq_address_create(
1278                 const char *path,
1279                 mode_t mq_mode,
1280                 long maxmsg,
1281                 long msgsize) {
1282
1283         _cleanup_close_ int fd = -1;
1284         struct stat st;
1285         mode_t old_mask;
1286         struct mq_attr _attr, *attr = NULL;
1287         int r;
1288
1289         assert(path);
1290
1291         if (maxmsg > 0 && msgsize > 0) {
1292                 _attr = (struct mq_attr) {
1293                         .mq_flags = O_NONBLOCK,
1294                         .mq_maxmsg = maxmsg,
1295                         .mq_msgsize = msgsize,
1296                 };
1297                 attr = &_attr;
1298         }
1299
1300         /* Enforce the right access mode for the mq */
1301         old_mask = umask(~ mq_mode);
1302
1303         /* Include the original umask in our mask */
1304         (void) umask(~mq_mode | old_mask);
1305         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
1306         (void) umask(old_mask);
1307
1308         if (fd < 0)
1309                 return -errno;
1310
1311         if (fstat(fd, &st) < 0)
1312                 return -errno;
1313
1314         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
1315             st.st_uid != getuid() ||
1316             st.st_gid != getgid())
1317                 return -EEXIST;
1318
1319         r = fd;
1320         fd = -1;
1321
1322         return r;
1323 }
1324
1325 static int socket_symlink(Socket *s) {
1326         const char *p;
1327         char **i;
1328         int r;
1329
1330         assert(s);
1331
1332         p = socket_find_symlink_target(s);
1333         if (!p)
1334                 return 0;
1335
1336         STRV_FOREACH(i, s->symlinks) {
1337                 (void) mkdir_parents_label(*i, s->directory_mode);
1338
1339                 r = symlink_idempotent(p, *i);
1340
1341                 if (r == -EEXIST && s->remove_on_stop) {
1342                         /* If there's already something where we want to create the symlink, and the destructive
1343                          * RemoveOnStop= mode is set, then we might as well try to remove what already exists and try
1344                          * again. */
1345
1346                         if (unlink(*i) >= 0)
1347                                 r = symlink_idempotent(p, *i);
1348                 }
1349
1350                 if (r < 0)
1351                         log_unit_warning_errno(UNIT(s), r, "Failed to create symlink %s → %s, ignoring: %m", p, *i);
1352         }
1353
1354         return 0;
1355 }
1356
1357 static int usbffs_write_descs(int fd, Service *s) {
1358         int r;
1359
1360         if (!s->usb_function_descriptors || !s->usb_function_strings)
1361                 return -EINVAL;
1362
1363         r = copy_file_fd(s->usb_function_descriptors, fd, 0);
1364         if (r < 0)
1365                 return r;
1366
1367         return copy_file_fd(s->usb_function_strings, fd, 0);
1368 }
1369
1370 static int usbffs_select_ep(const struct dirent *d) {
1371         return d->d_name[0] != '.' && !streq(d->d_name, "ep0");
1372 }
1373
1374 static int usbffs_dispatch_eps(SocketPort *p) {
1375         _cleanup_free_ struct dirent **ent = NULL;
1376         int r, i, n, k;
1377
1378         r = scandir(p->path, &ent, usbffs_select_ep, alphasort);
1379         if (r < 0)
1380                 return -errno;
1381
1382         n = r;
1383         p->auxiliary_fds = new(int, n);
1384         if (!p->auxiliary_fds)
1385                 return -ENOMEM;
1386
1387         p->n_auxiliary_fds = n;
1388
1389         k = 0;
1390         for (i = 0; i < n; ++i) {
1391                 _cleanup_free_ char *ep = NULL;
1392
1393                 ep = path_make_absolute(ent[i]->d_name, p->path);
1394                 if (!ep)
1395                         return -ENOMEM;
1396
1397                 path_kill_slashes(ep);
1398
1399                 r = usbffs_address_create(ep);
1400                 if (r < 0)
1401                         goto fail;
1402
1403                 p->auxiliary_fds[k] = r;
1404
1405                 ++k;
1406                 free(ent[i]);
1407         }
1408
1409         return r;
1410
1411 fail:
1412         close_many(p->auxiliary_fds, k);
1413         p->auxiliary_fds = mfree(p->auxiliary_fds);
1414         p->n_auxiliary_fds = 0;
1415
1416         return r;
1417 }
1418
1419 static int socket_determine_selinux_label(Socket *s, char **ret) {
1420         ExecCommand *c;
1421         int r;
1422
1423         assert(s);
1424         assert(ret);
1425
1426         if (s->selinux_context_from_net) {
1427                 /* If this is requested, get label from the network label */
1428
1429                 r = mac_selinux_get_our_label(ret);
1430                 if (r == -EOPNOTSUPP)
1431                         goto no_label;
1432
1433         } else {
1434                 /* Otherwise, get it from the executable we are about to start */
1435                 r = socket_instantiate_service(s);
1436                 if (r < 0)
1437                         return r;
1438
1439                 if (!UNIT_ISSET(s->service))
1440                         goto no_label;
1441
1442                 c = SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START];
1443                 if (!c)
1444                         goto no_label;
1445
1446                 r = mac_selinux_get_create_label_from_exe(c->path, ret);
1447                 if (IN_SET(r, -EPERM, -EOPNOTSUPP))
1448                         goto no_label;
1449         }
1450
1451         return r;
1452
1453 no_label:
1454         *ret = NULL;
1455         return 0;
1456 }
1457
1458 static int socket_address_listen_do(
1459                 Socket *s,
1460                 const SocketAddress *address,
1461                 const char *label) {
1462
1463         assert(s);
1464         assert(address);
1465
1466         return socket_address_listen(
1467                         address,
1468                         SOCK_CLOEXEC|SOCK_NONBLOCK,
1469                         s->backlog,
1470                         s->bind_ipv6_only,
1471                         s->bind_to_device,
1472                         s->reuse_port,
1473                         s->free_bind,
1474                         s->transparent,
1475                         s->directory_mode,
1476                         s->socket_mode,
1477                         label);
1478 }
1479
1480 static int socket_address_listen_in_cgroup(
1481                 Socket *s,
1482                 const SocketAddress *address,
1483                 const char *label) {
1484
1485         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1486         int fd, r;
1487         pid_t pid;
1488
1489         assert(s);
1490         assert(address);
1491
1492         /* This is a wrapper around socket_address_listen(), that forks off a helper process inside the socket's cgroup
1493          * in which the socket is actually created. This way we ensure the socket is actually properly attached to the
1494          * unit's cgroup for the purpose of BPF filtering and such. */
1495
1496         if (!IN_SET(address->sockaddr.sa.sa_family, AF_INET, AF_INET6))
1497                 goto shortcut; /* BPF filtering only applies to IPv4 + IPv6, shortcut things for other protocols */
1498
1499         r = bpf_firewall_supported();
1500         if (r < 0)
1501                 return r;
1502         if (r == 0) /* If BPF firewalling isn't supported anyway — there's no point in this forking complexity */
1503                 goto shortcut;
1504
1505         if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
1506                 return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
1507
1508         r = unit_fork_helper_process(UNIT(s), &pid);
1509         if (r < 0)
1510                 return log_unit_error_errno(UNIT(s), r, "Failed to fork off listener stub process: %m");
1511         if (r == 0) {
1512                 /* Child */
1513
1514                 pair[0] = safe_close(pair[0]);
1515
1516                 fd = socket_address_listen_do(s, address, label);
1517                 if (fd < 0) {
1518                         log_unit_error_errno(UNIT(s), fd, "Failed to create listening socket: %m");
1519                         _exit(EXIT_FAILURE);
1520                 }
1521
1522                 r = send_one_fd(pair[1], fd, 0);
1523                 if (r < 0) {
1524                         log_unit_error_errno(UNIT(s), r, "Failed to send listening socket to parent: %m");
1525                         _exit(EXIT_FAILURE);
1526                 }
1527
1528                 _exit(EXIT_SUCCESS);
1529         }
1530
1531         pair[1] = safe_close(pair[1]);
1532         fd = receive_one_fd(pair[0], 0);
1533
1534         /* We synchronously wait for the helper, as it shouldn't be slow */
1535         r = wait_for_terminate_and_warn("listen-cgroup-helper", pid, false);
1536         if (r < 0) {
1537                 safe_close(fd);
1538                 return r;
1539         }
1540
1541         if (fd < 0)
1542                 return log_unit_error_errno(UNIT(s), fd, "Failed to receive listening socket: %m");
1543
1544         return fd;
1545
1546 shortcut:
1547         fd = socket_address_listen_do(s, address, label);
1548         if (fd < 0)
1549                 return log_error_errno(fd, "Failed to create listening socket: %m");
1550
1551         return fd;
1552 }
1553
1554 static int socket_open_fds(Socket *s) {
1555         _cleanup_(mac_selinux_freep) char *label = NULL;
1556         bool know_label = false;
1557         SocketPort *p;
1558         int r;
1559
1560         assert(s);
1561
1562         LIST_FOREACH(port, p, s->ports) {
1563
1564                 if (p->fd >= 0)
1565                         continue;
1566
1567                 switch (p->type) {
1568
1569                 case SOCKET_SOCKET:
1570
1571                         if (!know_label) {
1572                                 /* Figure out label, if we don't it know yet. We do it once, for the first socket where
1573                                  * we need this and remember it for the rest. */
1574
1575                                 r = socket_determine_selinux_label(s, &label);
1576                                 if (r < 0)
1577                                         goto rollback;
1578
1579                                 know_label = true;
1580                         }
1581
1582                         /* Apply the socket protocol */
1583                         switch (p->address.type) {
1584
1585                         case SOCK_STREAM:
1586                         case SOCK_SEQPACKET:
1587                                 if (s->socket_protocol == IPPROTO_SCTP)
1588                                         p->address.protocol = s->socket_protocol;
1589                                 break;
1590
1591                         case SOCK_DGRAM:
1592                                 if (s->socket_protocol == IPPROTO_UDPLITE)
1593                                         p->address.protocol = s->socket_protocol;
1594                                 break;
1595                         }
1596
1597                         r = socket_address_listen_in_cgroup(s, &p->address, label);
1598                         if (r < 0)
1599                                 goto rollback;
1600
1601                         p->fd = r;
1602                         socket_apply_socket_options(s, p->fd);
1603                         socket_symlink(s);
1604                         break;
1605
1606                 case SOCKET_SPECIAL:
1607
1608                         p->fd = special_address_create(p->path, s->writable);
1609                         if (p->fd < 0) {
1610                                 r = p->fd;
1611                                 goto rollback;
1612                         }
1613                         break;
1614
1615                 case SOCKET_FIFO:
1616
1617                         p->fd = fifo_address_create(
1618                                         p->path,
1619                                         s->directory_mode,
1620                                         s->socket_mode);
1621                         if (p->fd < 0) {
1622                                 r = p->fd;
1623                                 goto rollback;
1624                         }
1625
1626                         socket_apply_fifo_options(s, p->fd);
1627                         socket_symlink(s);
1628                         break;
1629
1630                 case SOCKET_MQUEUE:
1631
1632                         p->fd = mq_address_create(
1633                                         p->path,
1634                                         s->socket_mode,
1635                                         s->mq_maxmsg,
1636                                         s->mq_msgsize);
1637                         if (p->fd < 0) {
1638                                 r = p->fd;
1639                                 goto rollback;
1640                         }
1641                         break;
1642
1643                 case SOCKET_USB_FUNCTION: {
1644                         _cleanup_free_ char *ep = NULL;
1645
1646                         ep = path_make_absolute("ep0", p->path);
1647
1648                         p->fd = usbffs_address_create(ep);
1649                         if (p->fd < 0) {
1650                                 r = p->fd;
1651                                 goto rollback;
1652                         }
1653
1654                         r = usbffs_write_descs(p->fd, SERVICE(UNIT_DEREF(s->service)));
1655                         if (r < 0)
1656                                 goto rollback;
1657
1658                         r = usbffs_dispatch_eps(p);
1659                         if (r < 0)
1660                                 goto rollback;
1661
1662                         break;
1663                 }
1664                 default:
1665                         assert_not_reached("Unknown port type");
1666                 }
1667         }
1668
1669         return 0;
1670
1671 rollback:
1672         socket_close_fds(s);
1673         return r;
1674 }
1675
1676 static void socket_unwatch_fds(Socket *s) {
1677         SocketPort *p;
1678         int r;
1679
1680         assert(s);
1681
1682         LIST_FOREACH(port, p, s->ports) {
1683                 if (p->fd < 0)
1684                         continue;
1685
1686                 if (!p->event_source)
1687                         continue;
1688
1689                 r = sd_event_source_set_enabled(p->event_source, SD_EVENT_OFF);
1690                 if (r < 0)
1691                         log_unit_debug_errno(UNIT(s), r, "Failed to disable event source: %m");
1692         }
1693 }
1694
1695 static int socket_watch_fds(Socket *s) {
1696         SocketPort *p;
1697         int r;
1698
1699         assert(s);
1700
1701         LIST_FOREACH(port, p, s->ports) {
1702                 if (p->fd < 0)
1703                         continue;
1704
1705                 if (p->event_source) {
1706                         r = sd_event_source_set_enabled(p->event_source, SD_EVENT_ON);
1707                         if (r < 0)
1708                                 goto fail;
1709                 } else {
1710                         r = sd_event_add_io(UNIT(s)->manager->event, &p->event_source, p->fd, EPOLLIN, socket_dispatch_io, p);
1711                         if (r < 0)
1712                                 goto fail;
1713
1714                         (void) sd_event_source_set_description(p->event_source, "socket-port-io");
1715                 }
1716         }
1717
1718         return 0;
1719
1720 fail:
1721         log_unit_warning_errno(UNIT(s), r, "Failed to watch listening fds: %m");
1722         socket_unwatch_fds(s);
1723         return r;
1724 }
1725
1726 enum {
1727         SOCKET_OPEN_NONE,
1728         SOCKET_OPEN_SOME,
1729         SOCKET_OPEN_ALL,
1730 };
1731
1732 static int socket_check_open(Socket *s) {
1733         bool have_open = false, have_closed = false;
1734         SocketPort *p;
1735
1736         assert(s);
1737
1738         LIST_FOREACH(port, p, s->ports) {
1739                 if (p->fd < 0)
1740                         have_closed = true;
1741                 else
1742                         have_open = true;
1743
1744                 if (have_open && have_closed)
1745                         return SOCKET_OPEN_SOME;
1746         }
1747
1748         if (have_open)
1749                 return SOCKET_OPEN_ALL;
1750
1751         return SOCKET_OPEN_NONE;
1752 }
1753
1754 static void socket_set_state(Socket *s, SocketState state) {
1755         SocketState old_state;
1756         assert(s);
1757
1758         old_state = s->state;
1759         s->state = state;
1760
1761         if (!IN_SET(state,
1762                     SOCKET_START_PRE,
1763                     SOCKET_START_CHOWN,
1764                     SOCKET_START_POST,
1765                     SOCKET_STOP_PRE,
1766                     SOCKET_STOP_PRE_SIGTERM,
1767                     SOCKET_STOP_PRE_SIGKILL,
1768                     SOCKET_STOP_POST,
1769                     SOCKET_FINAL_SIGTERM,
1770                     SOCKET_FINAL_SIGKILL)) {
1771
1772                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1773                 socket_unwatch_control_pid(s);
1774                 s->control_command = NULL;
1775                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1776         }
1777
1778         if (state != SOCKET_LISTENING)
1779                 socket_unwatch_fds(s);
1780
1781         if (!IN_SET(state,
1782                     SOCKET_START_CHOWN,
1783                     SOCKET_START_POST,
1784                     SOCKET_LISTENING,
1785                     SOCKET_RUNNING,
1786                     SOCKET_STOP_PRE,
1787                     SOCKET_STOP_PRE_SIGTERM,
1788                     SOCKET_STOP_PRE_SIGKILL))
1789                 socket_close_fds(s);
1790
1791         if (state != old_state)
1792                 log_unit_debug(UNIT(s), "Changed %s -> %s", socket_state_to_string(old_state), socket_state_to_string(state));
1793
1794         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1795 }
1796
1797 static int socket_coldplug(Unit *u) {
1798         Socket *s = SOCKET(u);
1799         int r;
1800
1801         assert(s);
1802         assert(s->state == SOCKET_DEAD);
1803
1804         if (s->deserialized_state == s->state)
1805                 return 0;
1806
1807         if (s->control_pid > 0 &&
1808             pid_is_unwaited(s->control_pid) &&
1809             IN_SET(s->deserialized_state,
1810                    SOCKET_START_PRE,
1811                    SOCKET_START_CHOWN,
1812                    SOCKET_START_POST,
1813                    SOCKET_STOP_PRE,
1814                    SOCKET_STOP_PRE_SIGTERM,
1815                    SOCKET_STOP_PRE_SIGKILL,
1816                    SOCKET_STOP_POST,
1817                    SOCKET_FINAL_SIGTERM,
1818                    SOCKET_FINAL_SIGKILL)) {
1819
1820                 r = unit_watch_pid(UNIT(s), s->control_pid);
1821                 if (r < 0)
1822                         return r;
1823
1824                 r = socket_arm_timer(s, usec_add(u->state_change_timestamp.monotonic, s->timeout_usec));
1825                 if (r < 0)
1826                         return r;
1827         }
1828
1829         if (IN_SET(s->deserialized_state,
1830                    SOCKET_START_CHOWN,
1831                    SOCKET_START_POST,
1832                    SOCKET_LISTENING,
1833                    SOCKET_RUNNING)) {
1834
1835                 /* Originally, we used to simply reopen all sockets here that we didn't have file descriptors
1836                  * for. However, this is problematic, as we won't traverse throught the SOCKET_START_CHOWN state for
1837                  * them, and thus the UID/GID wouldn't be right. Hence, instead simply check if we have all fds open,
1838                  * and if there's a mismatch, warn loudly. */
1839
1840                 r = socket_check_open(s);
1841                 if (r == SOCKET_OPEN_NONE)
1842                         log_unit_warning(UNIT(s),
1843                                          "Socket unit configuration has changed while unit has been running, "
1844                                          "no open socket file descriptor left. "
1845                                          "The socket unit is not functional until restarted.");
1846                 else if (r == SOCKET_OPEN_SOME)
1847                         log_unit_warning(UNIT(s),
1848                                          "Socket unit configuration has changed while unit has been running, "
1849                                          "and some socket file descriptors have not been opened yet. "
1850                                          "The socket unit is not fully functional until restarted.");
1851         }
1852
1853         if (s->deserialized_state == SOCKET_LISTENING) {
1854                 r = socket_watch_fds(s);
1855                 if (r < 0)
1856                         return r;
1857         }
1858
1859         if (!IN_SET(s->deserialized_state, SOCKET_DEAD, SOCKET_FAILED))
1860                 (void) unit_setup_dynamic_creds(u);
1861
1862         socket_set_state(s, s->deserialized_state);
1863         return 0;
1864 }
1865
1866 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1867         pid_t pid;
1868         int r;
1869         ExecParameters exec_params = {
1870                 .flags      = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
1871                 .stdin_fd   = -1,
1872                 .stdout_fd  = -1,
1873                 .stderr_fd  = -1,
1874         };
1875
1876         assert(s);
1877         assert(c);
1878         assert(_pid);
1879
1880         (void) unit_realize_cgroup(UNIT(s));
1881         if (s->reset_accounting) {
1882                 (void) unit_reset_cpu_accounting(UNIT(s));
1883                 (void) unit_reset_ip_accounting(UNIT(s));
1884                 s->reset_accounting = false;
1885         }
1886
1887         unit_export_state_files(UNIT(s));
1888
1889         r = unit_setup_exec_runtime(UNIT(s));
1890         if (r < 0)
1891                 return r;
1892
1893         r = unit_setup_dynamic_creds(UNIT(s));
1894         if (r < 0)
1895                 return r;
1896
1897         r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
1898         if (r < 0)
1899                 return r;
1900
1901         manager_set_exec_params(UNIT(s)->manager, &exec_params);
1902         unit_set_exec_params(UNIT(s), &exec_params);
1903
1904         exec_params.argv = c->argv;
1905
1906         r = exec_spawn(UNIT(s),
1907                        c,
1908                        &s->exec_context,
1909                        &exec_params,
1910                        s->exec_runtime,
1911                        &s->dynamic_creds,
1912                        &pid);
1913         if (r < 0)
1914                 return r;
1915
1916         r = unit_watch_pid(UNIT(s), pid);
1917         if (r < 0)
1918                 /* FIXME: we need to do something here */
1919                 return r;
1920
1921         *_pid = pid;
1922
1923         return 0;
1924 }
1925
1926 static int socket_chown(Socket *s, pid_t *_pid) {
1927         pid_t pid;
1928         int r;
1929
1930         r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
1931         if (r < 0)
1932                 goto fail;
1933
1934         /* We have to resolve the user names out-of-process, hence
1935          * let's fork here. It's messy, but well, what can we do? */
1936
1937         r = unit_fork_helper_process(UNIT(s), &pid);
1938         if (r < 0)
1939                 return r;
1940         if (r == 0) {
1941                 uid_t uid = UID_INVALID;
1942                 gid_t gid = GID_INVALID;
1943                 SocketPort *p;
1944
1945                 /* Child */
1946
1947                 if (!isempty(s->user)) {
1948                         const char *user = s->user;
1949
1950                         r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1951                         if (r < 0) {
1952                                 log_unit_error_errno(UNIT(s), r, "Failed to resolve user %s: %m", user);
1953                                 _exit(EXIT_USER);
1954                         }
1955                 }
1956
1957                 if (!isempty(s->group)) {
1958                         const char *group = s->group;
1959
1960                         r = get_group_creds(&group, &gid);
1961                         if (r < 0) {
1962                                 log_unit_error_errno(UNIT(s), r, "Failed to resolve group %s: %m", group);
1963                                 _exit(EXIT_GROUP);
1964                         }
1965                 }
1966
1967                 LIST_FOREACH(port, p, s->ports) {
1968                         const char *path = NULL;
1969
1970                         if (p->type == SOCKET_SOCKET)
1971                                 path = socket_address_get_path(&p->address);
1972                         else if (p->type == SOCKET_FIFO)
1973                                 path = p->path;
1974
1975                         if (!path)
1976                                 continue;
1977
1978                         if (chown(path, uid, gid) < 0) {
1979                                 log_unit_error_errno(UNIT(s), errno, "Failed to chown(): %m");
1980                                 _exit(EXIT_CHOWN);
1981                         }
1982                 }
1983
1984                 _exit(EXIT_SUCCESS);
1985         }
1986
1987         r = unit_watch_pid(UNIT(s), pid);
1988         if (r < 0)
1989                 goto fail;
1990
1991         *_pid = pid;
1992         return 0;
1993
1994 fail:
1995         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1996         return r;
1997 }
1998
1999 static void socket_enter_dead(Socket *s, SocketResult f) {
2000         assert(s);
2001
2002         if (s->result == SOCKET_SUCCESS)
2003                 s->result = f;
2004
2005         if (s->result != SOCKET_SUCCESS)
2006                 log_unit_warning(UNIT(s), "Failed with result '%s'.", socket_result_to_string(s->result));
2007
2008         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
2009
2010         exec_runtime_destroy(s->exec_runtime);
2011         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
2012
2013         exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
2014
2015         unit_unref_uid_gid(UNIT(s), true);
2016
2017         dynamic_creds_destroy(&s->dynamic_creds);
2018 }
2019
2020 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
2021
2022 static void socket_enter_stop_post(Socket *s, SocketResult f) {
2023         int r;
2024         assert(s);
2025
2026         if (s->result == SOCKET_SUCCESS)
2027                 s->result = f;
2028
2029         socket_unwatch_control_pid(s);
2030         s->control_command_id = SOCKET_EXEC_STOP_POST;
2031         s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST];
2032
2033         if (s->control_command) {
2034                 r = socket_spawn(s, s->control_command, &s->control_pid);
2035                 if (r < 0)
2036                         goto fail;
2037
2038                 socket_set_state(s, SOCKET_STOP_POST);
2039         } else
2040                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
2041
2042         return;
2043
2044 fail:
2045         log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-post' task: %m");
2046         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
2047 }
2048
2049 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
2050         int r;
2051
2052         assert(s);
2053
2054         if (s->result == SOCKET_SUCCESS)
2055                 s->result = f;
2056
2057         r = unit_kill_context(
2058                         UNIT(s),
2059                         &s->kill_context,
2060                         !IN_SET(state, SOCKET_STOP_PRE_SIGTERM, SOCKET_FINAL_SIGTERM) ?
2061                         KILL_KILL : KILL_TERMINATE,
2062                         -1,
2063                         s->control_pid,
2064                         false);
2065         if (r < 0)
2066                 goto fail;
2067
2068         if (r > 0) {
2069                 r = socket_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
2070                 if (r < 0)
2071                         goto fail;
2072
2073                 socket_set_state(s, state);
2074         } else if (state == SOCKET_STOP_PRE_SIGTERM)
2075                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
2076         else if (state == SOCKET_STOP_PRE_SIGKILL)
2077                 socket_enter_stop_post(s, SOCKET_SUCCESS);
2078         else if (state == SOCKET_FINAL_SIGTERM)
2079                 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
2080         else
2081                 socket_enter_dead(s, SOCKET_SUCCESS);
2082
2083         return;
2084
2085 fail:
2086         log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
2087
2088         if (IN_SET(state, SOCKET_STOP_PRE_SIGTERM, SOCKET_STOP_PRE_SIGKILL))
2089                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
2090         else
2091                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
2092 }
2093
2094 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
2095         int r;
2096         assert(s);
2097
2098         if (s->result == SOCKET_SUCCESS)
2099                 s->result = f;
2100
2101         socket_unwatch_control_pid(s);
2102         s->control_command_id = SOCKET_EXEC_STOP_PRE;
2103         s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE];
2104
2105         if (s->control_command) {
2106                 r = socket_spawn(s, s->control_command, &s->control_pid);
2107                 if (r < 0)
2108                         goto fail;
2109
2110                 socket_set_state(s, SOCKET_STOP_PRE);
2111         } else
2112                 socket_enter_stop_post(s, SOCKET_SUCCESS);
2113
2114         return;
2115
2116 fail:
2117         log_unit_warning_errno(UNIT(s), r, "Failed to run 'stop-pre' task: %m");
2118         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
2119 }
2120
2121 static void socket_enter_listening(Socket *s) {
2122         int r;
2123         assert(s);
2124
2125         r = socket_watch_fds(s);
2126         if (r < 0) {
2127                 log_unit_warning_errno(UNIT(s), r, "Failed to watch sockets: %m");
2128                 goto fail;
2129         }
2130
2131         socket_set_state(s, SOCKET_LISTENING);
2132         return;
2133
2134 fail:
2135         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2136 }
2137
2138 static void socket_enter_start_post(Socket *s) {
2139         int r;
2140         assert(s);
2141
2142         socket_unwatch_control_pid(s);
2143         s->control_command_id = SOCKET_EXEC_START_POST;
2144         s->control_command = s->exec_command[SOCKET_EXEC_START_POST];
2145
2146         if (s->control_command) {
2147                 r = socket_spawn(s, s->control_command, &s->control_pid);
2148                 if (r < 0) {
2149                         log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-post' task: %m");
2150                         goto fail;
2151                 }
2152
2153                 socket_set_state(s, SOCKET_START_POST);
2154         } else
2155                 socket_enter_listening(s);
2156
2157         return;
2158
2159 fail:
2160         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2161 }
2162
2163 static void socket_enter_start_chown(Socket *s) {
2164         int r;
2165
2166         assert(s);
2167
2168         r = socket_open_fds(s);
2169         if (r < 0) {
2170                 log_unit_warning_errno(UNIT(s), r, "Failed to listen on sockets: %m");
2171                 goto fail;
2172         }
2173
2174         if (!isempty(s->user) || !isempty(s->group)) {
2175
2176                 socket_unwatch_control_pid(s);
2177                 s->control_command_id = SOCKET_EXEC_START_CHOWN;
2178                 s->control_command = NULL;
2179
2180                 r = socket_chown(s, &s->control_pid);
2181                 if (r < 0) {
2182                         log_unit_warning_errno(UNIT(s), r, "Failed to fork 'start-chown' task: %m");
2183                         goto fail;
2184                 }
2185
2186                 socket_set_state(s, SOCKET_START_CHOWN);
2187         } else
2188                 socket_enter_start_post(s);
2189
2190         return;
2191
2192 fail:
2193         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2194 }
2195
2196 static void socket_enter_start_pre(Socket *s) {
2197         int r;
2198         assert(s);
2199
2200         socket_unwatch_control_pid(s);
2201         s->control_command_id = SOCKET_EXEC_START_PRE;
2202         s->control_command = s->exec_command[SOCKET_EXEC_START_PRE];
2203
2204         if (s->control_command) {
2205                 r = socket_spawn(s, s->control_command, &s->control_pid);
2206                 if (r < 0) {
2207                         log_unit_warning_errno(UNIT(s), r, "Failed to run 'start-pre' task: %m");
2208                         goto fail;
2209                 }
2210
2211                 socket_set_state(s, SOCKET_START_PRE);
2212         } else
2213                 socket_enter_start_chown(s);
2214
2215         return;
2216
2217 fail:
2218         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
2219 }
2220
2221 static void flush_ports(Socket *s) {
2222         SocketPort *p;
2223
2224         /* Flush all incoming traffic, regardless if actual bytes or new connections, so that this socket isn't busy
2225          * anymore */
2226
2227         LIST_FOREACH(port, p, s->ports) {
2228                 if (p->fd < 0)
2229                         continue;
2230
2231                 (void) flush_accept(p->fd);
2232                 (void) flush_fd(p->fd);
2233         }
2234 }
2235
2236 static void socket_enter_running(Socket *s, int cfd) {
2237         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2238         int r;
2239
2240         /* Note that this call takes possession of the connection fd passed. It either has to assign it somewhere or
2241          * close it. */
2242
2243         assert(s);
2244
2245         /* We don't take connections anymore if we are supposed to shut down anyway */
2246         if (unit_stop_pending(UNIT(s))) {
2247
2248                 log_unit_debug(UNIT(s), "Suppressing connection request since unit stop is scheduled.");
2249
2250                 if (cfd >= 0)
2251                         cfd = safe_close(cfd);
2252                 else
2253                         flush_ports(s);
2254
2255                 return;
2256         }
2257
2258         if (!ratelimit_test(&s->trigger_limit)) {
2259                 safe_close(cfd);
2260                 log_unit_warning(UNIT(s), "Trigger limit hit, refusing further activation.");
2261                 socket_enter_stop_pre(s, SOCKET_FAILURE_TRIGGER_LIMIT_HIT);
2262                 return;
2263         }
2264
2265         if (cfd < 0) {
2266                 bool pending = false;
2267                 Unit *other;
2268                 Iterator i;
2269                 void *v;
2270
2271                 /* If there's already a start pending don't bother to
2272                  * do anything */
2273                 HASHMAP_FOREACH_KEY(v, other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
2274                         if (unit_active_or_pending(other)) {
2275                                 pending = true;
2276                                 break;
2277                         }
2278
2279                 if (!pending) {
2280                         if (!UNIT_ISSET(s->service)) {
2281                                 log_unit_error(UNIT(s), "Service to activate vanished, refusing activation.");
2282                                 r = -ENOENT;
2283                                 goto fail;
2284                         }
2285
2286                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, &error, NULL);
2287                         if (r < 0)
2288                                 goto fail;
2289                 }
2290
2291                 socket_set_state(s, SOCKET_RUNNING);
2292         } else {
2293                 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
2294                 _cleanup_(socket_peer_unrefp) SocketPeer *p = NULL;
2295                 Service *service;
2296
2297                 if (s->n_connections >= s->max_connections) {
2298                         log_unit_warning(UNIT(s), "Too many incoming connections (%u), dropping connection.",
2299                                          s->n_connections);
2300                         safe_close(cfd);
2301                         return;
2302                 }
2303
2304                 if (s->max_connections_per_source > 0) {
2305                         r = socket_acquire_peer(s, cfd, &p);
2306                         if (r < 0) {
2307                                 safe_close(cfd);
2308                                 return;
2309                         } else if (r > 0 && p->n_ref > s->max_connections_per_source) {
2310                                 _cleanup_free_ char *t = NULL;
2311
2312                                 (void) sockaddr_pretty(&p->peer.sa, p->peer_salen, true, false, &t);
2313
2314                                 log_unit_warning(UNIT(s),
2315                                                  "Too many incoming connections (%u) from source %s, dropping connection.",
2316                                                  p->n_ref, strnull(t));
2317                                 safe_close(cfd);
2318                                 return;
2319                         }
2320                 }
2321
2322                 r = socket_instantiate_service(s);
2323                 if (r < 0)
2324                         goto fail;
2325
2326                 r = instance_from_socket(cfd, s->n_accepted, &instance);
2327                 if (r < 0) {
2328                         if (r != -ENOTCONN)
2329                                 goto fail;
2330
2331                         /* ENOTCONN is legitimate if TCP RST was received.
2332                          * This connection is over, but the socket unit lives on. */
2333                         log_unit_debug(UNIT(s), "Got ENOTCONN on incoming socket, assuming aborted connection attempt, ignoring.");
2334                         safe_close(cfd);
2335                         return;
2336                 }
2337
2338                 r = unit_name_to_prefix(UNIT(s)->id, &prefix);
2339                 if (r < 0)
2340                         goto fail;
2341
2342                 r = unit_name_build(prefix, instance, ".service", &name);
2343                 if (r < 0)
2344                         goto fail;
2345
2346                 r = unit_add_name(UNIT_DEREF(s->service), name);
2347                 if (r < 0)
2348                         goto fail;
2349
2350                 service = SERVICE(UNIT_DEREF(s->service));
2351                 unit_ref_unset(&s->service);
2352
2353                 s->n_accepted++;
2354                 unit_choose_id(UNIT(service), name);
2355
2356                 r = service_set_socket_fd(service, cfd, s, s->selinux_context_from_net);
2357                 if (r < 0)
2358                         goto fail;
2359
2360                 cfd = -1; /* We passed ownership of the fd to the service now. Forget it here. */
2361                 s->n_connections++;
2362
2363                 service->peer = p; /* Pass ownership of the peer reference */
2364                 p = NULL;
2365
2366                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, &error, NULL);
2367                 if (r < 0) {
2368                         /* We failed to activate the new service, but it still exists. Let's make sure the service
2369                          * closes and forgets the connection fd again, immediately. */
2370                         service_close_socket_fd(service);
2371                         goto fail;
2372                 }
2373
2374                 /* Notify clients about changed counters */
2375                 unit_add_to_dbus_queue(UNIT(s));
2376         }
2377
2378         return;
2379
2380 fail:
2381         log_unit_warning(UNIT(s), "Failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
2382                          cfd >= 0 ? "template" : "non-template",
2383                          bus_error_message(&error, r));
2384
2385         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2386         safe_close(cfd);
2387 }
2388
2389 static void socket_run_next(Socket *s) {
2390         int r;
2391
2392         assert(s);
2393         assert(s->control_command);
2394         assert(s->control_command->command_next);
2395
2396         socket_unwatch_control_pid(s);
2397
2398         s->control_command = s->control_command->command_next;
2399
2400         r = socket_spawn(s, s->control_command, &s->control_pid);
2401         if (r < 0)
2402                 goto fail;
2403
2404         return;
2405
2406 fail:
2407         log_unit_warning_errno(UNIT(s), r, "Failed to run next task: %m");
2408
2409         if (s->state == SOCKET_START_POST)
2410                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2411         else if (s->state == SOCKET_STOP_POST)
2412                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
2413         else
2414                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
2415 }
2416
2417 static int socket_start(Unit *u) {
2418         Socket *s = SOCKET(u);
2419         int r;
2420
2421         assert(s);
2422
2423         /* We cannot fulfill this request right now, try again later
2424          * please! */
2425         if (IN_SET(s->state,
2426                    SOCKET_STOP_PRE,
2427                    SOCKET_STOP_PRE_SIGKILL,
2428                    SOCKET_STOP_PRE_SIGTERM,
2429                    SOCKET_STOP_POST,
2430                    SOCKET_FINAL_SIGTERM,
2431                    SOCKET_FINAL_SIGKILL))
2432                 return -EAGAIN;
2433
2434         /* Already on it! */
2435         if (IN_SET(s->state,
2436                    SOCKET_START_PRE,
2437                    SOCKET_START_CHOWN,
2438                    SOCKET_START_POST))
2439                 return 0;
2440
2441         /* Cannot run this without the service being around */
2442         if (UNIT_ISSET(s->service)) {
2443                 Service *service;
2444
2445                 service = SERVICE(UNIT_DEREF(s->service));
2446
2447                 if (UNIT(service)->load_state != UNIT_LOADED) {
2448                         log_unit_error(u, "Socket service %s not loaded, refusing.", UNIT(service)->id);
2449                         return -ENOENT;
2450                 }
2451
2452                 /* If the service is already active we cannot start the
2453                  * socket */
2454                 if (!IN_SET(service->state, SERVICE_DEAD, SERVICE_FAILED, SERVICE_AUTO_RESTART)) {
2455                         log_unit_error(u, "Socket service %s already active, refusing.", UNIT(service)->id);
2456                         return -EBUSY;
2457                 }
2458         }
2459
2460         assert(IN_SET(s->state, SOCKET_DEAD, SOCKET_FAILED));
2461
2462         r = unit_start_limit_test(u);
2463         if (r < 0) {
2464                 socket_enter_dead(s, SOCKET_FAILURE_START_LIMIT_HIT);
2465                 return r;
2466         }
2467
2468         r = unit_acquire_invocation_id(u);
2469         if (r < 0)
2470                 return r;
2471
2472         s->result = SOCKET_SUCCESS;
2473         s->reset_accounting = true;
2474
2475         socket_enter_start_pre(s);
2476         return 1;
2477 }
2478
2479 static int socket_stop(Unit *u) {
2480         Socket *s = SOCKET(u);
2481
2482         assert(s);
2483
2484         /* Already on it */
2485         if (IN_SET(s->state,
2486                    SOCKET_STOP_PRE,
2487                    SOCKET_STOP_PRE_SIGTERM,
2488                    SOCKET_STOP_PRE_SIGKILL,
2489                    SOCKET_STOP_POST,
2490                    SOCKET_FINAL_SIGTERM,
2491                    SOCKET_FINAL_SIGKILL))
2492                 return 0;
2493
2494         /* If there's already something running we go directly into
2495          * kill mode. */
2496         if (IN_SET(s->state,
2497                    SOCKET_START_PRE,
2498                    SOCKET_START_CHOWN,
2499                    SOCKET_START_POST)) {
2500                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
2501                 return -EAGAIN;
2502         }
2503
2504         assert(IN_SET(s->state, SOCKET_LISTENING, SOCKET_RUNNING));
2505
2506         socket_enter_stop_pre(s, SOCKET_SUCCESS);
2507         return 1;
2508 }
2509
2510 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
2511         Socket *s = SOCKET(u);
2512         SocketPort *p;
2513         int r;
2514
2515         assert(u);
2516         assert(f);
2517         assert(fds);
2518
2519         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
2520         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
2521         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
2522
2523         if (s->control_pid > 0)
2524                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
2525
2526         if (s->control_command_id >= 0)
2527                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
2528
2529         LIST_FOREACH(port, p, s->ports) {
2530                 int copy;
2531
2532                 if (p->fd < 0)
2533                         continue;
2534
2535                 copy = fdset_put_dup(fds, p->fd);
2536                 if (copy < 0)
2537                         return copy;
2538
2539                 if (p->type == SOCKET_SOCKET) {
2540                         _cleanup_free_ char *t = NULL;
2541
2542                         r = socket_address_print(&p->address, &t);
2543                         if (r < 0)
2544                                 return r;
2545
2546                         if (socket_address_family(&p->address) == AF_NETLINK)
2547                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
2548                         else
2549                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
2550
2551                 } else if (p->type == SOCKET_SPECIAL)
2552                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
2553                 else if (p->type == SOCKET_MQUEUE)
2554                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
2555                 else if (p->type == SOCKET_USB_FUNCTION)
2556                         unit_serialize_item_format(u, f, "ffs", "%i %s", copy, p->path);
2557                 else {
2558                         assert(p->type == SOCKET_FIFO);
2559                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
2560                 }
2561         }
2562
2563         return 0;
2564 }
2565
2566 static void socket_port_take_fd(SocketPort *p, FDSet *fds, int fd) {
2567         safe_close(p->fd);
2568         p->fd = fdset_remove(fds, fd);
2569 }
2570
2571 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
2572         Socket *s = SOCKET(u);
2573
2574         assert(u);
2575         assert(key);
2576         assert(value);
2577
2578         if (streq(key, "state")) {
2579                 SocketState state;
2580
2581                 state = socket_state_from_string(value);
2582                 if (state < 0)
2583                         log_unit_debug(u, "Failed to parse state value: %s", value);
2584                 else
2585                         s->deserialized_state = state;
2586         } else if (streq(key, "result")) {
2587                 SocketResult f;
2588
2589                 f = socket_result_from_string(value);
2590                 if (f < 0)
2591                         log_unit_debug(u, "Failed to parse result value: %s", value);
2592                 else if (f != SOCKET_SUCCESS)
2593                         s->result = f;
2594
2595         } else if (streq(key, "n-accepted")) {
2596                 unsigned k;
2597
2598                 if (safe_atou(value, &k) < 0)
2599                         log_unit_debug(u, "Failed to parse n-accepted value: %s", value);
2600                 else
2601                         s->n_accepted += k;
2602         } else if (streq(key, "control-pid")) {
2603                 pid_t pid;
2604
2605                 if (parse_pid(value, &pid) < 0)
2606                         log_unit_debug(u, "Failed to parse control-pid value: %s", value);
2607                 else
2608                         s->control_pid = pid;
2609         } else if (streq(key, "control-command")) {
2610                 SocketExecCommand id;
2611
2612                 id = socket_exec_command_from_string(value);
2613                 if (id < 0)
2614                         log_unit_debug(u, "Failed to parse exec-command value: %s", value);
2615                 else {
2616                         s->control_command_id = id;
2617                         s->control_command = s->exec_command[id];
2618                 }
2619         } else if (streq(key, "fifo")) {
2620                 int fd, skip = 0;
2621                 SocketPort *p;
2622
2623                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2624                         log_unit_debug(u, "Failed to parse fifo value: %s", value);
2625                 else
2626                         LIST_FOREACH(port, p, s->ports)
2627                                 if (p->type == SOCKET_FIFO &&
2628                                     path_equal_or_files_same(p->path, value+skip, 0)) {
2629                                         socket_port_take_fd(p, fds, fd);
2630                                         break;
2631                                 }
2632
2633         } else if (streq(key, "special")) {
2634                 int fd, skip = 0;
2635                 SocketPort *p;
2636
2637                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2638                         log_unit_debug(u, "Failed to parse special value: %s", value);
2639                 else
2640                         LIST_FOREACH(port, p, s->ports)
2641                                 if (p->type == SOCKET_SPECIAL &&
2642                                     path_equal_or_files_same(p->path, value+skip, 0)) {
2643                                         socket_port_take_fd(p, fds, fd);
2644                                         break;
2645                                 }
2646
2647         } else if (streq(key, "mqueue")) {
2648                 int fd, skip = 0;
2649                 SocketPort *p;
2650
2651                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2652                         log_unit_debug(u, "Failed to parse mqueue value: %s", value);
2653                 else
2654                         LIST_FOREACH(port, p, s->ports)
2655                                 if (p->type == SOCKET_MQUEUE &&
2656                                     streq(p->path, value+skip)) {
2657                                         socket_port_take_fd(p, fds, fd);
2658                                         break;
2659                                 }
2660
2661         } else if (streq(key, "socket")) {
2662                 int fd, type, skip = 0;
2663                 SocketPort *p;
2664
2665                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
2666                         log_unit_debug(u, "Failed to parse socket value: %s", value);
2667                 else
2668                         LIST_FOREACH(port, p, s->ports)
2669                                 if (socket_address_is(&p->address, value+skip, type)) {
2670                                         socket_port_take_fd(p, fds, fd);
2671                                         break;
2672                                 }
2673
2674         } else if (streq(key, "netlink")) {
2675                 int fd, skip = 0;
2676                 SocketPort *p;
2677
2678                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2679                         log_unit_debug(u, "Failed to parse socket value: %s", value);
2680                 else
2681                         LIST_FOREACH(port, p, s->ports)
2682                                 if (socket_address_is_netlink(&p->address, value+skip)) {
2683                                         socket_port_take_fd(p, fds, fd);
2684                                         break;
2685                                 }
2686
2687         } else if (streq(key, "ffs")) {
2688                 int fd, skip = 0;
2689                 SocketPort *p;
2690
2691                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2692                         log_unit_debug(u, "Failed to parse ffs value: %s", value);
2693                 else
2694                         LIST_FOREACH(port, p, s->ports)
2695                                 if (p->type == SOCKET_USB_FUNCTION &&
2696                                     path_equal_or_files_same(p->path, value+skip, 0)) {
2697                                         socket_port_take_fd(p, fds, fd);
2698                                         break;
2699                                 }
2700
2701         } else
2702                 log_unit_debug(UNIT(s), "Unknown serialization key: %s", key);
2703
2704         return 0;
2705 }
2706
2707 static void socket_distribute_fds(Unit *u, FDSet *fds) {
2708         Socket *s = SOCKET(u);
2709         SocketPort *p;
2710
2711         assert(u);
2712
2713         LIST_FOREACH(port, p, s->ports) {
2714                 Iterator i;
2715                 int fd;
2716
2717                 if (p->type != SOCKET_SOCKET)
2718                         continue;
2719
2720                 if (p->fd >= 0)
2721                         continue;
2722
2723                 FDSET_FOREACH(fd, fds, i) {
2724                         if (socket_address_matches_fd(&p->address, fd)) {
2725                                 p->fd = fdset_remove(fds, fd);
2726                                 s->deserialized_state = SOCKET_LISTENING;
2727                                 break;
2728                         }
2729                 }
2730         }
2731 }
2732
2733 _pure_ static UnitActiveState socket_active_state(Unit *u) {
2734         assert(u);
2735
2736         return state_translation_table[SOCKET(u)->state];
2737 }
2738
2739 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
2740         assert(u);
2741
2742         return socket_state_to_string(SOCKET(u)->state);
2743 }
2744
2745 const char* socket_port_type_to_string(SocketPort *p) {
2746
2747         assert(p);
2748
2749         switch (p->type) {
2750
2751         case SOCKET_SOCKET:
2752
2753                 switch (p->address.type) {
2754
2755                 case SOCK_STREAM:
2756                         return "Stream";
2757
2758                 case SOCK_DGRAM:
2759                         return "Datagram";
2760
2761                 case SOCK_SEQPACKET:
2762                         return "SequentialPacket";
2763
2764                 case SOCK_RAW:
2765                         if (socket_address_family(&p->address) == AF_NETLINK)
2766                                 return "Netlink";
2767
2768                         /* fall through */
2769                 default:
2770                         return NULL;
2771                 }
2772
2773         case SOCKET_SPECIAL:
2774                 return "Special";
2775
2776         case SOCKET_MQUEUE:
2777                 return "MessageQueue";
2778
2779         case SOCKET_FIFO:
2780                 return "FIFO";
2781
2782         case SOCKET_USB_FUNCTION:
2783                 return "USBFunction";
2784
2785         default:
2786                 return NULL;
2787         }
2788 }
2789
2790 _pure_ static bool socket_check_gc(Unit *u) {
2791         Socket *s = SOCKET(u);
2792
2793         assert(u);
2794
2795         return s->n_connections > 0;
2796 }
2797
2798 static int socket_accept_do(Socket *s, int fd) {
2799         int cfd;
2800
2801         assert(s);
2802         assert(fd >= 0);
2803
2804         for (;;) {
2805                 cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2806                 if (cfd < 0) {
2807                         if (errno == EINTR)
2808                                 continue;
2809
2810                         return -errno;
2811                 }
2812
2813                 break;
2814         }
2815
2816         return cfd;
2817 }
2818
2819 static int socket_accept_in_cgroup(Socket *s, SocketPort *p, int fd) {
2820         _cleanup_close_pair_ int pair[2] = { -1, -1 };
2821         int cfd, r;
2822         pid_t pid;
2823
2824         assert(s);
2825         assert(p);
2826         assert(fd >= 0);
2827
2828         /* Similar to socket_address_listen_in_cgroup(), but for accept() rathern than socket(): make sure that any
2829          * connection socket is also properly associated with the cgroup. */
2830
2831         if (!IN_SET(p->address.sockaddr.sa.sa_family, AF_INET, AF_INET6))
2832                 goto shortcut;
2833
2834         r = bpf_firewall_supported();
2835         if (r < 0)
2836                 return r;
2837         if (r == 0)
2838                 goto shortcut;
2839
2840         if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
2841                 return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
2842
2843         r = unit_fork_helper_process(UNIT(s), &pid);
2844         if (r < 0)
2845                 return log_unit_error_errno(UNIT(s), r, "Failed to fork off accept stub process: %m");
2846         if (r == 0) {
2847                 /* Child */
2848
2849                 pair[0] = safe_close(pair[0]);
2850
2851                 cfd = socket_accept_do(s, fd);
2852                 if (cfd < 0) {
2853                         log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
2854                         _exit(EXIT_FAILURE);
2855                 }
2856
2857                 r = send_one_fd(pair[1], cfd, 0);
2858                 if (r < 0) {
2859                         log_unit_error_errno(UNIT(s), r, "Failed to send connection socket to parent: %m");
2860                         _exit(EXIT_FAILURE);
2861                 }
2862
2863                 _exit(EXIT_SUCCESS);
2864         }
2865
2866         pair[1] = safe_close(pair[1]);
2867         cfd = receive_one_fd(pair[0], 0);
2868
2869         /* We synchronously wait for the helper, as it shouldn't be slow */
2870         r = wait_for_terminate_and_warn("accept-cgroup-helper", pid, false);
2871         if (r < 0) {
2872                 safe_close(cfd);
2873                 return r;
2874         }
2875
2876         if (cfd < 0)
2877                 return log_unit_error_errno(UNIT(s), cfd, "Failed to receive connection socket: %m");
2878
2879         return cfd;
2880
2881 shortcut:
2882         cfd = socket_accept_do(s, fd);
2883         if (cfd < 0)
2884                 return log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
2885
2886         return cfd;
2887 }
2888
2889 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2890         SocketPort *p = userdata;
2891         int cfd = -1;
2892
2893         assert(p);
2894         assert(fd >= 0);
2895
2896         if (p->socket->state != SOCKET_LISTENING)
2897                 return 0;
2898
2899         log_unit_debug(UNIT(p->socket), "Incoming traffic");
2900
2901         if (revents != EPOLLIN) {
2902
2903                 if (revents & EPOLLHUP)
2904                         log_unit_error(UNIT(p->socket), "Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.");
2905                 else
2906                         log_unit_error(UNIT(p->socket), "Got unexpected poll event (0x%x) on socket.", revents);
2907                 goto fail;
2908         }
2909
2910         if (p->socket->accept &&
2911             p->type == SOCKET_SOCKET &&
2912             socket_address_can_accept(&p->address)) {
2913
2914                 cfd = socket_accept_in_cgroup(p->socket, p, fd);
2915                 if (cfd < 0)
2916                         goto fail;
2917
2918                 socket_apply_socket_options(p->socket, cfd);
2919         }
2920
2921         socket_enter_running(p->socket, cfd);
2922         return 0;
2923
2924 fail:
2925         socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2926         return 0;
2927 }
2928
2929 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2930         Socket *s = SOCKET(u);
2931         SocketResult f;
2932
2933         assert(s);
2934         assert(pid >= 0);
2935
2936         if (pid != s->control_pid)
2937                 return;
2938
2939         s->control_pid = 0;
2940
2941         if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
2942                 f = SOCKET_SUCCESS;
2943         else if (code == CLD_EXITED)
2944                 f = SOCKET_FAILURE_EXIT_CODE;
2945         else if (code == CLD_KILLED)
2946                 f = SOCKET_FAILURE_SIGNAL;
2947         else if (code == CLD_DUMPED)
2948                 f = SOCKET_FAILURE_CORE_DUMP;
2949         else
2950                 assert_not_reached("Unknown sigchld code");
2951
2952         if (s->control_command) {
2953                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2954
2955                 if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
2956                         f = SOCKET_SUCCESS;
2957         }
2958
2959         log_unit_full(u, f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE, 0,
2960                       "Control process exited, code=%s status=%i",
2961                       sigchld_code_to_string(code), status);
2962
2963         if (s->result == SOCKET_SUCCESS)
2964                 s->result = f;
2965
2966         if (s->control_command &&
2967             s->control_command->command_next &&
2968             f == SOCKET_SUCCESS) {
2969
2970                 log_unit_debug(u, "Running next command for state %s", socket_state_to_string(s->state));
2971                 socket_run_next(s);
2972         } else {
2973                 s->control_command = NULL;
2974                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2975
2976                 /* No further commands for this step, so let's figure
2977                  * out what to do next */
2978
2979                 log_unit_debug(u, "Got final SIGCHLD for state %s", socket_state_to_string(s->state));
2980
2981                 switch (s->state) {
2982
2983                 case SOCKET_START_PRE:
2984                         if (f == SOCKET_SUCCESS)
2985                                 socket_enter_start_chown(s);
2986                         else
2987                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2988                         break;
2989
2990                 case SOCKET_START_CHOWN:
2991                         if (f == SOCKET_SUCCESS)
2992                                 socket_enter_start_post(s);
2993                         else
2994                                 socket_enter_stop_pre(s, f);
2995                         break;
2996
2997                 case SOCKET_START_POST:
2998                         if (f == SOCKET_SUCCESS)
2999                                 socket_enter_listening(s);
3000                         else
3001                                 socket_enter_stop_pre(s, f);
3002                         break;
3003
3004                 case SOCKET_STOP_PRE:
3005                 case SOCKET_STOP_PRE_SIGTERM:
3006                 case SOCKET_STOP_PRE_SIGKILL:
3007                         socket_enter_stop_post(s, f);
3008                         break;
3009
3010                 case SOCKET_STOP_POST:
3011                 case SOCKET_FINAL_SIGTERM:
3012                 case SOCKET_FINAL_SIGKILL:
3013                         socket_enter_dead(s, f);
3014                         break;
3015
3016                 default:
3017                         assert_not_reached("Uh, control process died at wrong time.");
3018                 }
3019         }
3020
3021         /* Notify clients about changed exit status */
3022         unit_add_to_dbus_queue(u);
3023 }
3024
3025 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
3026         Socket *s = SOCKET(userdata);
3027
3028         assert(s);
3029         assert(s->timer_event_source == source);
3030
3031         switch (s->state) {
3032
3033         case SOCKET_START_PRE:
3034                 log_unit_warning(UNIT(s), "Starting timed out. Terminating.");
3035                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
3036                 break;
3037
3038         case SOCKET_START_CHOWN:
3039         case SOCKET_START_POST:
3040                 log_unit_warning(UNIT(s), "Starting timed out. Stopping.");
3041                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
3042                 break;
3043
3044         case SOCKET_STOP_PRE:
3045                 log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
3046                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
3047                 break;
3048
3049         case SOCKET_STOP_PRE_SIGTERM:
3050                 if (s->kill_context.send_sigkill) {
3051                         log_unit_warning(UNIT(s), "Stopping timed out. Killing.");
3052                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
3053                 } else {
3054                         log_unit_warning(UNIT(s), "Stopping timed out. Skipping SIGKILL. Ignoring.");
3055                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
3056                 }
3057                 break;
3058
3059         case SOCKET_STOP_PRE_SIGKILL:
3060                 log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
3061                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
3062                 break;
3063
3064         case SOCKET_STOP_POST:
3065                 log_unit_warning(UNIT(s), "Stopping timed out (2). Terminating.");
3066                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
3067                 break;
3068
3069         case SOCKET_FINAL_SIGTERM:
3070                 if (s->kill_context.send_sigkill) {
3071                         log_unit_warning(UNIT(s), "Stopping timed out (2). Killing.");
3072                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
3073                 } else {
3074                         log_unit_warning(UNIT(s), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
3075                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
3076                 }
3077                 break;
3078
3079         case SOCKET_FINAL_SIGKILL:
3080                 log_unit_warning(UNIT(s), "Still around after SIGKILL (2). Entering failed mode.");
3081                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
3082                 break;
3083
3084         default:
3085                 assert_not_reached("Timeout at wrong time.");
3086         }
3087
3088         return 0;
3089 }
3090
3091 int socket_collect_fds(Socket *s, int **fds) {
3092         int *rfds, k = 0, n = 0;
3093         SocketPort *p;
3094
3095         assert(s);
3096         assert(fds);
3097
3098         /* Called from the service code for requesting our fds */
3099
3100         LIST_FOREACH(port, p, s->ports) {
3101                 if (p->fd >= 0)
3102                         n++;
3103                 n += p->n_auxiliary_fds;
3104         }
3105
3106         if (n <= 0) {
3107                 *fds = NULL;
3108                 return 0;
3109         }
3110
3111         rfds = new(int, n);
3112         if (!rfds)
3113                 return -ENOMEM;
3114
3115         LIST_FOREACH(port, p, s->ports) {
3116                 int i;
3117
3118                 if (p->fd >= 0)
3119                         rfds[k++] = p->fd;
3120                 for (i = 0; i < p->n_auxiliary_fds; ++i)
3121                         rfds[k++] = p->auxiliary_fds[i];
3122         }
3123
3124         assert(k == n);
3125
3126         *fds = rfds;
3127         return n;
3128 }
3129
3130 static void socket_reset_failed(Unit *u) {
3131         Socket *s = SOCKET(u);
3132
3133         assert(s);
3134
3135         if (s->state == SOCKET_FAILED)
3136                 socket_set_state(s, SOCKET_DEAD);
3137
3138         s->result = SOCKET_SUCCESS;
3139 }
3140
3141 void socket_connection_unref(Socket *s) {
3142         assert(s);
3143
3144         /* The service is dead. Yay!
3145          *
3146          * This is strictly for one-instance-per-connection
3147          * services. */
3148
3149         assert(s->n_connections > 0);
3150         s->n_connections--;
3151
3152         log_unit_debug(UNIT(s), "One connection closed, %u left.", s->n_connections);
3153 }
3154
3155 static void socket_trigger_notify(Unit *u, Unit *other) {
3156         Socket *s = SOCKET(u);
3157
3158         assert(u);
3159         assert(other);
3160
3161         /* Filter out invocations with bogus state */
3162         if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
3163                 return;
3164
3165         /* Don't propagate state changes from the service if we are already down */
3166         if (!IN_SET(s->state, SOCKET_RUNNING, SOCKET_LISTENING))
3167                 return;
3168
3169         /* We don't care for the service state if we are in Accept=yes mode */
3170         if (s->accept)
3171                 return;
3172
3173         /* Propagate start limit hit state */
3174         if (other->start_limit_hit) {
3175                 socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_START_LIMIT_HIT);
3176                 return;
3177         }
3178
3179         /* Don't propagate anything if there's still a job queued */
3180         if (other->job)
3181                 return;
3182
3183         if (IN_SET(SERVICE(other)->state,
3184                    SERVICE_DEAD, SERVICE_FAILED,
3185                    SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
3186                    SERVICE_AUTO_RESTART))
3187                socket_enter_listening(s);
3188
3189         if (SERVICE(other)->state == SERVICE_RUNNING)
3190                 socket_set_state(s, SOCKET_RUNNING);
3191 }
3192
3193 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
3194         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
3195 }
3196
3197 static int socket_get_timeout(Unit *u, usec_t *timeout) {
3198         Socket *s = SOCKET(u);
3199         usec_t t;
3200         int r;
3201
3202         if (!s->timer_event_source)
3203                 return 0;
3204
3205         r = sd_event_source_get_time(s->timer_event_source, &t);
3206         if (r < 0)
3207                 return r;
3208         if (t == USEC_INFINITY)
3209                 return 0;
3210
3211         *timeout = t;
3212         return 1;
3213 }
3214
3215 char *socket_fdname(Socket *s) {
3216         assert(s);
3217
3218         /* Returns the name to use for $LISTEN_NAMES. If the user
3219          * didn't specify anything specifically, use the socket unit's
3220          * name as fallback. */
3221
3222         if (s->fdname)
3223                 return s->fdname;
3224
3225         return UNIT(s)->id;
3226 }
3227
3228 static int socket_control_pid(Unit *u) {
3229         Socket *s = SOCKET(u);
3230
3231         assert(s);
3232
3233         return s->control_pid;
3234 }
3235
3236 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
3237         [SOCKET_EXEC_START_PRE] = "StartPre",
3238         [SOCKET_EXEC_START_CHOWN] = "StartChown",
3239         [SOCKET_EXEC_START_POST] = "StartPost",
3240         [SOCKET_EXEC_STOP_PRE] = "StopPre",
3241         [SOCKET_EXEC_STOP_POST] = "StopPost"
3242 };
3243
3244 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
3245
3246 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
3247         [SOCKET_SUCCESS] = "success",
3248         [SOCKET_FAILURE_RESOURCES] = "resources",
3249         [SOCKET_FAILURE_TIMEOUT] = "timeout",
3250         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
3251         [SOCKET_FAILURE_SIGNAL] = "signal",
3252         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
3253         [SOCKET_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
3254         [SOCKET_FAILURE_TRIGGER_LIMIT_HIT] = "trigger-limit-hit",
3255         [SOCKET_FAILURE_SERVICE_START_LIMIT_HIT] = "service-start-limit-hit"
3256 };
3257
3258 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
3259
3260 const UnitVTable socket_vtable = {
3261         .object_size = sizeof(Socket),
3262         .exec_context_offset = offsetof(Socket, exec_context),
3263         .cgroup_context_offset = offsetof(Socket, cgroup_context),
3264         .kill_context_offset = offsetof(Socket, kill_context),
3265         .exec_runtime_offset = offsetof(Socket, exec_runtime),
3266         .dynamic_creds_offset = offsetof(Socket, dynamic_creds),
3267
3268         .sections =
3269                 "Unit\0"
3270                 "Socket\0"
3271                 "Install\0",
3272         .private_section = "Socket",
3273
3274         .init = socket_init,
3275         .done = socket_done,
3276         .load = socket_load,
3277
3278         .coldplug = socket_coldplug,
3279
3280         .dump = socket_dump,
3281
3282         .start = socket_start,
3283         .stop = socket_stop,
3284
3285         .kill = socket_kill,
3286
3287         .get_timeout = socket_get_timeout,
3288
3289         .serialize = socket_serialize,
3290         .deserialize_item = socket_deserialize_item,
3291         .distribute_fds = socket_distribute_fds,
3292
3293         .active_state = socket_active_state,
3294         .sub_state_to_string = socket_sub_state_to_string,
3295
3296         .check_gc = socket_check_gc,
3297
3298         .sigchld_event = socket_sigchld_event,
3299
3300         .trigger_notify = socket_trigger_notify,
3301
3302         .reset_failed = socket_reset_failed,
3303
3304         .control_pid = socket_control_pid,
3305
3306         .bus_vtable = bus_socket_vtable,
3307         .bus_set_property = bus_socket_set_property,
3308         .bus_commit_properties = bus_socket_commit_properties,
3309
3310         .status_message_formats = {
3311                 /*.starting_stopping = {
3312                         [0] = "Starting socket %s...",
3313                         [1] = "Stopping socket %s...",
3314                 },*/
3315                 .finished_start_job = {
3316                         [JOB_DONE]       = "Listening on %s.",
3317                         [JOB_FAILED]     = "Failed to listen on %s.",
3318                         [JOB_TIMEOUT]    = "Timed out starting %s.",
3319                 },
3320                 .finished_stop_job = {
3321                         [JOB_DONE]       = "Closed %s.",
3322                         [JOB_FAILED]     = "Failed stopping %s.",
3323                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
3324                 },
3325         },
3326 };