HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/socket.c

134,327 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 3eea7e4c0557a4acc7b3916226c5571929f54015

Lines 1–1000 of 3,800

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <fcntl.h>
#include <linux/sctp.h>
#include <mqueue.h>
#include <netinet/tcp.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include "sd-bus.h"
 
#include "alloc-util.h"
#include "bpf-program.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "copy.h"
#include "dbus-socket.h"
#include "dbus-unit.h"
#include "errno-list.h"
#include "errno-util.h"
#include "exit-status.h"
#include "extract-word.h"
#include "fd-util.h"
#include "fdset.h"
#include "format-util.h"
#include "fs-util.h"
#include "glyph-util.h"
#include "in-addr-util.h"
#include "io-util.h"
#include "ip-protocol-list.h"
#include "log.h"
#include "manager.h"
#include "mkdir.h"
#include "namespace-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "pidfd-util.h"
#include "process-util.h"
#include "recurse-dir.h"
#include "selinux-util.h"
#include "serialize.h"
#include "service.h"
#include "set.h"
#include "siphash24.h"
#include "smack-util.h"
#include "socket.h"
#include "socket-netlink.h"
#include "special.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "unit.h"
#include "unit-name.h"
#include "user-util.h"
 
typedef struct SocketPeer {
        unsigned n_ref;
 
        Socket *socket;
        union sockaddr_union peer;
        socklen_t peer_salen;
        struct ucred peer_cred;
} SocketPeer;
 
static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
        [SOCKET_DEAD]             = UNIT_INACTIVE,
        [SOCKET_START_PRE]        = UNIT_ACTIVATING,
        [SOCKET_START_OPEN]       = UNIT_ACTIVATING,
        [SOCKET_START_CHOWN]      = UNIT_ACTIVATING,
        [SOCKET_START_POST]       = UNIT_ACTIVATING,
        [SOCKET_LISTENING]        = UNIT_ACTIVE,
        [SOCKET_DEFERRED]         = UNIT_ACTIVE,
        [SOCKET_RUNNING]          = UNIT_ACTIVE,
        [SOCKET_STOP_PRE]         = UNIT_DEACTIVATING,
        [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
        [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
        [SOCKET_STOP_POST]        = UNIT_DEACTIVATING,
        [SOCKET_FINAL_SIGTERM]    = UNIT_DEACTIVATING,
        [SOCKET_FINAL_SIGKILL]    = UNIT_DEACTIVATING,
        [SOCKET_FAILED]           = UNIT_FAILED,
        [SOCKET_CLEANING]         = UNIT_MAINTENANCE,
};
 
static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
 
static bool SOCKET_STATE_WITH_PROCESS(SocketState state) {
        return IN_SET(state,
                      SOCKET_START_PRE,
                      SOCKET_START_CHOWN,
                      SOCKET_START_POST,
                      SOCKET_STOP_PRE,
                      SOCKET_STOP_PRE_SIGTERM,
                      SOCKET_STOP_PRE_SIGKILL,
                      SOCKET_STOP_POST,
                      SOCKET_FINAL_SIGTERM,
                      SOCKET_FINAL_SIGKILL,
                      SOCKET_CLEANING);
}
 
static bool SOCKET_SERVICE_IS_ACTIVE(Service *s, bool allow_finalize) {
        assert(s);
 
        /* If unit_active_state() reports inactive/failed then it's all good, otherwise we need to
         * manually exclude SERVICE_AUTO_RESTART and SERVICE_AUTO_RESTART_QUEUED, in which cases
         * the start job hasn't been enqueued/run, but are only placeholders in order to allow
         * canceling auto restart. */
 
        if (UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(UNIT(s))))
                return false;
 
        if (IN_SET(s->state, SERVICE_AUTO_RESTART, SERVICE_AUTO_RESTART_QUEUED))
                return false;
 
        if (allow_finalize && IN_SET(s->state, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL, SERVICE_CLEANING))
                return false;
 
        return true;
}
 
