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 2001–3000 of 3,800

 
        /* Note that ExecStartPre= command doesn't inherit any FDs. It runs before we open listen FDs. */
        if (s->pass_fds_to_exec) {
                _cleanup_strv_free_ char **fd_names = NULL;
                _cleanup_free_ int *fds = NULL;
                int n_fds;
 
                n_fds = socket_collect_fds(s, &fds);
                if (n_fds < 0)
                        return n_fds;
 
                r = strv_extend_n(&fd_names, socket_fdname(s), n_fds);
                if (r < 0)
                        return r;
 
                exec_params.fds = TAKE_PTR(fds);
                exec_params.fd_names = TAKE_PTR(fd_names);
                exec_params.n_socket_fds = n_fds;
        }
 
        r = exec_spawn(UNIT(s),
                       c,
                       &s->exec_context,
                       &exec_params,
                       s->exec_runtime,
                       &s->cgroup_context,
                       &pidref);
        if (r < 0)
                return r;
 
        r = unit_watch_pidref(UNIT(s), &pidref, /* exclusive= */ true);
        if (r < 0)
                return r;
 
        *ret_pid = TAKE_PIDREF(pidref);
        return 0;
}
 
static int socket_chown(Socket *s, PidRef *ret_pid) {
        _cleanup_(pidref_done) PidRef pid = PIDREF_NULL;
        int r;
 
        assert(s);
        assert(ret_pid);
 
        r = socket_arm_timer(s, /* relative= */ true, s->timeout_usec);
        if (r < 0)
                return r;
 
        /* We have to resolve the user names out-of-process, hence
         * let's fork here. It's messy, but well, what can we do? */
 
        r = unit_fork_helper_process(UNIT(s), "(sd-chown)", /* into_cgroup= */ true, &pid);
        if (r < 0)
                return r;
        if (r == 0) {
                uid_t uid = UID_INVALID;
                gid_t gid = GID_INVALID;
 
                /* Child */
 
                if (!isempty(s->user)) {
                        r = get_user_creds(s->user, /* flags= */ 0, NULL, &uid, &gid, NULL, NULL);
                        if (r < 0) {
                                log_unit_error_errno(UNIT(s), r,
                                                     "Failed to resolve user '%s': %s",
                                                     s->user, STRERROR_USER(r));
                                _exit(EXIT_USER);
                        }
                }
 
                if (!isempty(s->group)) {
                        r = get_group_creds(s->group, /* flags= */ 0, /* ret_name= */ NULL, &gid);
                        if (r < 0) {
                                log_unit_error_errno(UNIT(s), r,
                                                     "Failed to resolve group '%s': %s",
                                                     s->group, STRERROR_GROUP(r));
                                _exit(EXIT_GROUP);
                        }
                }
 
                LIST_FOREACH(port, p, s->ports) {
                        const char *path = NULL;
 
                        if (p->type == SOCKET_SOCKET)
                                path = socket_address_get_path(&p->address);
                        else if (p->type == SOCKET_FIFO)
                                path = p->path;
                        else if (p->type == SOCKET_MQUEUE) {
                                /* Use fchown on the fd since /dev/mqueue might not be mounted. */
                                if (fchown(p->fd, uid, gid) < 0) {
                                        log_unit_error_errno(UNIT(s), errno, "Failed to fchown(): %m");
                                        _exit(EXIT_CHOWN);
                                }
                                continue;
                        }
 
                        if (!path)
                                continue;
 
                        if (chown(path, uid, gid) < 0) {
                                log_unit_error_errno(UNIT(s), errno, "Failed to chown(): %m");
                                _exit(EXIT_CHOWN);
                        }
                }
 
                _exit(EXIT_SUCCESS);
        }
 
        r = unit_watch_pidref(UNIT(s), &pid, /* exclusive= */ true);
        if (r < 0)
                return r;
 
        *ret_pid = TAKE_PIDREF(pid);
        return 0;
}
 
