src/core/socket.c

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