static void socket_init(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        assert(u->load_state == UNIT_STUB);
 
        s->backlog = SOMAXCONN_DELUXE;
        s->timeout_usec = u->manager->defaults.timeout_start_usec;
        s->directory_mode = 0755;
        s->socket_mode = 0666;
 
        s->max_connections = 64;
 
        s->pass_rights = true; /* defaults to enabled in kernel */
        s->priority = -1;
        s->ip_tos = -1;
        s->ip_ttl = -1;
        s->mark = -1;
 
        s->exec_context.std_output = u->manager->defaults.std_output;
        s->exec_context.std_error = u->manager->defaults.std_error;
 
        s->control_pid = PIDREF_NULL;
        s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
 
        s->trigger_limit = RATELIMIT_OFF;
 
        s->poll_limit = RATELIMIT_OFF;
 
        s->defer_trigger_max_usec = USEC_INFINITY;
}
 
static void socket_unwatch_control_pid(Socket *s) {
        assert(s);
        unit_unwatch_pidref_done(UNIT(s), &s->control_pid);
}
 
static void socket_port_close_auxiliary_fds(SocketPort *p) {
        assert(p);
 
        close_many(p->auxiliary_fds, p->n_auxiliary_fds);
        p->auxiliary_fds = mfree(p->auxiliary_fds);
        p->n_auxiliary_fds = 0;
}
 
SocketPort* socket_port_free(SocketPort *p) {
        if (!p)
                return NULL;
 
        sd_event_source_unref(p->event_source);
 
        socket_port_close_auxiliary_fds(p);
        safe_close(p->fd);
        free(p->path);
 
        return mfree(p);
}
 
void socket_free_ports(Socket *s) {
        assert(s);
 
        LIST_CLEAR(port, s->ports, socket_port_free);
}
 
static void socket_done(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        SocketPeer *p;
 
        socket_free_ports(s);
 
        while ((p = set_steal_first(s->peers_by_address)))
                p->socket = NULL;
 
        s->peers_by_address = set_free(s->peers_by_address);
 
        s->exec_runtime = exec_runtime_free(s->exec_runtime);
 
        exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
        s->control_command = NULL;
 
        socket_unwatch_control_pid(s);
 
        unit_ref_unset(&s->service);
 
        s->tcp_congestion = mfree(s->tcp_congestion);
        s->bind_to_device = mfree(s->bind_to_device);
 
        s->smack = mfree(s->smack);
        s->smack_ip_in = mfree(s->smack_ip_in);
        s->smack_ip_out = mfree(s->smack_ip_out);
 
        strv_free(s->symlinks);
 
        strv_free(s->xattr_entrypoint);
        strv_free(s->xattr_listen);
        strv_free(s->xattr_accept);
 
        s->user = mfree(s->user);
        s->group = mfree(s->group);
 
        s->fdname = mfree(s->fdname);
 
        s->timer_event_source = sd_event_source_disable_unref(s->timer_event_source);
}
 
static int socket_arm_timer(Socket *s, bool relative, usec_t usec) {
        assert(s);
 
        return unit_arm_timer(UNIT(s), &s->timer_event_source, relative, usec, socket_dispatch_timer);
}
 
static bool have_non_accept_socket(Socket *s) {
        assert(s);
 
        if (!s->accept)
                return true;
 
        LIST_FOREACH(port, p, s->ports) {
 
                if (p->type != SOCKET_SOCKET)
                        return true;
 
                if (!socket_address_can_accept(&p->address))
                        return true;
        }
 
        return false;
}
 
