src/core/socket.c

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