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 3001–3800 of 3,800

static const char *socket_sub_state_to_string(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        return socket_state_to_string(s->state);
}
 
int socket_port_to_address(const SocketPort *p, char **ret) {
        _cleanup_free_ char *address = NULL;
        int r;
 
        assert(p);
        assert(ret);
 
        switch (p->type) {
                case SOCKET_SOCKET: {
                        r = socket_address_print(&p->address, &address);
                        if (r < 0)
                                return r;
 
                        break;
                }
 
                case SOCKET_SPECIAL:
                case SOCKET_MQUEUE:
                case SOCKET_FIFO:
                case SOCKET_USB_FUNCTION:
                        address = strdup(p->path);
                        if (!address)
                                return -ENOMEM;
                        break;
 
                default:
                        assert_not_reached();
        }
 
        *ret = TAKE_PTR(address);
 
        return 0;
}
 
const char* socket_port_type_to_string(SocketPort *p) {
        assert(p);
 
        switch (p->type) {
 
        case SOCKET_SOCKET:
 
                switch (p->address.type) {
 
                case SOCK_STREAM:
                        return "Stream";
 
                case SOCK_DGRAM:
                        return "Datagram";
 
                case SOCK_SEQPACKET:
                        return "SequentialPacket";
 
                case SOCK_RAW:
                        if (socket_address_family(&p->address) == AF_NETLINK)
                                return "Netlink";
 
                        _fallthrough_;
                default:
                        return NULL;
                }
 
        case SOCKET_SPECIAL:
                return "Special";
 
        case SOCKET_MQUEUE:
                return "MessageQueue";
 
        case SOCKET_FIFO:
                return "FIFO";
 
        case SOCKET_USB_FUNCTION:
                return "USBFunction";
 
        default:
                return NULL;
        }
}
 
SocketType socket_port_type_from_string(const char *s) {
        assert(s);
 
        if (STR_IN_SET(s, "Stream", "Datagram", "SequentialPacket", "Netlink"))
                return SOCKET_SOCKET;
        else if (streq(s, "Special"))
                return SOCKET_SPECIAL;
        else if (streq(s, "MessageQueue"))
                return SOCKET_MQUEUE;
        else if (streq(s, "FIFO"))
                return SOCKET_FIFO;
        else if (streq(s, "USBFunction"))
                return SOCKET_USB_FUNCTION;
        else
                return _SOCKET_TYPE_INVALID;
}
 
static bool socket_may_gc(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        return s->n_connections == 0;
}
 
static int socket_accept_do(Socket *s, int fd) {
        int cfd;
 
        assert(s);
        assert(fd >= 0);
 
        cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
        if (cfd < 0)
                /* Convert transient network errors into clean and well-defined EAGAIN */
                return ERRNO_IS_ACCEPT_AGAIN(errno) ? -EAGAIN : -errno;
 
        return cfd;
}
 