static void socket_enter_dead(Socket *s, SocketResult f) {
        assert(s);
 
        if (s->result == SOCKET_SUCCESS || IN_SET(f, SOCKET_FAILURE_SERVICE_START_LIMIT_HIT, SOCKET_FAILURE_START_LIMIT_HIT))
                s->result = f;
 
        if (s->result == SOCKET_SUCCESS)
                unit_log_success(UNIT(s));
        else
                unit_log_failure(UNIT(s), socket_result_to_string(s->result));
 
        unit_warn_leftover_processes(UNIT(s), /* start= */ false);
 
        socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
 
        s->exec_runtime = exec_runtime_destroy(s->exec_runtime);
 
        unit_destroy_runtime_data(UNIT(s), &s->exec_context, /* destroy_runtime_dir= */ true);
 
        unit_unref_uid_gid(UNIT(s), true);
}
 
static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
 
static void socket_enter_stop_post(Socket *s, SocketResult f) {
        int r;
 
        assert(s);
 
        if (s->result == SOCKET_SUCCESS)
                s->result = f;
 
        socket_unwatch_control_pid(s);
        s->control_command_id = SOCKET_EXEC_STOP_POST;
        s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST];
 
        if (s->control_command) {
                r = socket_spawn(s, s->control_command, &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'stop-post' task: %m");
                        socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
                        return;
                }
 
                socket_set_state(s, SOCKET_STOP_POST);
        } else
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
}
 
static int state_to_kill_operation(Socket *s, SocketState state) {
        assert(s);
 
        if (state == SOCKET_STOP_PRE_SIGTERM)
                return unit_has_job_type(UNIT(s), JOB_RESTART) ? KILL_RESTART : KILL_TERMINATE;
 
        if (state == SOCKET_FINAL_SIGTERM)
                return KILL_TERMINATE;
 
        return KILL_KILL;
}
 
static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
        int r;
 
        assert(s);
 
        if (s->result == SOCKET_SUCCESS)
                s->result = f;
 
        r = unit_kill_context(UNIT(s), state_to_kill_operation(s, state));
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
                goto fail;
        }
        if (r > 0) {
                r = socket_arm_timer(s, /* relative= */ true, s->timeout_usec);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                        goto fail;
                }
 
                socket_set_state(s, state);
        } else if (state == SOCKET_STOP_PRE_SIGTERM)
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
        else if (state == SOCKET_STOP_PRE_SIGKILL)
                socket_enter_stop_post(s, SOCKET_SUCCESS);
        else if (state == SOCKET_FINAL_SIGTERM)
                socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
        else
                socket_enter_dead(s, SOCKET_SUCCESS);
 
        return;
 
fail:
        if (IN_SET(state, SOCKET_STOP_PRE_SIGTERM, SOCKET_STOP_PRE_SIGKILL))
                socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
        else
                socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
}
 
static void socket_enter_stop_pre(Socket *s, SocketResult f) {
        int r;
 
        assert(s);
 
        if (s->result == SOCKET_SUCCESS)
                s->result = f;
 
        socket_unwatch_control_pid(s);
        s->control_command_id = SOCKET_EXEC_STOP_PRE;
        s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE];
 
        if (s->control_command) {
                r = socket_spawn(s, s->control_command, &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'stop-pre' task: %m");
                        socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
                        return;
                }
 
                socket_set_state(s, SOCKET_STOP_PRE);
        } else
                socket_enter_stop_post(s, SOCKET_SUCCESS);
}
 
static void flush_ports(Socket *s) {
        assert(s);
 
        /* Flush all incoming traffic, regardless if actual bytes or new connections, so that this socket isn't busy
         * anymore */
 
        LIST_FOREACH(port, p, s->ports) {
                if (p->fd < 0)
                        continue;
 
                if (p->type == SOCKET_MQUEUE)
                        (void) flush_mqueue(p->fd);
                else {
                        (void) flush_accept(p->fd);
                        (void) flush_fd(p->fd);
                }
        }
}
 