static int socket_add_mount_dependencies(Socket *s) {
        int r;
 
        assert(s);
 
        LIST_FOREACH(port, p, s->ports) {
                const char *path = NULL;
 
                if (p->type == SOCKET_SOCKET)
                        path = socket_address_get_path(&p->address);
                else if (IN_SET(p->type, SOCKET_FIFO, SOCKET_SPECIAL, SOCKET_USB_FUNCTION))
                        path = p->path;
 
                if (!path)
                        continue;
 
                r = unit_add_mounts_for(UNIT(s), path, UNIT_DEPENDENCY_FILE, UNIT_MOUNT_REQUIRES);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static int socket_add_device_dependencies(Socket *s) {
        char *t;
 
        assert(s);
 
        if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
                return 0;
 
        t = strjoina("/sys/subsystem/net/devices/", s->bind_to_device);
        return unit_add_node_dependency(UNIT(s), t, UNIT_BINDS_TO, UNIT_DEPENDENCY_FILE);
}
 
static int socket_add_default_dependencies(Socket *s) {
        int r;
 
        assert(s);
 
        if (!UNIT(s)->default_dependencies)
                return 0;
 
        r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
        if (r < 0)
                return r;
 
        if (MANAGER_IS_SYSTEM(UNIT(s)->manager)) {
                r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
                if (r < 0)
                        return r;
        }
 
        return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, true, UNIT_DEPENDENCY_DEFAULT);
}
 
static bool socket_has_exec(Socket *s) {
        assert(s);
 
        FOREACH_ARRAY(i, s->exec_command, _SOCKET_EXEC_COMMAND_MAX)
                if (*i)
                        return true;
 
        return false;
}
 
static int socket_add_extras(Socket *s) {
        Unit *u = UNIT(ASSERT_PTR(s));
        int r;
 
        /* Pick defaults for the trigger limit, if nothing was explicitly configured. We pick a relatively high limit
         * in Accept=yes mode, and a lower limit for Accept=no. Reason: in Accept=yes mode we are invoking accept()
         * ourselves before the trigger limit can hit, thus incoming connections are taken off the socket queue quickly
         * and reliably. This is different for Accept=no, where the spawned service has to take the incoming traffic
         * off the queues, which it might not necessarily do. Moreover, while Accept=no services are supposed to
         * process whatever is queued in one go, and thus should normally never have to be started frequently. This is
         * different for Accept=yes where each connection is processed by a new service instance, and thus frequent
         * service starts are typical.
         *
         * For the poll limit we follow a similar rule, but use 3/4th of the trigger limit parameters, to
         * trigger this earlier. */
 
        if (s->trigger_limit.interval == USEC_INFINITY)
                s->trigger_limit.interval = 2 * USEC_PER_SEC;
        if (s->trigger_limit.burst == UINT_MAX)
                s->trigger_limit.burst = s->accept ? 200 : 20;
 
        if (s->poll_limit.interval == USEC_INFINITY)
                s->poll_limit.interval = 2 * USEC_PER_SEC;
        if (s->poll_limit.burst == UINT_MAX)
                s->poll_limit.burst = s->accept ? 150 : 15;
 
        if (have_non_accept_socket(s)) {
 
                if (!UNIT_ISSET(s->service)) {
                        Unit *x;
 
                        r = unit_load_related_unit(u, ".service", &x);
                        if (r < 0)
                                return r;
 
                        unit_ref_set(&s->service, u, x);
                }
 
                r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true, UNIT_DEPENDENCY_IMPLICIT);
                if (r < 0)
                        return r;
        }
 
        r = socket_add_mount_dependencies(s);
        if (r < 0)
                return r;
 
        r = socket_add_device_dependencies(s);
        if (r < 0)
                return r;
 
        r = unit_patch_contexts(u);
        if (r < 0)
                return r;
 
        if (socket_has_exec(s)) {
                r = unit_add_exec_dependencies(u, &s->exec_context);
                if (r < 0)
                        return r;
        }
 
        r = unit_set_default_slice(u);
        if (r < 0)
                return r;
 
        r = socket_add_default_dependencies(s);
        if (r < 0)
                return r;
 
        return 0;
}
 
static const char* socket_find_symlink_target(Socket *s) {
        const char *found = NULL;
 
        assert(s);
 
        LIST_FOREACH(port, p, s->ports) {
                const char *f;
 
                switch (p->type) {
 
                case SOCKET_FIFO:
                        f = p->path;
                        break;
 
                case SOCKET_SOCKET:
                        f = socket_address_get_path(&p->address);
                        break;
 
                default:
                        f = NULL;
                }
 
                if (f) {
                        if (found)
                                return NULL;
 
                        found = f;
                }
        }
 
        return found;
}
 