static int socket_accept_in_cgroup(Socket *s, SocketPort *p, int fd) {
        _cleanup_(pidref_done) PidRef pid = PIDREF_NULL;
        _cleanup_close_pair_ int pair[2] = EBADF_PAIR;
        int cfd, r;
 
        assert(s);
        assert(p);
        assert(fd >= 0);
 
        /* Similar to socket_address_listen_in_cgroup(), but for accept() rather than socket(): make sure that any
         * connection socket is also properly associated with the cgroup. */
 
        if (!IN_SET(p->address.sockaddr.sa.sa_family, AF_INET, AF_INET6))
                goto shortcut;
 
        if (bpf_program_supported() <= 0)
                goto shortcut;
 
        if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
                return log_unit_error_errno(UNIT(s), errno, "Failed to create communication channel: %m");
 
        r = unit_fork_helper_process(UNIT(s), "(sd-accept)", /* into_cgroup= */ true, &pid);
        if (r < 0)
                return log_unit_error_errno(UNIT(s), r, "Failed to fork off accept stub process: %m");
        if (r == 0) {
                /* Child */
 
                pair[0] = safe_close(pair[0]);
 
                cfd = socket_accept_do(s, fd);
                if (cfd == -EAGAIN) /* spurious accept() */
                        _exit(EXIT_SUCCESS);
                if (cfd < 0) {
                        log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
                        _exit(EXIT_FAILURE);
                }
 
                r = send_one_fd(pair[1], cfd, 0);
                if (r < 0) {
                        log_unit_error_errno(UNIT(s), r, "Failed to send connection socket to parent: %m");
                        _exit(EXIT_FAILURE);
                }
 
                _exit(EXIT_SUCCESS);
        }
 
        pair[1] = safe_close(pair[1]);
        cfd = receive_one_fd(pair[0], 0);
 
        /* We synchronously wait for the helper, as it shouldn't be slow */
        r = pidref_wait_for_terminate_and_check("(sd-accept)", &pid, WAIT_LOG_ABNORMAL);
        if (r < 0) {
                safe_close(cfd);
                return r;
        }
 
        /* If we received no fd, we got EIO here. If this happens with a process exit code of EXIT_SUCCESS
         * this is a spurious accept(), let's convert that back to EAGAIN here. */
        if (cfd == -EIO && r == EXIT_SUCCESS)
                return -EAGAIN;
        if (cfd < 0)
                return log_unit_error_errno(UNIT(s), cfd, "Failed to receive connection socket: %m");
 
        return cfd;
 
shortcut:
        cfd = socket_accept_do(s, fd);
        if (cfd == -EAGAIN) /* spurious accept(), skip it silently */
                return -EAGAIN;
        if (cfd < 0)
                return log_unit_error_errno(UNIT(s), cfd, "Failed to accept connection socket: %m");
 
        return cfd;
}
 
static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
        SocketPort *p = ASSERT_PTR(userdata);
        int cfd = -EBADF;
 
        assert(fd >= 0);
 
        if (p->socket->state != SOCKET_LISTENING)
                return 0;
 
        log_unit_debug(UNIT(p->socket), "Incoming traffic");
 
        if (revents != EPOLLIN) {
                if (revents & EPOLLHUP)
                        log_unit_error(UNIT(p->socket), "Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.");
                else
                        log_unit_error(UNIT(p->socket), "Got unexpected poll event (0x%x) on socket.", revents);
                goto fail;
        }
 
        if (p->socket->accept &&
            p->type == SOCKET_SOCKET &&
            socket_address_can_accept(&p->address)) {
 
                cfd = socket_accept_in_cgroup(p->socket, p, fd);
                if (cfd == -EAGAIN) /* Spurious accept() */
                        return 0;
                if (cfd < 0)
                        goto fail;
 
                (void) socket_set_xattrs(cfd, /* path= */ NULL, p->socket->xattr_accept);
                socket_apply_socket_options(p->socket, p, cfd);
        }
 
        socket_enter_running(p->socket, cfd);
        return 0;
 
fail:
        socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
        return 0;
}
 