static void socket_enter_listening(Socket *s) {
        int r;
 
        assert(s);
 
        if (!s->accept && s->flush_pending) {
                log_unit_debug(UNIT(s), "Flushing socket before listening.");
                flush_ports(s);
        }
 
        r = socket_watch_fds(s);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to watch sockets: %m");
                socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
                return;
        }
 
        socket_set_state(s, SOCKET_LISTENING);
}
 
static void socket_enter_start_post(Socket *s) {
        int r;
 
        assert(s);
 
        socket_unwatch_control_pid(s);
        s->control_command_id = SOCKET_EXEC_START_POST;
        s->control_command = s->exec_command[SOCKET_EXEC_START_POST];
 
        if (s->control_command) {
                r = socket_spawn(s, s->control_command, &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'start-post' task: %m");
                        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
                        return;
                }
 
                socket_set_state(s, SOCKET_START_POST);
        } else
                socket_enter_listening(s);
}
 
static void socket_enter_start_chown(Socket *s) {
        int r;
 
        assert(s);
        assert(s->state == SOCKET_START_OPEN);
 
        if (!isempty(s->user) || !isempty(s->group)) {
 
                socket_unwatch_control_pid(s);
                s->control_command_id = SOCKET_EXEC_START_CHOWN;
                s->control_command = NULL;
 
                r = socket_chown(s, &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'start-chown' task: %m");
                        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
                        return;
                }
 
                socket_set_state(s, SOCKET_START_CHOWN);
        } else
                socket_enter_start_post(s);
}
 
static void socket_enter_start_open(Socket *s) {
        int r;
 
        assert(s);
        assert(IN_SET(s->state, SOCKET_DEAD, SOCKET_FAILED, SOCKET_START_PRE));
 
        /* We force a state transition here even though we're not spawning any process (i.e. the state is purely
         * intermediate), so that failure of socket_open_fds() always causes a state change in unit_notify().
         * Otherwise, if no Exec*= is defined, we might go from previous SOCKET_FAILED to SOCKET_FAILED,
         * meaning the OnFailure= deps are unexpectedly skipped (#35635). */
 
        socket_set_state(s, SOCKET_START_OPEN);
 
        r = socket_open_fds(s);
        if (r < 0) {
                log_unit_error_errno(UNIT(s), r, "Failed to listen on sockets: %m");
                socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
                return;
        }
 
        socket_enter_start_chown(s);
}
 
static void socket_enter_start_pre(Socket *s) {
        int r;
 
        assert(s);
 
        socket_unwatch_control_pid(s);
 
        unit_warn_leftover_processes(UNIT(s), /* start= */ true);
 
        s->control_command_id = SOCKET_EXEC_START_PRE;
        s->control_command = s->exec_command[SOCKET_EXEC_START_PRE];
 
        if (s->control_command) {
                r = socket_spawn(s, s->control_command, &s->control_pid);
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to spawn 'start-pre' task: %m");
                        socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
                        return;
                }
 
                socket_set_state(s, SOCKET_START_PRE);
        } else
                socket_enter_start_open(s);
}
 
static bool socket_may_defer(Socket *s) {
        assert(s);
 
        switch (s->defer_trigger) {
 
        case SOCKET_DEFER_NO:
                return false;
 
        case SOCKET_DEFER_YES:
                return !hashmap_isempty(UNIT(s)->manager->jobs);
 
        case SOCKET_DEFER_PATIENT:
                assert(s->defer_trigger_max_usec > 0);
                return true;
 
        default:
                assert_not_reached();
        }
}
 
