src/core/socket.c

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