HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/nsresourced/nsresourcework.c

113,568 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 464f373f21773862291bc192c5f28a0b78e42b97

Lines 2001–2683 of 2,683

        _cleanup_close_ int lock_fd = -EBADF;
        lock_fd = userns_registry_lock(registry_dir_fd);
        if (lock_fd < 0)
                return lock_fd;
 
        r = userns_registry_load_by_userns_inode(
                        registry_dir_fd,
                        userns_st.st_ino,
                        &userns_info);
        if (r == -ENOENT)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.UserNamespaceNotRegistered", NULL);
        if (r < 0)
                return r;
 
        r = userns_info_verify_fd(userns_fd, userns_info);
        if (r == -ESTALE)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.UserNamespaceNotRegistered", NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to verify user namespace identity: %m");
 
        /* The user namespace must have a user assigned */
        if (userns_info->size == 0)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.UserNamespaceWithoutUserRange", NULL);
        if (userns_info_has_cgroup(userns_info, cgroup_id))
                return sd_varlink_error(link, "io.systemd.NamespaceResource.ControlGroupAlreadyAdded", NULL);
        if (userns_info->n_cgroups > USER_NAMESPACE_CGROUPS_DELEGATE_MAX)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.TooManyControlGroups", NULL);
 
        /* Registering a cgroup for this client is only allowed for the root or the owner of a userns */
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return log_debug_errno(r, "Failed to get connection peer: %m");
        if (peer_uid != 0) {
                if (peer_uid != userns_info->owner)
                        return sd_varlink_error(link, SD_VARLINK_ERROR_PERMISSION_DENIED, NULL);
 
                /* The cgroup must be owned by the owner of the userns */
                if (cgroup_st.st_uid != userns_info->owner)
                        return sd_varlink_error(link, SD_VARLINK_ERROR_PERMISSION_DENIED, NULL);
        }
 
        r = userns_info_add_cgroup(userns_info, cgroup_id);
        if (r < 0)
                return r;
 
        r = userns_registry_store(registry_dir_fd, userns_info);
        if (r < 0)
                return r;
 
        if (fchown(cgroup_fd, userns_info->start_uid, userns_info->start_gid) < 0)
                return log_debug_errno(errno, "Failed to change ownership of cgroup: %m");
 
        if (fchmod(cgroup_fd, 0755) < 0)
                return log_debug_errno(errno, "Failed to change access mode of cgroup: %m");
 
        FOREACH_STRING(attr, "cgroup.procs", "cgroup.subtree_control", "cgroup.threads") {
                (void) fchmodat(cgroup_fd, attr, 0644, AT_SYMLINK_NOFOLLOW);
                (void) fchownat(cgroup_fd, attr, userns_info->start_uid, userns_info->start_gid, AT_SYMLINK_NOFOLLOW);
        }
 
        log_debug("Granting ownership to cgroup %" PRIu64 " to userns " INO_FMT " ('%s' @ UID " UID_FMT ")",
                  cgroup_id, userns_st.st_ino, userns_info->name, userns_info->start_uid);
 
        return sd_varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
}
 
static uint64_t hash_ifname_id(UserNamespaceInfo *userns_info, const char *ifname) {
        struct siphash state;
 
        assert(userns_info);
 
        siphash24_init(&state, (const uint8_t[]) { 0xc4, 0x6c, 0x96, 0xe8, 0xad, 0x37, 0x4d, 0x5f, 0xa1, 0xae, 0xfe, 0x70, 0x40, 0xed, 0x41, 0x5f });
        siphash24_compress_string(userns_info->name, &state);
        siphash24_compress_byte(0, &state); /* separator */
        siphash24_compress_string(strempty(ifname), &state);
 
        return siphash24_finalize(&state);
}
 