static bool socket_stop_notify(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;
 
        assert(s->state == SOCKET_DEFERRED);
 
        r = manager_add_job(u->manager, JOB_START, UNIT_DEREF(s->service), JOB_LENIENT, &error, /* ret= */ NULL);
        if (r >= 0) { /* Yay! */
                socket_set_state(s, SOCKET_RUNNING);
                return true; /* changed */
        }
        if (sd_bus_error_has_name(&error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE)) {
                if (s->defer_trigger == SOCKET_DEFER_PATIENT || !hashmap_isempty(u->manager->jobs))
                        /* Wait for some more */
                        return false;
 
                log_unit_warning_errno(u, r, "Service conflicts with active units even after all jobs have completed, giving up.");
        } else
                log_unit_warning_errno(u, r, "Failed to queue service startup job: %s", bus_error_message(&error, r));
 
        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
        return true; /* changed */
}
 
static void socket_enter_deferred(Socket *s) {
        int r;
 
        assert(s);
        assert(socket_may_defer(s));
 
        /* So here's the thing: if there're currently units conflicting with the service we shall be
         * triggering, and the previous transaction is still running (job pool is not empty), let's
         * defer the activation a bit, and recheck upon any unit stop. IOW, the trigger in question
         * becomes bound to the conflicting dependency, and not the socket IO because we never process them.
         * Put a safety net around all this though, i.e. give up if the service still can't be started
         * even after all existing jobs have completed, or DeferTriggerMaxSec= is reached. */
 
        r = socket_arm_timer(s, /* relative= */ true, s->defer_trigger_max_usec);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to install timer: %m");
                return socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
        }
 
        unit_add_to_stop_notify_queue(UNIT(s));
 
        /* Disable IO event sources */
        socket_set_state(s, SOCKET_DEFERRED);
}
 