static int socket_verify(Socket *s) {
        assert(s);
        assert(UNIT(s)->load_state == UNIT_LOADED);
 
        if (!s->ports)
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENOEXEC), "Unit has no Listen setting (ListenStream=, ListenDatagram=, ListenFIFO=, ...). Refusing.");
 
        if (s->max_connections <= 0)
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENOEXEC), "MaxConnection= setting too small. Refusing.");
 
        if (s->accept && have_non_accept_socket(s))
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENOEXEC), "Unit configured for accepting sockets, but sockets are non-accepting. Refusing.");
 
        if (s->accept && UNIT_ISSET(s->service))
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENOEXEC), "Explicit service configuration for accepting socket units not supported. Refusing.");
 
        if (s->accept && s->defer_trigger != SOCKET_DEFER_NO)
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENOEXEC), "Socket unit is configured to be accepting with DeferTrigger= enabled. Refusing.");
 
        if (!strv_isempty(s->symlinks) && !socket_find_symlink_target(s))
                return log_unit_error_errno(UNIT(s), SYNTHETIC_ERRNO(ENOEXEC), "Unit has symlinks set but none or more than one node in the file system. Refusing.");
 
        return 0;
}
 
static void peer_address_hash_func(const SocketPeer *s, struct siphash *state) {
        assert(s);
 
        if (s->peer.sa.sa_family == AF_INET)
                siphash24_compress_typesafe(s->peer.in.sin_addr, state);
        else if (s->peer.sa.sa_family == AF_INET6)
                siphash24_compress_typesafe(s->peer.in6.sin6_addr, state);
        else if (s->peer.sa.sa_family == AF_VSOCK)
                siphash24_compress_typesafe(s->peer.vm.svm_cid, state);
        else if (s->peer.sa.sa_family == AF_UNIX)
                siphash24_compress_typesafe(s->peer_cred.uid, state);
        else
                assert_not_reached();
}
 
static int peer_address_compare_func(const SocketPeer *x, const SocketPeer *y) {
        int r;
 
        r = CMP(x->peer.sa.sa_family, y->peer.sa.sa_family);
        if (r != 0)
                return r;
 
        switch (x->peer.sa.sa_family) {
        case AF_INET:
                return memcmp(&x->peer.in.sin_addr, &y->peer.in.sin_addr, sizeof(x->peer.in.sin_addr));
        case AF_INET6:
                return memcmp(&x->peer.in6.sin6_addr, &y->peer.in6.sin6_addr, sizeof(x->peer.in6.sin6_addr));
        case AF_VSOCK:
                return CMP(x->peer.vm.svm_cid, y->peer.vm.svm_cid);
        case AF_UNIX:
                return CMP(x->peer_cred.uid, y->peer_cred.uid);
        }
        assert_not_reached();
}
 
DEFINE_PRIVATE_HASH_OPS(peer_address_hash_ops, SocketPeer, peer_address_hash_func, peer_address_compare_func);
 
static int socket_load(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        int r;
 
        assert(u->load_state == UNIT_STUB);
 
        r = unit_load_fragment_and_dropin(u, true);
        if (r < 0)
                return r;
 
        if (u->load_state != UNIT_LOADED)
                return 0;
 
        /* This is a new unit? Then let's add in some extras */
        r = socket_add_extras(s);
        if (r < 0)
                return r;
 
        return socket_verify(s);
}
 
static SocketPeer* socket_peer_dup(const SocketPeer *q) {
        SocketPeer *p;
 
        assert(q);
 
        p = new(SocketPeer, 1);
        if (!p)
                return NULL;
 
        *p = (SocketPeer) {
                .n_ref = 1,
                .peer = q->peer,
                .peer_salen = q->peer_salen,
                .peer_cred = q->peer_cred,
        };
 
        return p;
}
 