static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        SocketResult f;
 
        assert(pid >= 0);
 
        if (pid != s->control_pid.pid)
                return;
 
        pidref_done(&s->control_pid);
 
        if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
                f = SOCKET_SUCCESS;
        else if (code == CLD_EXITED)
                f = SOCKET_FAILURE_EXIT_CODE;
        else if (code == CLD_KILLED)
                f = SOCKET_FAILURE_SIGNAL;
        else if (code == CLD_DUMPED)
                f = SOCKET_FAILURE_CORE_DUMP;
        else
                assert_not_reached();
 
        if (s->control_command) {
                exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
 
                if (s->control_command->flags & EXEC_COMMAND_IGNORE_FAILURE)
                        f = SOCKET_SUCCESS;
        }
 
        unit_log_process_exit(
                        u,
                        "Control process",
                        socket_exec_command_to_string(s->control_command_id),
                        f == SOCKET_SUCCESS,
                        code, status);
 
        if (s->result == SOCKET_SUCCESS)
                s->result = f;
 
        if (s->control_command &&
            s->control_command->command_next &&
            f == SOCKET_SUCCESS) {
 
                log_unit_debug(u, "Running next command for state %s", socket_state_to_string(s->state));
                socket_run_next(s);
        } else {
                s->control_command = NULL;
                s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
 
                /* No further commands for this step, so let's figure
                 * out what to do next */
 
                log_unit_debug(u, "Got final SIGCHLD for state %s", socket_state_to_string(s->state));
 
                switch (s->state) {
 
                case SOCKET_START_PRE:
                        if (f == SOCKET_SUCCESS)
                                socket_enter_start_open(s);
                        else
                                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
                        break;
 
                case SOCKET_START_CHOWN:
                        if (f == SOCKET_SUCCESS)
                                socket_enter_start_post(s);
                        else
                                socket_enter_stop_pre(s, f);
                        break;
 
                case SOCKET_START_POST:
                        if (f == SOCKET_SUCCESS)
                                socket_enter_listening(s);
                        else
                                socket_enter_stop_pre(s, f);
                        break;
 
                case SOCKET_STOP_PRE:
                case SOCKET_STOP_PRE_SIGTERM:
                case SOCKET_STOP_PRE_SIGKILL:
                        socket_enter_stop_post(s, f);
                        break;
 
                case SOCKET_STOP_POST:
                case SOCKET_FINAL_SIGTERM:
                case SOCKET_FINAL_SIGKILL:
                        socket_enter_dead(s, f);
                        break;
 
                case SOCKET_CLEANING:
 
                        if (s->clean_result == SOCKET_SUCCESS)
                                s->clean_result = f;
 
                        socket_enter_dead(s, SOCKET_SUCCESS);
                        break;
 
                default:
                        assert_not_reached();
                }
        }
 
        /* Notify clients about changed exit status */
        unit_add_to_dbus_queue(u);
}
 
static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
        Socket *s = ASSERT_PTR(SOCKET(userdata));
 
        assert(s->timer_event_source == source);
 
        switch (s->state) {
 
        case SOCKET_START_PRE:
                log_unit_warning(UNIT(s), "Starting timed out. Terminating.");
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_START_CHOWN:
        case SOCKET_START_POST:
                log_unit_warning(UNIT(s), "Starting timed out. Stopping.");
                socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_DEFERRED:
                log_unit_warning(UNIT(s), "DeferTriggerMaxSec= elapsed. Stopping.");
                socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_STOP_PRE:
                log_unit_warning(UNIT(s), "Stopping timed out. Terminating.");
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_STOP_PRE_SIGTERM:
                if (s->kill_context.send_sigkill) {
                        log_unit_warning(UNIT(s), "Stopping timed out. Killing.");
                        socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
                } else {
                        log_unit_warning(UNIT(s), "Stopping timed out. Skipping SIGKILL. Ignoring.");
                        socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
                }
                break;
 
        case SOCKET_STOP_PRE_SIGKILL:
                log_unit_warning(UNIT(s), "Processes still around after SIGKILL. Ignoring.");
                socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_STOP_POST:
                log_unit_warning(UNIT(s), "Stopping timed out (2). Terminating.");
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_FINAL_SIGTERM:
                if (s->kill_context.send_sigkill) {
                        log_unit_warning(UNIT(s), "Stopping timed out (2). Killing.");
                        socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
                } else {
                        log_unit_warning(UNIT(s), "Stopping timed out (2). Skipping SIGKILL. Ignoring.");
                        socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
                }
                break;
 
        case SOCKET_FINAL_SIGKILL:
                log_unit_warning(UNIT(s), "Still around after SIGKILL (2). Entering failed mode.");
                socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
                break;
 
        case SOCKET_CLEANING:
                log_unit_warning(UNIT(s), "Cleaning timed out. killing.");
 
                if (s->clean_result == SOCKET_SUCCESS)
                        s->clean_result = SOCKET_FAILURE_TIMEOUT;
 
                socket_enter_signal(s, SOCKET_FINAL_SIGKILL, 0);
                break;
 
        default:
                assert_not_reached();
        }
 
        return 0;
}
 