static void socket_enter_running(Socket *s, int cfd_in) {
        /* Note that this call takes possession of the connection fd passed. It either has to assign it
         * somewhere or close it. */
        _cleanup_close_ int cfd = cfd_in;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        int r;
 
        assert(s);
 
        /* We don't take connections anymore if we are supposed to shut down anyway */
        if (unit_stop_pending(UNIT(s))) {
 
                log_unit_debug(UNIT(s), "Suppressing connection request since unit stop is scheduled.");
 
                if (cfd >= 0)
                        goto refuse;
 
                flush_ports(s);
                return;
        }
 
        if (s->state == SOCKET_DEFERRED) {
                assert(cfd < 0);
                return;
        }
 
        if (!ratelimit_below(&s->trigger_limit)) {
                log_unit_warning(UNIT(s), "Trigger limit hit, refusing further activation.");
                socket_enter_stop_pre(s, SOCKET_FAILURE_TRIGGER_LIMIT_HIT);
                goto refuse;
        }
 
        if (cfd < 0) { /* Accept=no case */
                bool pending = false;
                Unit *other;
 
                /* If there's already a start pending don't bother to do anything */
                UNIT_FOREACH_DEPENDENCY(other, UNIT(s), UNIT_ATOM_TRIGGERS)
                        if (unit_active_or_pending(other)) {
                                pending = true;
                                break;
                        }
 
                if (!pending) {
                        if (!UNIT_ISSET(s->service)) {
                                log_unit_warning(UNIT(s),
                                                 "Service to activate vanished, refusing activation.");
                                goto fail;
                        }
 
                        if (s->defer_trigger != SOCKET_DEFER_NO) {
                                r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_LENIENT, &error, /* ret= */ NULL);
                                if (r < 0 && sd_bus_error_has_name(&error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE) && socket_may_defer(s))
                                        /* We only check BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE here, not
                                         * BUS_ERROR_TRANSACTION_JOBS_CONFLICTING or BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC,
                                         * since those are errors in a single transaction, which are most likely
                                         * caused by dependency issues in the unit configuration.
                                         * Deferring activation probably won't help. */
                                        return socket_enter_deferred(s);
                        } else
                                r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, &error, /* ret= */ NULL);
                        if (r < 0)
                                goto queue_error;
                }
 
                socket_set_state(s, SOCKET_RUNNING);
        } else { /* Accept=yes case */
                _cleanup_(socket_peer_unrefp) SocketPeer *p = NULL;
                Unit *service;
 
                if (s->n_connections >= s->max_connections) {
                        log_unit_warning(UNIT(s), "Too many incoming connections (%u), dropping connection.",
                                         s->n_connections);
                        goto refuse;
                }
 
                if (s->max_connections_per_source > 0) {
                        r = socket_acquire_peer(s, cfd, &p);
                        if (ERRNO_IS_NEG_DISCONNECT(r))
                                return;
                        if (r < 0)
                                /* We didn't have enough resources to acquire peer information, let's fail. */
                                goto fail;
                        if (r > 0 && p->n_ref > s->max_connections_per_source) {
                                _cleanup_free_ char *t = NULL;
 
                                if (p->peer.sa.sa_family == AF_UNIX)
                                        (void) asprintf(&t, "UID " UID_FMT, p->peer_cred.uid);
                                else
                                        (void) sockaddr_pretty(&p->peer.sa, p->peer_salen, /* translate_ipv6= */ true, /* include_port= */ false, &t);
 
                                log_unit_warning(UNIT(s),
                                                 "Too many incoming connections (%u) from source %s, dropping connection.",
                                                 p->n_ref, strnull(t));
                                goto refuse;
                        }
                }
 
                r = socket_load_service_unit(s, cfd, &service);
                if (ERRNO_IS_NEG_DISCONNECT(r))
                        return;
                if (r < 0 || UNIT_IS_LOAD_ERROR(service->load_state)) {
                        log_unit_warning_errno(UNIT(s), r < 0 ? r : service->load_error,
                                               "Failed to load connection service unit: %m");
                        goto fail;
                }
                if (service->load_state == UNIT_MASKED) {
                        log_unit_warning(UNIT(s), "Connection service unit is masked, refusing.");
                        goto fail;
                }
 
                s->n_accepted++;
 
                r = service_set_socket_fd(SERVICE(service), cfd, s, p, s->selinux_context_from_net);
                if (ERRNO_IS_NEG_DISCONNECT(r))
                        return;
                if (r < 0) {
                        log_unit_warning_errno(UNIT(s), r, "Failed to set socket on service: %m");
                        goto fail;
                }
 
                /* We passed ownership of the fd and socket peer to the service now. */
                TAKE_FD(cfd);
                TAKE_PTR(p);
 
                s->n_connections++;
 
                r = manager_add_job(UNIT(s)->manager, JOB_START, service, JOB_REPLACE, &error, /* ret= */ NULL);
                if (r < 0) {
                        /* We failed to activate the new service, but it still exists. Let's make sure the
                         * service closes and forgets the connection fd again, immediately. */
                        service_release_socket_fd(SERVICE(service));
                        goto queue_error;
                }
 
                /* Notify clients about changed counters */
                unit_add_to_dbus_queue(UNIT(s));
        }
 
        return;
 
refuse:
        s->n_refused++;
        return;
 
queue_error:
        log_unit_warning_errno(UNIT(s), r, "Failed to queue service startup job%s: %s",
                               cfd >= 0 && !ERRNO_IS_RESOURCE(r) ? " (Maybe the service is missing or is a template unit?)" : "",
                               bus_error_message(&error, r));
 
fail:
        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
}
 
static void socket_run_next(Socket *s) {
        int r;
 
        assert(s);
        assert(s->control_command);
        assert(s->control_command->command_next);
 
        socket_unwatch_control_pid(s);
 
        s->control_command = s->control_command->command_next;
 
        r = socket_spawn(s, s->control_command, &s->control_pid);
        if (r < 0) {
                log_unit_warning_errno(UNIT(s), r, "Failed to spawn next task: %m");
 
                if (s->state == SOCKET_START_POST)
                        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
                else if (s->state == SOCKET_STOP_POST)
                        socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
                else
                        socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
        }
}
 