static void hash_ether_addr(UserNamespaceInfo *userns_info, const char *ifname, uint64_t n, struct ether_addr *ret) {
        struct siphash state;
        uint64_t h;
 
        assert(userns_info);
        assert(ret);
 
        siphash24_init(&state, (const uint8_t[]) { 0x36, 0xaa, 0xd1, 0x69, 0xc7, 0xe5, 0x4c, 0xaa, 0x1e, 0xb2, 0x9e, 0xb3, 0x3a, 0x6b, 0xd4, 0x71 });
        siphash24_compress_string(userns_info->name, &state);
        siphash24_compress_byte(0, &state); /* separator */
        siphash24_compress_string(strempty(ifname), &state);
        siphash24_compress_byte(0, &state); /* separator */
        n = htole64(n); /* add the 'index' to the mix in an endianness-independent fashion */
        siphash24_compress_typesafe(n, &state);
 
        h = htole64(siphash24_finalize(&state));
 
        assert(sizeof(h) >= sizeof_field(struct ether_addr, ether_addr_octet));
 
        memcpy(ret->ether_addr_octet, &h, sizeof_field(struct ether_addr, ether_addr_octet));
        ether_addr_mark_random(ret);
}
 
static int create_veth(
                int netns_fd,
                const char *ifname_host,
                const char *altifname_host,
                struct ether_addr *mac_host,
                const char *ifname_namespace,
                struct ether_addr *mac_namespace) {
 
        int r;
 
        assert(netns_fd >= 0);
        assert(ifname_host);
        assert(mac_host);
        assert(ifname_namespace);
        assert(mac_namespace);
 
        log_debug("Creating veth link on host %s (%s) with address %s to container as %s with address %s",
                  ifname_host, strna(altifname_host), ETHER_ADDR_TO_STR(mac_host),
                  ifname_namespace, ETHER_ADDR_TO_STR(mac_namespace));
 
        _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
        r = sd_netlink_open(&rtnl);
        if (r < 0)
                return log_error_errno(r, "Failed to allocation netlink connection: %m");
 
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
        r = sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate netlink message: %m");
 
        r = sd_netlink_message_append_string(m, IFLA_IFNAME, ifname_host);
        if (r < 0)
                return log_error_errno(r, "Failed to add netlink interface name: %m");
 
        r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, mac_host);
        if (r < 0)
                return log_error_errno(r, "Failed to add netlink MAC address: %m");
 
        r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
        if (r < 0)
                return log_error_errno(r, "Failed to open netlink container: %m");
 
        r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "veth");
        if (r < 0)
                return log_error_errno(r, "Failed to open netlink container: %m");
 
        r = sd_netlink_message_open_container(m, VETH_INFO_PEER);
        if (r < 0)
                return log_error_errno(r, "Failed to open netlink container: %m");
 
        r = sd_netlink_message_append_string(m, IFLA_IFNAME, ifname_namespace);
        if (r < 0)
                return log_error_errno(r, "Failed to add netlink interface name: %m");
 
        r = sd_netlink_message_append_ether_addr(m, IFLA_ADDRESS, mac_namespace);
        if (r < 0)
                return log_error_errno(r, "Failed to add netlink MAC address: %m");
 
        r = sd_netlink_message_append_u32(m, IFLA_NET_NS_FD, netns_fd);
        if (r < 0)
                return log_error_errno(r, "Failed to add netlink namespace field: %m");
 
        r = sd_netlink_message_close_container(m);
        if (r < 0)
                return log_error_errno(r, "Failed to close netlink container: %m");
 
        r = sd_netlink_message_close_container(m);
        if (r < 0)
                return log_error_errno(r, "Failed to close netlink container: %m");
 
        r = sd_netlink_message_close_container(m);
        if (r < 0)
                return log_error_errno(r, "Failed to close netlink container: %m");
 
        r = sd_netlink_call(rtnl, m, 0, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to add new veth interfaces (%s:%s): %m", ifname_host, ifname_namespace);
 
        r = rtnl_set_link_alternative_names_by_ifname(&rtnl, ifname_host, STRV_MAKE(altifname_host));
        if (r < 0)
                log_warning_errno(r, "Failed to set alternative interface name to '%s', ignoring: %m", altifname_host);
 
        return 0;
}
 