int socket_collect_fds(Socket *s, int **ret) {
        size_t n = 0, k = 0;
 
        assert(s);
        assert(ret);
 
        /* Called from the service code for requesting our fds */
 
        LIST_FOREACH(port, p, s->ports) {
                if (p->fd >= 0)
                        n++;
                n += p->n_auxiliary_fds;
        }
 
        if (n == 0) {
                *ret = NULL;
                return 0;
        }
 
        int *fds = new(int, n);
        if (!fds)
                return -ENOMEM;
 
        LIST_FOREACH(port, p, s->ports) {
                if (p->fd >= 0)
                        fds[k++] = p->fd;
                FOREACH_ARRAY(i, p->auxiliary_fds, p->n_auxiliary_fds)
                        fds[k++] = *i;
        }
 
        assert(k == n);
 
        *ret = fds;
        return (int) n;
}
 
static void socket_reset_failed(Unit *u) {
        Socket *s = SOCKET(u);
 
        assert(s);
 
        if (s->state == SOCKET_FAILED)
                socket_set_state(s, SOCKET_DEAD);
 
        s->result = SOCKET_SUCCESS;
        s->clean_result = SOCKET_SUCCESS;
}
 
void socket_connection_unref(Socket *s) {
        assert(s);
 
        /* The service is dead. Yay!
         *
         * This is strictly for one-instance-per-connection
         * services. */
 
        assert(s->n_connections > 0);
        s->n_connections--;
 
        log_unit_debug(UNIT(s), "One connection closed, %u left.", s->n_connections);
}
 
static void socket_trigger_notify(Unit *u, Unit *other) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        assert(other);
 
        /* Filter out invocations with bogus state */
        assert(UNIT_IS_LOAD_COMPLETE(other->load_state));
 
        Service *service = ASSERT_PTR(SERVICE(other));
 
        /* Don't propagate state changes from the service if we are already down */
        if (!IN_SET(s->state, SOCKET_RUNNING, SOCKET_LISTENING, SOCKET_DEFERRED))
                return;
 
        /* We don't care for the service state if we are in Accept=yes mode */
        if (s->accept)
                return;
 
        /* Propagate start limit hit state */
        if (other->start_limit_hit) {
                socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_START_LIMIT_HIT);
                return;
        }
 
        /* Don't propagate anything if there's still a job queued */
        if (other->job)
                return;
 
        if (!SOCKET_SERVICE_IS_ACTIVE(service, /* allow_finalize= */ true))
                socket_enter_listening(s);
 
        if (SERVICE(other)->state == SERVICE_RUNNING)
                socket_set_state(s, SOCKET_RUNNING);
}
 
static void socket_handoff_timestamp(
                Unit *u,
                const struct ucred *ucred,
                const dual_timestamp *ts) {
 
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        assert(ucred);
        assert(ts);
 
        if (s->control_pid.pid == ucred->pid && s->control_command) {
                exec_status_handoff(&s->control_command->exec_status, ucred, ts);
                unit_add_to_dbus_queue(u);
        }
}
 
static int socket_get_timeout(Unit *u, usec_t *timeout) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        usec_t t;
        int r;
 
        assert(timeout);
 
        if (!s->timer_event_source)
                return 0;
 
        r = sd_event_source_get_time(s->timer_event_source, &t);
        if (r < 0)
                return r;
        if (t == USEC_INFINITY)
                return 0;
 
        *timeout = t;
        return 1;
}
 
const char* socket_fdname(Socket *s) {
        assert(s);
 
        /* Returns the name to use for $LISTEN_FDNAMES. If the user didn't specify anything specifically,
         * use the socket unit's name as fallback for Accept=no sockets, "connection" otherwise. */
 
        if (s->fdname)
                return s->fdname;
 
        if (s->accept)
                return "connection";
 
        return UNIT(s)->id;
}
 
static PidRef* socket_control_pid(Unit *u) {
        return &ASSERT_PTR(SOCKET(u))->control_pid;
}
 