static int socket_start(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        int r;
 
        assert(IN_SET(s->state, SOCKET_DEAD, SOCKET_FAILED));
 
        r = unit_acquire_invocation_id(u);
        if (r < 0)
                return r;
 
        s->result = SOCKET_SUCCESS;
        exec_command_reset_status_list_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
 
        if (s->cgroup_runtime)
                s->cgroup_runtime->reset_accounting = true;
 
        socket_enter_start_pre(s);
        return 1;
}
 
static int socket_stop(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        /* Already on it */
        if (IN_SET(s->state,
                   SOCKET_STOP_PRE,
                   SOCKET_STOP_PRE_SIGTERM,
                   SOCKET_STOP_PRE_SIGKILL,
                   SOCKET_STOP_POST,
                   SOCKET_FINAL_SIGTERM,
                   SOCKET_FINAL_SIGKILL))
                return 0;
 
        /* If there's already something running we go directly into
         * kill mode. */
        if (IN_SET(s->state,
                   SOCKET_START_PRE,
                   SOCKET_START_OPEN,
                   SOCKET_START_CHOWN,
                   SOCKET_START_POST)) {
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
                return -EAGAIN;
        }
 
        /* If we are currently cleaning, then abort it, brutally. */
        if (s->state == SOCKET_CLEANING) {
                socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
                return 0;
        }
 
        assert(IN_SET(s->state, SOCKET_LISTENING, SOCKET_DEFERRED, SOCKET_RUNNING));
 
        socket_enter_stop_pre(s, SOCKET_SUCCESS);
        return 1;
}
 
static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        int r;
 
        assert(f);
        assert(fds);
 
        (void) serialize_item(f, "state", socket_state_to_string(s->state));
        (void) serialize_item(f, "result", socket_result_to_string(s->result));
        (void) serialize_item_format(f, "n-accepted", "%u", s->n_accepted);
        (void) serialize_item_format(f, "n-refused", "%u", s->n_refused);
        (void) serialize_pidref(f, fds, "control-pid", &s->control_pid);
 
        if (s->control_command_id >= 0)
                (void) serialize_item(f, "control-command", socket_exec_command_to_string(s->control_command_id));
 
        LIST_FOREACH(port, p, s->ports) {
                int copy;
 
                if (p->fd < 0)
                        continue;
 
                copy = fdset_put_dup(fds, p->fd);
                if (copy < 0)
                        return log_unit_warning_errno(u, copy, "Failed to serialize socket fd: %m");
 
                if (p->type == SOCKET_SOCKET) {
                        _cleanup_free_ char *t = NULL;
 
                        r = socket_address_print(&p->address, &t);
                        if (r < 0)
                                return log_unit_error_errno(u, r, "Failed to format socket address: %m");
 
                        if (socket_address_family(&p->address) == AF_NETLINK)
                                (void) serialize_item_format(f, "netlink", "%i %s", copy, t);
                        else
                                (void) serialize_item_format(f, "socket", "%i %i %s", copy, p->address.type, t);
                } else if (p->type == SOCKET_SPECIAL)
                        (void) serialize_item_format(f, "special", "%i %s", copy, p->path);
                else if (p->type == SOCKET_MQUEUE)
                        (void) serialize_item_format(f, "mqueue", "%i %s", copy, p->path);
                else if (p->type == SOCKET_USB_FUNCTION)
                        (void) serialize_item_format(f, "ffs", "%i %s", copy, p->path);
                else {
                        assert(p->type == SOCKET_FIFO);
                        (void) serialize_item_format(f, "fifo", "%i %s", copy, p->path);
                }
        }
 
        (void) serialize_ratelimit(f, "trigger-ratelimit", &s->trigger_limit);
 
        return 0;
}
 