static int create_tap(
                int userns_fd,
                const char *ifname_host,
                char *const *altifname_host,
                struct ether_addr *mac_host) {
 
        int r;
 
        assert(ifname_host);
        assert(mac_host);
 
        if (!ifname_valid(ifname_host))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", ifname_host);
 
        log_debug("Creating tap link on host %s (%s) with address %s",
                  ifname_host, strna(altifname_host ? altifname_host[0] : NULL), ETHER_ADDR_TO_STR(mac_host));
 
        _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
        if (altifname_host) {
                r = sd_netlink_open(&rtnl);
                if (r < 0)
                        return log_error_errno(r, "Failed to allocate netlink connection: %m");
        }
 
        uid_t uid;
        r = userns_get_base_uid(userns_fd, &uid, /* ret_gid= */ NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to get namespace base UID/GID: %m");
 
        struct ifreq ifr = {
                .ifr_flags = IFF_TAP | IFF_NO_PI | IFF_VNET_HDR,
        };
 
        assert(strlen(ifname_host) < sizeof(ifr.ifr_name));
        strcpy(ifr.ifr_name, ifname_host);
 
        _cleanup_close_ int fd = open("/dev/net/tun", O_RDWR|O_CLOEXEC);
        if (fd < 0) {
                if (errno == ENOENT) /* Turn ENOENT → EOPNOTSUPP */
                        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Network tap device node /dev/net/tun not found, cannot create network interface.");
 
                return log_error_errno(errno, "Failed to open %s: %m", "/dev/net/tun");
        }
 
        if (ioctl(fd, TUNSETIFF, &ifr) < 0)
                return log_error_errno(errno, "TUNSETIFF failed: %m");
 
        if (ioctl(fd, TUNSETOWNER, uid) < 0)
                return log_error_errno(errno, "TUNSETOWNER failed: %m");
 
        if (!strv_isempty(altifname_host)) {
                r = rtnl_set_link_alternative_names_by_ifname(&rtnl, ifname_host, altifname_host);
                if (r < 0)
                        log_warning_errno(r, "Failed to set alternative interface names, ignoring: %m");
        }
 
        return TAKE_FD(fd);
}
 
static int validate_netns(sd_varlink *link, int userns_fd, int netns_fd) {
        int r;
 
        assert(link);
        assert(userns_fd >= 0);
        assert(netns_fd >= 0);
 
        r = fd_verify_safe_flags(netns_fd);
        if (r < 0)
                return log_debug_errno(r, "Network namespace file descriptor has unsafe flags set: %m");
 
        /* Validate this is actually a valid network namespace fd */
        r = fd_is_namespace(netns_fd, NAMESPACE_NET);
        if (r < 0)
                return r;
        if (r == 0)
                return sd_varlink_error_invalid_parameter_name(link, "networkNamespaceFileDescriptor");
 
        /* And refuse the thing if it is our own */
        r = is_our_namespace(netns_fd, NAMESPACE_NET);
        if (r < 0)
                return r;
        if (r > 0)
                return sd_varlink_error_invalid_parameter_name(link, "networkNamespaceFileDescriptor");
 
        /* Check if the netns actually belongs to the userns */
        _cleanup_close_ int owner_userns_fd = -EBADF;
        owner_userns_fd = ioctl(netns_fd, NS_GET_USERNS);
        if (owner_userns_fd < 0)
                return -errno;
 
        r = inode_same_at(owner_userns_fd, /* filea= */ NULL, userns_fd, /* fileb= */ NULL, AT_EMPTY_PATH);
        if (r < 0)
                return r;
        if (r == 0)
                return sd_varlink_error_invalid_parameter_name(link, "networkNamespaceFileDescriptor");
 
        uid_t peer_uid;
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return r;
 
        if (peer_uid != 0) {
                /* Refuse if the netns is not actually owned by our client. */
 
                uid_t owner_uid;
                if (ioctl(owner_userns_fd, NS_GET_OWNER_UID, &owner_uid) < 0)
                        return -errno;
 
                if (owner_uid != peer_uid)
                        return sd_varlink_error_invalid_parameter_name(link, "networkNamespaceFileDescriptor");
        }
 
        return 0;
}
 
typedef struct AddNetworkParameters {
        unsigned userns_fd_idx;
        unsigned netns_fd_idx;
        const char *ifname;
        const char *mode;
} AddNetworkParameters;
 
static int vl_method_add_netif_to_user_namespace(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        static const sd_json_dispatch_field parameter_dispatch_table[] = {
                { "userNamespaceFileDescriptor",    _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint,         offsetof(AddNetworkParameters, userns_fd_idx), SD_JSON_MANDATORY },
                { "networkNamespaceFileDescriptor", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint,         offsetof(AddNetworkParameters, netns_fd_idx),  0                 },
                { "namespaceInterfaceName",         SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(AddNetworkParameters, ifname),        0                 },
                { "mode",                           SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(AddNetworkParameters, mode),          SD_JSON_MANDATORY },
                {}
        };
 
        _cleanup_close_ int userns_fd = -EBADF, netns_fd = -EBADF, registry_dir_fd = -EBADF;
        Context *c = ASSERT_PTR(userdata);
        AddNetworkParameters p = {
                .userns_fd_idx = UINT_MAX,
                .netns_fd_idx = UINT_MAX,
        };
        int r;
 
        assert(link);
        assert(parameters);
 
        r = test_userns_api_support(link);
        if (r != 0)
                return r;
 
        r = sd_varlink_dispatch(link, parameters, parameter_dispatch_table, &p);
        if (r != 0)
                return r;
 
        userns_fd = sd_varlink_peek_dup_fd(link, p.userns_fd_idx);
        if (userns_fd < 0)
                return userns_fd;
 
        r = validate_userns(link, userns_fd);
        if (r != 0)
                return r;
 
        struct stat userns_st;
        if (fstat(userns_fd, &userns_st) < 0)
                return -errno;
 
        if (p.netns_fd_idx != UINT_MAX) {
                netns_fd = sd_varlink_peek_dup_fd(link, p.netns_fd_idx);
                if (netns_fd < 0)
                        return netns_fd;
 
                r = validate_netns(link, userns_fd, netns_fd);
                if (r != 0)
                        return r;
        }
 
        if (p.ifname && !ifname_valid(p.ifname))
                return sd_varlink_error_invalid_parameter_name(link, "interfaceName");
 
        if (streq(p.mode, "veth")) {
                /* In veth mode we need a netns */
 
                if (netns_fd < 0)
                        return sd_varlink_error_invalid_parameter_name(link, "networkNamespaceFileDescriptor");
 
        } else if (streq(p.mode, "tap")) {
                /* In tap mode we do want a netns, nor an interface name for it */
 
                if (p.ifname)
                        return sd_varlink_error_invalid_parameter_name(link, "namespaceInterfaceName");
 
                if (netns_fd >= 0)
                        return sd_varlink_error_invalid_parameter_name(link, "networkNamespaceFileDescriptor");
        } else
                return sd_varlink_error_invalid_parameter_name(link, "mode");
 
        const char *polkit_details[] = {
                "type", p.mode,
                NULL,
        };
 
        r = varlink_verify_polkit_async_full(
                        link,
                        /* bus= */ NULL,
                        "io.systemd.namespace-resource.delegate-network-interface",
                        polkit_details,
                        /* good_user= */ UID_INVALID,
                        POLKIT_DEFAULT_ALLOW, /* If no polkit is installed, allow delegation of network interfaces to registered userns */
                        &c->polkit_registry,
                        /* ret_admin= */ NULL);
        if (r <= 0)
                return r;
 
        registry_dir_fd = userns_registry_open_fd();
        if (registry_dir_fd < 0)
                return registry_dir_fd;
 
        _cleanup_close_ int lock_fd = userns_registry_lock(registry_dir_fd);
        if (lock_fd < 0)
                return log_debug_errno(lock_fd, "Failed to open nsresource registry lock file: %m");
 
        _cleanup_(userns_info_freep) UserNamespaceInfo *userns_info = NULL;
        r = userns_registry_load_by_userns_inode(
                        registry_dir_fd,
                        userns_st.st_ino,
                        &userns_info);
        if (r == -ENOENT)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.UserNamespaceNotRegistered", NULL);
        if (r < 0)
                return r;
 
        r = userns_info_verify_fd(userns_fd, userns_info);
        if (r == -ESTALE)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.UserNamespaceNotRegistered", NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to verify user namespace identity: %m");
 
        if (strv_length(userns_info->netifs) > USER_NAMESPACE_NETIFS_DELEGATE_MAX)
                return sd_varlink_error(link, "io.systemd.NamespaceResource.TooManyNetworkInterfaces", NULL);
 
        /* Registering a network interface for this client is only allowed for the root or the owner of a userns */
        uid_t peer_uid;
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return r;
        if (peer_uid != 0 && peer_uid != userns_info->owner)
                return sd_varlink_error(link, SD_VARLINK_ERROR_PERMISSION_DENIED, NULL);
 
        _cleanup_free_ char *ifname_host = NULL, *altifname_host = NULL;
        const char *ifname_namespace = p.ifname ?: "host0";
 
        /* The short ifname is just too short to generate readable and unique names where unprivileged users
         * can't take each others names. Hence just hash it. The alternative name however contains more useful
         * information. */
        if (asprintf(&ifname_host, "ns-%08" PRIx64, hash_ifname_id(userns_info, p.ifname)) < 0)
                return -ENOMEM;
        strshorten(ifname_host, IFNAMSIZ-1);
 
        /* Register the interface in the userns store first, so that we can be sure it's properly 'owned' at
         * any time, in case setup fails for some reason. Given we the interface name is hashed accidental
         * collisions should be unlikely. */
        r = userns_info_add_netif(userns_info, ifname_host);
        if (r < 0)
                return r;
 
        r = userns_registry_store(registry_dir_fd, userns_info);
        if (r < 0)
                return r;
 
        if (p.ifname)
                r = asprintf(&altifname_host, "ns-" UID_FMT "-%s-%s", userns_info->owner, userns_info->name, p.ifname);
        else
                r = asprintf(&altifname_host, "ns-" UID_FMT "-%s", userns_info->owner, userns_info->name);
        if (r < 0)
                return -ENOMEM;
 
        if (!ifname_valid_full(altifname_host, IFNAME_VALID_ALTERNATIVE))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Generated alternative interface name not valid: %s", altifname_host);
 
        struct ether_addr ether_addr_host;
        hash_ether_addr(userns_info, p.ifname, 0, &ether_addr_host);
 
        if (streq(p.mode, "veth")) {
                struct ether_addr ether_addr_namespace;
                hash_ether_addr(userns_info, p.ifname, 1, &ether_addr_namespace);
 
                r = create_veth(netns_fd,
                                ifname_host, altifname_host, &ether_addr_host,
                                ifname_namespace, &ether_addr_namespace);
                if (r < 0)
                        return r;
 
                log_debug("Added veth tunnel %s from host to userns " INO_FMT " ('%s' @ UID " UID_FMT ", interface %s).",
                          ifname_host, userns_st.st_ino, userns_info->name, userns_info->start_uid, ifname_namespace);
 
                return sd_varlink_replybo(
                                link,
                                SD_JSON_BUILD_PAIR_STRING("hostInterfaceName", ifname_host),
                                SD_JSON_BUILD_PAIR_STRING("namespaceInterfaceName", ifname_namespace));
 
        } else if (streq(p.mode, "tap")) {
                /* NB: when we do the "tap" stuff we do not actually do any namespace operation here, neither
                 * netns nor userns. We use the userns only as conduit for user identity information and
                 * indication that the calling user has some control over the UID they want to assign the tap
                 * device to. */
 
                _cleanup_close_ int tap_fd = create_tap(userns_fd, ifname_host, STRV_MAKE(altifname_host), &ether_addr_host);
                if (tap_fd < 0)
                        return tap_fd;
 
                log_debug("Added tap device %s from host to userns " INO_FMT " ('%s' @ UID " UID_FMT ").",
                          ifname_host, userns_st.st_ino, userns_info->name, userns_info->start_uid);
 
                int fd_index = sd_varlink_push_fd(link, tap_fd);
                if (fd_index < 0)
                        return log_error_errno(fd_index, "Failed to push tap fd into varlink socket: %m");
 
                TAKE_FD(tap_fd);
 
                return sd_varlink_replybo(
                                link,
                                SD_JSON_BUILD_PAIR_STRING("hostInterfaceName", ifname_host),
                                SD_JSON_BUILD_PAIR_INTEGER("interfaceFileDescriptor", fd_index));
        } else
                assert_not_reached();
}
 