static int socket_clean(Unit *u, ExecCleanMask mask) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(mask != 0);
 
        if (s->state != SOCKET_DEAD)
                return -EBUSY;
 
        r = exec_context_get_clean_directories(&s->exec_context, u->manager->prefix, mask, &l);
        if (r < 0)
                return r;
 
        if (strv_isempty(l))
                return -EUNATCH;
 
        socket_unwatch_control_pid(s);
        s->clean_result = SOCKET_SUCCESS;
        s->control_command = NULL;
        s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
 
        r = socket_arm_timer(s, /* relative= */ true, s->exec_context.timeout_clean_usec);
        if (r < 0) {
                log_unit_warning_errno(u, r, "Failed to install timer: %m");
                goto fail;
        }
 
        r = unit_fork_and_watch_rm_rf(u, l, &s->control_pid);
        if (r < 0) {
                log_unit_warning_errno(u, r, "Failed to spawn cleaning task: %m");
                goto fail;
        }
 
        socket_set_state(s, SOCKET_CLEANING);
        return 0;
 
fail:
        s->clean_result = SOCKET_FAILURE_RESOURCES;
        s->timer_event_source = sd_event_source_disable_unref(s->timer_event_source);
        return r;
}
 
static int socket_can_clean(Unit *u, ExecCleanMask *ret) {
        Socket *s = ASSERT_PTR(SOCKET(u));
 
        return exec_context_get_clean_mask(&s->exec_context, ret);
}
 
static int socket_test_startable(Unit *u) {
        Socket *s = ASSERT_PTR(SOCKET(u));
        int r;
 
        /* It is already being started. */
        if (IN_SET(s->state,
                   SOCKET_START_PRE,
                   SOCKET_START_OPEN,
                   SOCKET_START_CHOWN,
                   SOCKET_START_POST))
                return false;
 
        /* Cannot run this without the service being around */
        if (UNIT_ISSET(s->service)) {
                Service *service = ASSERT_PTR(SERVICE(UNIT_DEREF(s->service)));
 
                if (UNIT(service)->load_state != UNIT_LOADED)
                        return log_unit_error_errno(u, SYNTHETIC_ERRNO(ENOENT),
                                                    "Socket service %s not loaded, refusing.", UNIT(service)->id);
 
                /* If the service is already active we cannot start the socket */
                if (SOCKET_SERVICE_IS_ACTIVE(service, /* allow_finalize= */ false))
                        return log_unit_error_errno(u, SYNTHETIC_ERRNO(EBUSY),
                                                    "Socket service %s already active, refusing.", UNIT(service)->id);
        }
 
        r = unit_test_start_limit(u);
        if (r < 0) {
                socket_enter_dead(s, SOCKET_FAILURE_START_LIMIT_HIT);
                return r;
        }
 
        return true;
}
 
static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
        [SOCKET_EXEC_START_PRE]   = "ExecStartPre",
        [SOCKET_EXEC_START_CHOWN] = "ExecStartChown",
        [SOCKET_EXEC_START_POST]  = "ExecStartPost",
        [SOCKET_EXEC_STOP_PRE]    = "ExecStopPre",
        [SOCKET_EXEC_STOP_POST]   = "ExecStopPost",
};
 
DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
 
static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
        [SOCKET_SUCCESS]                         = "success",
        [SOCKET_FAILURE_RESOURCES]               = "resources",
        [SOCKET_FAILURE_TIMEOUT]                 = "timeout",
        [SOCKET_FAILURE_EXIT_CODE]               = "exit-code",
        [SOCKET_FAILURE_SIGNAL]                  = "signal",
        [SOCKET_FAILURE_CORE_DUMP]               = "core-dump",
        [SOCKET_FAILURE_START_LIMIT_HIT]         = "start-limit-hit",
        [SOCKET_FAILURE_TRIGGER_LIMIT_HIT]       = "trigger-limit-hit",
        [SOCKET_FAILURE_SERVICE_START_LIMIT_HIT] = "service-start-limit-hit",
};
 
DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
 