static SocketPeer* socket_peer_free(SocketPeer *p) {
        assert(p);
 
        if (p->socket)
                set_remove(p->socket->peers_by_address, p);
 
        return mfree(p);
}
 
DEFINE_TRIVIAL_REF_UNREF_FUNC(SocketPeer, socket_peer, socket_peer_free);
 
int socket_acquire_peer(Socket *s, int fd, SocketPeer **ret) {
        _cleanup_(socket_peer_unrefp) SocketPeer *remote = NULL;
        SocketPeer key = {
                .peer_salen = sizeof(union sockaddr_union),
                .peer_cred = UCRED_INVALID,
        }, *i;
        int r;
 
        assert(s);
        assert(fd >= 0);
        assert(ret);
 
        if (getpeername(fd, &key.peer.sa, &key.peer_salen) < 0)
                return log_unit_error_errno(UNIT(s), errno, "getpeername() failed: %m");
 
        switch (key.peer.sa.sa_family) {
        case AF_INET:
        case AF_INET6:
        case AF_VSOCK:
                break;
 
        case AF_UNIX:
                r = getpeercred(fd, &key.peer_cred);
                if (r < 0)
                        return log_unit_error_errno(UNIT(s), r, "Failed to get peer credentials of socket: %m");
                break;
 
        default:
                *ret = NULL;
                return 0;
        }
 
        i = set_get(s->peers_by_address, &key);
        if (i) {
                *ret = socket_peer_ref(i);
                return 1;
        }
 
        remote = socket_peer_dup(&key);
        if (!remote)
                return log_oom();
 
        r = set_ensure_put(&s->peers_by_address, &peer_address_hash_ops, remote);
        if (r < 0)
                return log_unit_error_errno(UNIT(s), r, "Failed to insert peer info into hash table: %m");
 
        remote->socket = s;
 
        *ret = TAKE_PTR(remote);
        return 1;
}
 
static const char* listen_lookup(int family, int type) {
 
        if (family == AF_NETLINK)
                return "ListenNetlink";
 
        if (type == SOCK_STREAM)
                return "ListenStream";
        else if (type == SOCK_DGRAM)
                return "ListenDatagram";
        else if (type == SOCK_SEQPACKET)
                return "ListenSequentialPacket";
 
        assert_not_reached();
}
 