static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        int r;
 
        assert(key);
        assert(value);
 
        if (streq(key, "state")) {
                SocketState state;
 
                state = socket_state_from_string(value);
                if (state < 0)
                        log_unit_debug(u, "Failed to parse state value: %s", value);
                else
                        s->deserialized_state = state;
        } else if (streq(key, "result")) {
                SocketResult f;
 
                f = socket_result_from_string(value);
                if (f < 0)
                        log_unit_debug(u, "Failed to parse result value: %s", value);
                else if (f != SOCKET_SUCCESS)
                        s->result = f;
 
        } else if (streq(key, "n-accepted")) {
                unsigned k;
 
                if (safe_atou(value, &k) < 0)
                        log_unit_debug(u, "Failed to parse n-accepted value: %s", value);
                else
                        s->n_accepted += k;
        } else if (streq(key, "n-refused")) {
                unsigned k;
 
                if (safe_atou(value, &k) < 0)
                        log_unit_debug(u, "Failed to parse n-refused value: %s", value);
                else
                        s->n_refused += k;
        } else if (streq(key, "control-pid")) {
 
                if (!pidref_is_set(&s->control_pid))
                        (void) deserialize_pidref(fds, value, &s->control_pid);
 
        } else if (streq(key, "control-command")) {
                SocketExecCommand id;
 
                id = socket_exec_command_from_string(value);
                if (id < 0)
                        log_unit_debug(u, "Failed to parse exec-command value: %s", value);
                else {
                        s->control_command_id = id;
                        s->control_command = s->exec_command[id];
                }
        } else if (streq(key, "fifo")) {
                _cleanup_free_ char *fdv = NULL;
                bool found = false;
                int fd;
 
                r = extract_first_word(&value, &fdv, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse fifo value: %s", value);
                        return 0;
                }
 
                fd = parse_fd(fdv);
                if (fd < 0 || !fdset_contains(fds, fd)) {
                        log_unit_debug(u, "Invalid fifo value: %s", fdv);
                        return 0;
                }
 
                LIST_FOREACH(port, p, s->ports)
                        if (p->fd < 0 &&
                            p->type == SOCKET_FIFO &&
                            path_equal_or_inode_same(p->path, value, 0)) {
                                p->fd = fdset_remove(fds, fd);
                                found = true;
                                break;
                        }
                if (!found)
                        log_unit_debug(u, "No matching fifo socket found: %s", value);
 
        } else if (streq(key, "special")) {
                _cleanup_free_ char *fdv = NULL;
                bool found = false;
                int fd;
 
                r = extract_first_word(&value, &fdv, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse special value: %s", value);
                        return 0;
                }
 
                fd = parse_fd(fdv);
                if (fd < 0 || !fdset_contains(fds, fd)) {
                        log_unit_debug(u, "Invalid special value: %s", fdv);
                        return 0;
                }
 
                LIST_FOREACH(port, p, s->ports)
                        if (p->fd < 0 &&
                            p->type == SOCKET_SPECIAL &&
                            path_equal_or_inode_same(p->path, value, 0)) {
                                p->fd = fdset_remove(fds, fd);
                                found = true;
                                break;
                        }
                if (!found)
                        log_unit_debug(u, "No matching special socket found: %s", value);
 
        } else if (streq(key, "mqueue")) {
                _cleanup_free_ char *fdv = NULL;
                bool found = false;
                int fd;
 
                r = extract_first_word(&value, &fdv, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse mqueue value: %s", value);
                        return 0;
                }
 
                fd = parse_fd(fdv);
                if (fd < 0 || !fdset_contains(fds, fd)) {
                        log_unit_debug(u, "Invalid mqueue value: %s", fdv);
                        return 0;
                }
 
                LIST_FOREACH(port, p, s->ports)
                        if (p->fd < 0 &&
                            p->type == SOCKET_MQUEUE &&
                            streq(p->path, value)) {
                                p->fd = fdset_remove(fds, fd);
                                found = true;
                                break;
                        }
                if (!found)
                        log_unit_debug(u, "No matching mqueue socket found: %s", value);
 
        } else if (streq(key, "socket")) {
                _cleanup_free_ char *fdv = NULL, *typev = NULL;
                bool found = false;
                int fd, type;
 
                r = extract_first_word(&value, &fdv, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse socket fd from value: %s", value);
                        return 0;
                }
 
                fd = parse_fd(fdv);
                if (fd < 0 || !fdset_contains(fds, fd)) {
                        log_unit_debug(u, "Invalid socket fd: %s", fdv);
                        return 0;
                }
 
                r = extract_first_word(&value, &typev, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse socket type from value: %s", value);
                        return 0;
                }
 
                if (safe_atoi(typev, &type) < 0 || type < 0) {
                        log_unit_debug(u, "Invalid socket type: %s", typev);
                        return 0;
                }
 
                LIST_FOREACH(port, p, s->ports)
                        if (p->fd < 0 &&
                            socket_address_is(&p->address, value, type)) {
                                p->fd = fdset_remove(fds, fd);
                                found = true;
                                break;
                        }
                if (!found)
                        log_unit_debug(u, "No matching %s socket found: %s",
                                       socket_address_type_to_string(type), value);
 
        } else if (streq(key, "netlink")) {
                _cleanup_free_ char *fdv = NULL;
                bool found = false;
                int fd;
 
                r = extract_first_word(&value, &fdv, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse socket value: %s", value);
                        return 0;
                }
 
                fd = parse_fd(fdv);
                if (fd < 0 || !fdset_contains(fds, fd)) {
                        log_unit_debug(u, "Invalid socket value: %s", fdv);
                        return 0;
                }
 
                LIST_FOREACH(port, p, s->ports)
                        if (p->fd < 0 &&
                            socket_address_is_netlink(&p->address, value)) {
                                p->fd = fdset_remove(fds, fd);
                                found = true;
                                break;
                        }
                if (!found)
                        log_unit_debug(u, "No matching netlink socket found: %s", value);
 
        } else if (streq(key, "ffs")) {
                _cleanup_free_ char *fdv = NULL;
                bool found = false;
                int fd;
 
                r = extract_first_word(&value, &fdv, NULL, 0);
                if (r <= 0) {
                        log_unit_debug(u, "Failed to parse ffs value: %s", value);
                        return 0;
                }
 
                fd = parse_fd(fdv);
                if (fd < 0 || !fdset_contains(fds, fd)) {
                        log_unit_debug(u, "Invalid ffs value: %s", fdv);
                        return 0;
                }
 
                LIST_FOREACH(port, p, s->ports)
                        if (p->fd < 0 &&
                            p->type == SOCKET_USB_FUNCTION &&
                            path_equal_or_inode_same(p->path, value, 0)) {
                                p->fd = fdset_remove(fds, fd);
                                found = true;
                                break;
                        }
                if (!found)
                        log_unit_debug(u, "No matching ffs socket found: %s", value);
 
        } else if (streq(key, "trigger-ratelimit"))
                deserialize_ratelimit(&s->trigger_limit, key, value);
        else
                log_unit_debug(UNIT(s), "Unknown serialization key: %s", key);
 
        return 0;
}
 
static void socket_distribute_fds(Unit *u, FDSet *fds) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        LIST_FOREACH(port, p, s->ports) {
                int fd;
 
                if (p->type != SOCKET_SOCKET)
                        continue;
 
                if (p->fd >= 0)
                        continue;
 
                FDSET_FOREACH(fd, fds) {
                        if (socket_address_matches_fd(&p->address, fd)) {
                                p->fd = fdset_remove(fds, fd);
                                s->deserialized_state = SOCKET_LISTENING;
                                break;
                        }
                }
        }
}
 
static UnitActiveState socket_active_state(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        return state_translation_table[s->state];
}