static int process_connection(sd_varlink_server *server, int _fd) {
        _cleanup_close_ int fd = TAKE_FD(_fd); /* always take possession */
        _cleanup_(sd_varlink_close_unrefp) sd_varlink *vl = NULL;
        _cleanup_(sd_event_unrefp) sd_event *event = NULL;
        int r;
 
        assert(server);
        assert(fd >= 0);
 
        r = sd_event_new(&event);
        if (r < 0)
                return r;
 
        r = sd_varlink_server_attach_event(server, event, /* priority= */ 0);
        if (r < 0)
                return log_error_errno(r, "Failed to attach Varlink server to event loop: %m");
 
        r = sd_varlink_server_add_connection(server, fd, &vl);
        if (r < 0)
                return log_error_errno(r, "Failed to add connection: %m");
 
        TAKE_FD(fd);
        vl = sd_varlink_ref(vl);
 
        r = sd_event_loop(event);
        if (r < 0)
                return log_error_errno(r, "Failed to run event loop: %m");
 
        r = sd_varlink_server_detach_event(server);
        if (r < 0)
                return log_error_errno(r, "Failed to detach Varlink server from event loop: %m");
 
        return 0;
}
 
static void context_free(Context *c) {
        assert(c);
 
        c->polkit_registry = hashmap_free(c->polkit_registry);
        c->bpf = userns_restrict_bpf_free(c->bpf);
}
 