static void socket_dump(Unit *u, FILE *f, const char *prefix) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        const char *prefix2, *str;
 
        assert(f);
 
        prefix = strempty(prefix);
        prefix2 = strjoina(prefix, "\t");
 
        fprintf(f,
                "%sSocket State: %s\n"
                "%sResult: %s\n"
                "%sClean Result: %s\n"
                "%sBindIPv6Only: %s\n"
                "%sBacklog: %u\n"
                "%sSocketMode: %04o\n"
                "%sDirectoryMode: %04o\n"
                "%sKeepAlive: %s\n"
                "%sNoDelay: %s\n"
                "%sFreeBind: %s\n"
                "%sTransparent: %s\n"
                "%sBroadcast: %s\n"
                "%sPassCredentials: %s\n"
                "%sPassPIDFD: %s\n"
                "%sPassSecurity: %s\n"
                "%sPassPacketInfo: %s\n"
                "%sAcceptFileDescriptors: %s\n"
                "%sTCPCongestion: %s\n"
                "%sRemoveOnStop: %s\n"
                "%sWritable: %s\n"
                "%sFileDescriptorName: %s\n"
                "%sPassFileDescriptorsToExec: %s\n"
                "%sSELinuxContextFromNet: %s\n",
                prefix, socket_state_to_string(s->state),
                prefix, socket_result_to_string(s->result),
                prefix, socket_result_to_string(s->clean_result),
                prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
                prefix, s->backlog,
                prefix, s->socket_mode,
                prefix, s->directory_mode,
                prefix, yes_no(s->keep_alive),
                prefix, yes_no(s->no_delay),
                prefix, yes_no(s->free_bind),
                prefix, yes_no(s->transparent),
                prefix, yes_no(s->broadcast),
                prefix, yes_no(s->pass_cred),
                prefix, yes_no(s->pass_pidfd),
                prefix, yes_no(s->pass_sec),
                prefix, yes_no(s->pass_pktinfo),
                prefix, yes_no(s->pass_rights),
                prefix, strna(s->tcp_congestion),
                prefix, yes_no(s->remove_on_stop),
                prefix, yes_no(s->writable),
                prefix, socket_fdname(s),
                prefix, yes_no(s->pass_fds_to_exec),
                prefix, yes_no(s->selinux_context_from_net));
 
        if (s->timestamping != SOCKET_TIMESTAMPING_OFF)
                fprintf(f,
                        "%sTimestamping: %s\n",
                        prefix, socket_timestamping_to_string(s->timestamping));
 
        if (pidref_is_set(&s->control_pid))
                fprintf(f,
                        "%sControl PID: "PID_FMT"\n",
                        prefix, s->control_pid.pid);
 
        if (s->bind_to_device)
                fprintf(f,
                        "%sBindToDevice: %s\n",
                        prefix, s->bind_to_device);
 
        if (s->accept)
                fprintf(f,
                        "%sAccepted: %u\n"
                        "%sNConnections: %u\n"
                        "%sMaxConnections: %u\n"
                        "%sMaxConnectionsPerSource: %u\n",
                        prefix, s->n_accepted,
                        prefix, s->n_connections,
                        prefix, s->max_connections,
                        prefix, s->max_connections_per_source);
        else
                fprintf(f,
                        "%sFlushPending: %s\n"
                        "%sDeferTrigger: %s\n"
                        "%sDeferTriggerMaxSec: %s\n",
                        prefix, yes_no(s->flush_pending),
                        prefix, socket_defer_trigger_to_string(s->defer_trigger),
                        prefix, FORMAT_TIMESPAN(s->defer_trigger_max_usec, USEC_PER_SEC));
 
        if (s->priority >= 0)
                fprintf(f,
                        "%sPriority: %i\n",
                        prefix, s->priority);
 
        if (s->receive_buffer > 0)
                fprintf(f,
                        "%sReceiveBuffer: %zu\n",
                        prefix, s->receive_buffer);
 
        if (s->send_buffer > 0)
                fprintf(f,
                        "%sSendBuffer: %zu\n",
                        prefix, s->send_buffer);
 
        if (s->ip_tos >= 0)
                fprintf(f,
                        "%sIPTOS: %i\n",
                        prefix, s->ip_tos);
 
        if (s->ip_ttl >= 0)
                fprintf(f,
                        "%sIPTTL: %i\n",
                        prefix, s->ip_ttl);
 
        if (s->pipe_size > 0)
                fprintf(f,
                        "%sPipeSize: %zu\n",
                        prefix, s->pipe_size);
 
        if (s->mark >= 0)
                fprintf(f,
                        "%sMark: %i\n",
                        prefix, s->mark);
 
        if (s->mq_maxmsg > 0)
                fprintf(f,
                        "%sMessageQueueMaxMessages: %li\n",
                        prefix, s->mq_maxmsg);
 
        if (s->mq_msgsize > 0)
                fprintf(f,
                        "%sMessageQueueMessageSize: %li\n",
                        prefix, s->mq_msgsize);
 
        if (s->reuse_port)
                fprintf(f,
                        "%sReusePort: %s\n",
                         prefix, yes_no(s->reuse_port));
 
        if (s->smack)
                fprintf(f,
                        "%sSmackLabel: %s\n",
                        prefix, s->smack);
 
        if (s->smack_ip_in)
                fprintf(f,
                        "%sSmackLabelIPIn: %s\n",
                        prefix, s->smack_ip_in);
 
        if (s->smack_ip_out)
                fprintf(f,
                        "%sSmackLabelIPOut: %s\n",
                        prefix, s->smack_ip_out);
 
        if (!isempty(s->user) || !isempty(s->group))
                fprintf(f,
                        "%sSocketUser: %s\n"
                        "%sSocketGroup: %s\n",
                        prefix, strna(s->user),
                        prefix, strna(s->group));
 
        if (timestamp_is_set(s->keep_alive_time))
                fprintf(f,
                        "%sKeepAliveTimeSec: %s\n",
                        prefix, FORMAT_TIMESPAN(s->keep_alive_time, USEC_PER_SEC));
 
        if (s->keep_alive_interval > 0)
                fprintf(f,
                        "%sKeepAliveIntervalSec: %s\n",
                        prefix, FORMAT_TIMESPAN(s->keep_alive_interval, USEC_PER_SEC));
 
        if (s->keep_alive_cnt > 0)
                fprintf(f,
                        "%sKeepAliveProbes: %u\n",
                        prefix, s->keep_alive_cnt);
 
        if (s->defer_accept > 0)
                fprintf(f,
                        "%sDeferAcceptSec: %s\n",
                        prefix, FORMAT_TIMESPAN(s->defer_accept, USEC_PER_SEC));
 
        LIST_FOREACH(port, p, s->ports) {
 
                switch (p->type) {
                case SOCKET_SOCKET: {
                        _cleanup_free_ char *k = NULL;
                        int r;
 
                        r = socket_address_print(&p->address, &k);
                        if (r < 0) {
                                errno = -r;
                                fprintf(f, "%s%s: %m\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type));
                        } else
                                fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), k);
                        break;
                }
                case SOCKET_SPECIAL:
                        fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
                        break;
                case SOCKET_USB_FUNCTION:
                        fprintf(f, "%sListenUSBFunction: %s\n", prefix, p->path);
                        break;
                case SOCKET_MQUEUE:
                        fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
                        break;
                default:
                        fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
                }
        }
 
        fprintf(f,
                "%sTriggerLimitIntervalSec: %s\n"
                "%sTriggerLimitBurst: %u\n"
                "%sPollLimitIntervalSec: %s\n"
                "%sPollLimitBurst: %u\n",
                prefix, FORMAT_TIMESPAN(s->trigger_limit.interval, USEC_PER_SEC),
                prefix, s->trigger_limit.burst,
                prefix, FORMAT_TIMESPAN(s->poll_limit.interval, USEC_PER_SEC),
                prefix, s->poll_limit.burst);
 
        str = ip_protocol_to_name(s->socket_protocol);
        if (str)
                fprintf(f, "%sSocketProtocol: %s\n", prefix, str);
 
        if (!strv_isempty(s->symlinks)) {
                fprintf(f, "%sSymlinks:", prefix);
                STRV_FOREACH(q, s->symlinks)
                        fprintf(f, " %s", *q);
 
                fprintf(f, "\n");
        }
 
        fprintf(f,
                "%sTimeoutSec: %s\n",
                prefix, FORMAT_TIMESPAN(s->timeout_usec, USEC_PER_SEC));
 
        exec_context_dump(&s->exec_context, f, prefix);
        kill_context_dump(&s->kill_context, f, prefix);
 
        for (SocketExecCommand c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
                if (!s->exec_command[c])
                        continue;
 
                fprintf(f, "%s%s %s:\n",
                        prefix, glyph(GLYPH_ARROW_RIGHT), socket_exec_command_to_string(c));
 
                exec_command_dump_list(s->exec_command[c], f, prefix2);
        }
 
        cgroup_context_dump(UNIT(s), f, prefix);
}
 