static const char* const socket_timestamping_table[_SOCKET_TIMESTAMPING_MAX] = {
        [SOCKET_TIMESTAMPING_OFF] = "off",
        [SOCKET_TIMESTAMPING_US]  = "us",
        [SOCKET_TIMESTAMPING_NS]  = "ns",
};
 
DEFINE_STRING_TABLE_LOOKUP(socket_timestamping, SocketTimestamping);
 
SocketTimestamping socket_timestamping_from_string_harder(const char *s) {
        SocketTimestamping t;
        int r;
 
        if (!s)
                return _SOCKET_TIMESTAMPING_INVALID;
 
        t = socket_timestamping_from_string(s);
        if (t >= 0)
                return t;
 
        /* Let's alternatively support the various other aliases parse_time() accepts for ns and µs here,
         * too. */
        if (streq(s, "nsec"))
                return SOCKET_TIMESTAMPING_NS;
        if (STR_IN_SET(s, "usec", "µs", "μs")) /* Accept both small greek letter mu + micro sign unicode codepoints */
                return SOCKET_TIMESTAMPING_US;
 
        r = parse_boolean(s);
        if (r < 0)
                return _SOCKET_TIMESTAMPING_INVALID;
 
        return r ? SOCKET_TIMESTAMPING_NS : SOCKET_TIMESTAMPING_OFF; /* If boolean yes, default to ns accuracy */
}
 
static const char* const socket_defer_trigger_table[_SOCKET_DEFER_MAX] = {
        [SOCKET_DEFER_NO]      = "no",
        [SOCKET_DEFER_YES]     = "yes",
        [SOCKET_DEFER_PATIENT] = "patient",
};
 
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(socket_defer_trigger, SocketDeferTrigger, SOCKET_DEFER_YES);
 
const UnitVTable socket_vtable = {
        .object_size = sizeof(Socket),
        .exec_context_offset = offsetof(Socket, exec_context),
        .cgroup_context_offset = offsetof(Socket, cgroup_context),
        .kill_context_offset = offsetof(Socket, kill_context),
        .exec_runtime_offset = offsetof(Socket, exec_runtime),
        .cgroup_runtime_offset = offsetof(Socket, cgroup_runtime),
 
        .sections =
                "Unit\0"
                "Socket\0"
                "Install\0",
        .private_section = "Socket",
 
        .can_transient = true,
        .can_trigger = true,
        .can_fail = true,
        .track_orphaned = true,
 
        .init = socket_init,
        .done = socket_done,
        .load = socket_load,
 
        .coldplug = socket_coldplug,
 
        .dump = socket_dump,
 
        .start = socket_start,
        .stop = socket_stop,
 
        .clean = socket_clean,
        .can_clean = socket_can_clean,
 
        .get_timeout = socket_get_timeout,
 
        .serialize = socket_serialize,
        .deserialize_item = socket_deserialize_item,
        .distribute_fds = socket_distribute_fds,
 
        .active_state = socket_active_state,
        .sub_state_to_string = socket_sub_state_to_string,
 
        .will_restart = unit_will_restart_default,
 
        .may_gc = socket_may_gc,
 
        .sigchld_event = socket_sigchld_event,
 
        .trigger_notify = socket_trigger_notify,
 
        .stop_notify = socket_stop_notify,
 
        .reset_failed = socket_reset_failed,
 
        .notify_handoff_timestamp = socket_handoff_timestamp,
 
        .control_pid = socket_control_pid,
 
        .bus_set_property = bus_socket_set_property,
        .bus_commit_properties = bus_socket_commit_properties,
 
        .status_message_formats = {
                .finished_start_job = {
                        [JOB_DONE]       = "Listening on %s.",
                        [JOB_FAILED]     = "Failed to listen on %s.",
                        [JOB_TIMEOUT]    = "Timed out starting %s.",
                },
                .finished_stop_job = {
                        [JOB_DONE]       = "Closed %s.",
                        [JOB_FAILED]     = "Failed stopping %s.",
                        [JOB_TIMEOUT]    = "Timed out stopping %s.",
                },
        },
 
        .test_startable = socket_test_startable,
};