static int run(int argc, char *argv[]) {
        usec_t start_time, listen_idle_usec, last_busy_usec = USEC_INFINITY;
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *server = NULL;
        _cleanup_(context_free) Context c = {};
        _cleanup_(pidref_done) PidRef parent = PIDREF_NULL;
        unsigned n_iterations = 0;
        int m, listen_fd, r;
 
        log_setup();
 
        m = sd_listen_fds(false);
        if (m < 0)
                return log_error_errno(m, "Failed to determine number of listening fds: %m");
        if (m == 0)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No socket to listen on received.");
        if (m > 1)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Worker can only listen on a single socket at a time.");
 
        listen_fd = SD_LISTEN_FDS_START;
 
        r = fd_nonblock(listen_fd, false);
        if (r < 0)
                return log_error_errno(r, "Failed to turn off non-blocking mode for listening socket: %m");
 
        r = varlink_server_new(
                        &server,
                        SD_VARLINK_SERVER_INHERIT_USERDATA|
                        SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT|SD_VARLINK_SERVER_ALLOW_FD_PASSING_OUTPUT,
                        &c);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate varlink server: %m");
 
        r = sd_varlink_server_add_interface_many(
                        server,
                        &vl_interface_io_systemd_NamespaceResource,
                        &vl_interface_io_systemd_UserDatabase);
        if (r < 0)
                return log_error_errno(r, "Failed to add UserDatabase and NamespaceResource interface to varlink server: %m");
 
        r = sd_varlink_server_bind_method_many(
                        server,
                        "io.systemd.NamespaceResource.AllocateUserRange",              vl_method_allocate_user_range,
                        "io.systemd.NamespaceResource.RegisterUserNamespace",          vl_method_register_user_namespace,
                        "io.systemd.NamespaceResource.AddMountToUserNamespace",        vl_method_add_mount_to_user_namespace,
                        "io.systemd.NamespaceResource.AddControlGroupToUserNamespace", vl_method_add_cgroup_to_user_namespace,
                        "io.systemd.NamespaceResource.AddNetworkToUserNamespace",      vl_method_add_netif_to_user_namespace,
                        "io.systemd.UserDatabase.GetUserRecord",                       vl_method_get_user_record,
                        "io.systemd.UserDatabase.GetGroupRecord",                      vl_method_get_group_record,
                        "io.systemd.UserDatabase.GetMemberships",                      vl_method_get_memberships);
        if (r < 0)
                return log_error_errno(r, "Failed to bind methods: %m");
 
        r = sd_varlink_server_set_exit_on_idle(server, true);
        if (r < 0)
                return log_error_errno(r, "Failed to enable exit-on-idle mode: %m");
 
        r = getenv_bool("NSRESOURCE_FIXED_WORKER");
        if (r < 0)
                return log_error_errno(r, "Failed to parse NSRESOURCE_FIXED_WORKER: %m");
        listen_idle_usec = r ? USEC_INFINITY : LISTEN_IDLE_USEC;
 
        r = pidref_set_parent(&parent);
        if (r < 0)
                return log_error_errno(r, "Failed to acquire pidfd of parent process: %m");
 
        start_time = now(CLOCK_MONOTONIC);
 
        for (;;) {
                _cleanup_close_ int fd = -EBADF;
                usec_t n;
 
                /* Exit the worker in regular intervals, to flush out all memory use */
                if (n_iterations++ > ITERATIONS_MAX) {
                        log_debug("Exiting worker, processed %u iterations, that's enough.", n_iterations);
                        break;
                }
 
                n = now(CLOCK_MONOTONIC);
                if (n >= usec_add(start_time, RUNTIME_MAX_USEC)) {
                        log_debug("Exiting worker, ran for %s, that's enough.",
                                  FORMAT_TIMESPAN(usec_sub_unsigned(n, start_time), 0));
                        break;
                }
 
                if (last_busy_usec == USEC_INFINITY)
                        last_busy_usec = n;
                else if (listen_idle_usec != USEC_INFINITY && n >= usec_add(last_busy_usec, listen_idle_usec)) {
                        log_debug("Exiting worker, been idle for %s.",
                                  FORMAT_TIMESPAN(usec_sub_unsigned(n, last_busy_usec), 0));
                        break;
                }
 
                (void) rename_process("systemd-nsresourcework: waiting...");
                fd = RET_NERRNO(accept4(listen_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC));
                (void) rename_process("systemd-nsresourcework: processing...");
 
                if (fd == -EAGAIN)
                        continue; /* The listening socket has SO_RECVTIMEO set, hence a timeout is expected
                                   * after a while, let's check if it's time to exit though. */
                if (fd == -EINTR)
                        continue; /* Might be that somebody attached via strace, let's just continue in that
                                   * case */
                if (fd < 0)
                        return log_error_errno(fd, "Failed to accept() from listening socket: %m");
 
                if (now(CLOCK_MONOTONIC) <= usec_add(n, PRESSURE_SLEEP_TIME_USEC)) {
                        /* We only slept a very short time? If so, let's see if there are more sockets
                         * pending, and if so, let's ask our parent for more workers */
 
                        r = fd_wait_for_event(listen_fd, POLLIN, 0);
                        if (r < 0)
                                return log_error_errno(r, "Failed to test for POLLIN on listening socket: %m");
 
                        if (FLAGS_SET(r, POLLIN)) {
                                r = pidref_kill(&parent, SIGUSR2);
                                if (r == -ESRCH)
                                        return log_error_errno(r, "Parent already died?");
                                if (r < 0)
                                        return log_error_errno(r, "Failed to send SIGUSR2 signal to parent: %m");
                        }
                }
 
                (void) process_connection(server, TAKE_FD(fd));
                last_busy_usec = USEC_INFINITY;
        }
 
        return 0;
}
 
DEFINE_MAIN_FUNCTION(run);