static int instance_from_socket(
                int fd,
                unsigned nr,
                char **ret) {
 
        union sockaddr_union local, remote;
        socklen_t l;
        int r;
 
        assert(fd >= 0);
        assert(ret);
 
        l = sizeof(local);
        if (getsockname(fd, &local.sa, &l) < 0)
                return -errno;
 
        l = sizeof(remote);
        if (getpeername(fd, &remote.sa, &l) < 0)
                return -errno;
 
        uint64_t cookie;
        r = socket_get_cookie(fd, &cookie);
        if (r < 0)
                return r;
 
        char *s;
 
        switch (local.sa.sa_family) {
 
        case AF_INET: {
                uint32_t
                        a = be32toh(local.in.sin_addr.s_addr),
                        b = be32toh(remote.in.sin_addr.s_addr);
 
                s = asprintf_safe(
                                "%u-%" PRIu64 "-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
                                nr,
                                cookie,
                                a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
                                be16toh(local.in.sin_port),
                                b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
                                be16toh(remote.in.sin_port));
                break;
        }
 
        case AF_INET6: {
                static const unsigned char ipv4_prefix[] = {
                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
                };
 
                if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
                    memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
                        const uint8_t
                                *a = local.in6.sin6_addr.s6_addr+12,
                                *b = remote.in6.sin6_addr.s6_addr+12;
 
                        s = asprintf_safe(
                                        "%u-%" PRIu64 "-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
                                        nr,
                                        cookie,
                                        a[0], a[1], a[2], a[3],
                                        be16toh(local.in6.sin6_port),
                                        b[0], b[1], b[2], b[3],
                                        be16toh(remote.in6.sin6_port));
                } else
                        s = asprintf_safe(
                                        "%u-%" PRIu64 "-%s:%u-%s:%u",
                                        nr,
                                        cookie,
                                        IN6_ADDR_TO_STRING(&local.in6.sin6_addr),
                                        be16toh(local.in6.sin6_port),
                                        IN6_ADDR_TO_STRING(&remote.in6.sin6_addr),
                                        be16toh(remote.in6.sin6_port));
                break;
        }
 
        case AF_UNIX: {
                struct ucred ucred;
 
                r = getpeercred(fd, &ucred);
                if (r >= 0) {
                        _cleanup_close_ int pidfd = getpeerpidfd(fd);
                        uint64_t pidfd_id;
 
                        if (pidfd >= 0 && pidfd_get_inode_id(pidfd, &pidfd_id) >= 0)
                                s = asprintf_safe(
                                                "%u-%" PRIu64 "-" PID_FMT "_%" PRIu64 "-" UID_FMT,
                                                nr, cookie, ucred.pid, pidfd_id, ucred.uid);
                        else
                                s = asprintf_safe(
                                                "%u-%" PRIu64 "-" PID_FMT "-" UID_FMT,
                                                nr, cookie, ucred.pid, ucred.uid);
                } else if (r == -ENODATA)
                        /* This handles the case where somebody is connecting from another pid/uid namespace
                         * (e.g. from outside of our container). */
                        s = asprintf_safe("%u-%" PRIu64 "-unknown", nr, cookie);
                else
                        return r;
                break;
        }
 
        case AF_VSOCK:
                s = asprintf_safe(
                                "%u-%" PRIu64 "-%u:%u-%u:%u",
                                nr,
                                cookie,
                                local.vm.svm_cid, local.vm.svm_port,
                                remote.vm.svm_cid, remote.vm.svm_port);
                break;
 
        default:
                assert_not_reached();
        }
 
        if (!s)
                return -ENOMEM;
 
        *ret = s;
        return 0;
}
 
static void socket_close_fds(Socket *s) {
        assert(s);
 
        LIST_FOREACH(port, p, s->ports) {
                bool was_open = p->fd >= 0;
 
                p->event_source = sd_event_source_disable_unref(p->event_source);
                p->fd = safe_close(p->fd);
                socket_port_close_auxiliary_fds(p);
 
                /* One little note: we should normally not delete any sockets in the file system here! After all some
                 * other process we spawned might still have a reference of this fd and wants to continue to use
                 * it. Therefore we normally delete sockets in the file system before we create a new one, not after we
                 * stopped using one! That all said, if the user explicitly requested this, we'll delete them here
                 * anyway, but only then. */
 
                if (!was_open || !s->remove_on_stop)
                        continue;
 
                switch (p->type) {
 
                case SOCKET_FIFO:
                        (void) unlink(p->path);
                        break;