HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-varlink/sd-varlink.c

160,383 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 574fb57b5d87a469ddecdbe866d4aaf7f9d9b05f

Lines 4001–4353 of 4,353

            varlink_symbol_in_interface(method, "io.systemd"))
                return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EEXIST), "Cannot bind server to '%s'.", method);
 
        /* Refuse to register the same method in both the regular and fiber method maps: the dispatcher
         * always consults methods first and would silently ignore a shadowed fiber_methods entry (or vice
         * versa), hiding the misconfiguration. */
        Hashmap *other = methods == &s->methods ? s->fiber_methods : s->methods;
        if (hashmap_contains(other, method))
                return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EEXIST),
                                                "Method '%s' is already bound in the other method map.", method);
 
        m = strdup(method);
        if (!m)
                return log_oom_debug();
 
        r = hashmap_ensure_put(methods, &string_hash_ops, m, callback);
        if (r == -ENOMEM)
                return log_oom_debug();
        if (r < 0)
                return varlink_server_log_errno(s, r, "Failed to register callback: %m");
        if (r > 0)
                TAKE_PTR(m);
 
        return 0;
}
 
static int varlink_server_bind_many_internal(sd_varlink_server *s, Hashmap **methods, va_list ap) {
        int r = 0;
 
        assert(s);
        assert(methods);
 
        for (;;) {
                sd_varlink_method_t callback;
                const char *method;
 
                method = va_arg(ap, const char *);
                if (!method)
                        break;
 
                callback = va_arg(ap, sd_varlink_method_t);
 
                r = varlink_server_bind_internal(s, methods, method, callback);
                if (r < 0)
                        break;
        }
 
        return r;
}
 
_public_ int sd_varlink_server_bind_method(sd_varlink_server *s, const char *method, sd_varlink_method_t callback) {
        assert_return(s, -EINVAL);
        assert_return(method, -EINVAL);
        assert_return(callback, -EINVAL);
 
        return varlink_server_bind_internal(s, &s->methods, method, callback);
}
 
_public_ int sd_varlink_server_bind_method_many_internal(sd_varlink_server *s, ...) {
        va_list ap;
        int r;
 
        assert_return(s, -EINVAL);
 
        va_start(ap, s);
        r = varlink_server_bind_many_internal(s, &s->methods, ap);
        va_end(ap);
 
        return r;
}
 
int varlink_server_bind_fiber(sd_varlink_server *s, const char *method, sd_varlink_method_t callback) {
        assert_return(s, -EINVAL);
        assert_return(method, -EINVAL);
        assert_return(callback, -EINVAL);
 
        return varlink_server_bind_internal(s, &s->fiber_methods, method, callback);
}
 
int varlink_server_bind_fiber_many_internal(sd_varlink_server *s, ...) {
        va_list ap;
        int r;
 
        assert_return(s, -EINVAL);
 
        va_start(ap, s);
        r = varlink_server_bind_many_internal(s, &s->fiber_methods, ap);
        va_end(ap);
 
        return r;
}
 
_public_ int sd_varlink_server_bind_connect(sd_varlink_server *s, sd_varlink_connect_t connect) {
        assert_return(s, -EINVAL);
 
        if (connect && s->connect_callback && connect != s->connect_callback)
                return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
        s->connect_callback = connect;
        return 0;
}
 
_public_ int sd_varlink_server_bind_disconnect(sd_varlink_server *s, sd_varlink_disconnect_t disconnect) {
        assert_return(s, -EINVAL);
 
        if (disconnect && s->disconnect_callback && disconnect != s->disconnect_callback)
                return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
        s->disconnect_callback = disconnect;
        return 0;
}
 
_public_ int sd_varlink_server_add_interface(sd_varlink_server *s, const sd_varlink_interface *interface) {
        int r;
 
        assert_return(s, -EINVAL);
        assert_return(interface, -EINVAL);
        assert_return(interface->name, -EINVAL);
 
        if (hashmap_contains(s->interfaces, interface->name))
                return varlink_server_log_errno(s, SYNTHETIC_ERRNO(EEXIST), "Duplicate registration of interface '%s'.", interface->name);
 
        r = hashmap_ensure_put(&s->interfaces, &string_hash_ops, interface->name, (void*) interface);
        if (r < 0)
                return r;
 
        for (const sd_varlink_symbol *const*symbol = interface->symbols; *symbol; symbol++) {
                _cleanup_free_ char *j = NULL;
 
                /* We only ever want to validate method calls/replies and errors against the interface
                 * definitions, hence don't bother with the type symbols */
                if (!IN_SET((*symbol)->symbol_type, SD_VARLINK_METHOD, SD_VARLINK_ERROR))
                        continue;
 
                j = strjoin(interface->name, ".", (*symbol)->name);
                if (!j)
                        return -ENOMEM;
 
                r = hashmap_ensure_put(&s->symbols, &string_hash_ops_free, j, (void*) *symbol);
                if (r < 0)
                        return r;
 
                TAKE_PTR(j);
        }
 
        return 0;
}
 
_public_ int sd_varlink_server_add_interface_many_internal(sd_varlink_server *s, ...) {
        va_list ap;
        int r = 0;
 
        assert_return(s, -EINVAL);
 
        va_start(ap, s);
        for (;;) {
                const sd_varlink_interface *interface = va_arg(ap, const sd_varlink_interface*);
                if (!interface)
                        break;
 
                r = sd_varlink_server_add_interface(s, interface);
                if (r < 0)
                        break;
        }
        va_end(ap);
 
        return r;
}
 
_public_ unsigned sd_varlink_server_connections_max(sd_varlink_server *s) {
 
        /* If a server is specified, return the setting for that server, otherwise the default value */
        if (s)
                return s->connections_max;
 
        int dts = getdtablesize();
        assert_se(dts > 0);
 
        /* Make sure we never use up more than ¾th of RLIMIT_NOFILE for IPC */
        return MIN(VARLINK_DEFAULT_CONNECTIONS_MAX, (unsigned) dts / 4 * 3);
}
 
_public_ unsigned sd_varlink_server_connections_per_uid_max(sd_varlink_server *s) {
        unsigned m;
 
        if (s)
                return s->connections_per_uid_max;
 
        /* Make sure to never use up more than ¾th of available connections for a single user */
        m = sd_varlink_server_connections_max(NULL);
        if (VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX > m)
                return m / 4 * 3;
 
        return VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX;
}
 
_public_ int sd_varlink_server_set_connections_per_uid_max(sd_varlink_server *s, unsigned m) {
        assert_return(s, -EINVAL);
        assert_return(m > 0, -EINVAL);
 
        s->connections_per_uid_max = m;
        return 0;
}
 
_public_ int sd_varlink_server_set_connections_max(sd_varlink_server *s, unsigned m) {
        assert_return(s, -EINVAL);
        assert_return(m > 0, -EINVAL);
 
        s->connections_max = m;
        return 0;
}
 
_public_ unsigned sd_varlink_server_current_connections(sd_varlink_server *s) {
 
        if (!s) /* Unallocated servers have zero connections */
                return 0;
 
        return s->n_connections;
}
 
_public_ int sd_varlink_server_set_description(sd_varlink_server *s, const char *description) {
        assert_return(s, -EINVAL);
 
        return free_and_strdup(&s->description, description);
}
 
_public_ int sd_varlink_invocation(sd_varlink_invocation_flags_t flags) {
        _cleanup_strv_free_ char **names = NULL;
        int r, b;
        socklen_t l = sizeof(b);
 
        /* Returns true if this is a "pure" varlink server invocation, i.e. with one fd passed. */
 
        const char *e = secure_getenv("SYSTEMD_VARLINK_LISTEN"); /* Permit an explicit override */
        if (e)
                return true;
 
        r = sd_listen_fds_with_names(/* unset_environment= */ false, &names);
        if (r < 0)
                return r;
        if (r == 0)
                return false;
        if (r > 1)
                return -ETOOMANYREFS;
 
        if (!strv_equal(names, STRV_MAKE("varlink")))
                return false;
 
        if (FLAGS_SET(flags, SD_VARLINK_ALLOW_LISTEN|SD_VARLINK_ALLOW_ACCEPT)) /* Both flags set? Then allow everything */
                return true;
 
        if ((flags & (SD_VARLINK_ALLOW_LISTEN|SD_VARLINK_ALLOW_ACCEPT)) == 0) /* Neither is set, then fail */
                return -EISCONN;
 
        if (getsockopt(SD_LISTEN_FDS_START, SOL_SOCKET, SO_ACCEPTCONN, &b, &l) < 0)
                return -errno;
 
        assert(l == sizeof(b));
 
        if (!FLAGS_SET(flags, b ? SD_VARLINK_ALLOW_LISTEN : SD_VARLINK_ALLOW_ACCEPT))
                return -EISCONN;
 
        return true;
}
 
_public_ int sd_varlink_error_to_errno(const char *error, sd_json_variant *parameters) {
        static const struct {
                const char *error;
                int value;
        } table[] = {
                { SD_VARLINK_ERROR_DISCONNECTED,           -ECONNRESET    },
                { SD_VARLINK_ERROR_TIMEOUT,                -ETIMEDOUT     },
                { SD_VARLINK_ERROR_PROTOCOL,               -EPROTO        },
                { SD_VARLINK_ERROR_INTERFACE_NOT_FOUND,    -EADDRNOTAVAIL },
                { SD_VARLINK_ERROR_METHOD_NOT_FOUND,       -ENXIO         },
                { SD_VARLINK_ERROR_METHOD_NOT_IMPLEMENTED, -ENOTTY        },
                { SD_VARLINK_ERROR_INVALID_PARAMETER,      -EINVAL        },
                { SD_VARLINK_ERROR_PERMISSION_DENIED,      -EACCES        },
                { SD_VARLINK_ERROR_EXPECTED_MORE,          -EBADE         },
                { SD_VARLINK_ERROR_EXPECTED_UPGRADE,       -EPROTOTYPE    },
        };
 
        int r;
 
        if (!error)
                return 0;
 
        FOREACH_ELEMENT(t, table)
                if (streq(error, t->error))
                        return t->value;
 
        /* This following tries to reverse the operation sd_varlink_error_errno() applies to turn errnos into
         * varlink errors */
        if (!streq(error, SD_VARLINK_ERROR_SYSTEM))
                return -EBADR;
 
        if (!parameters)
                return -EBADR;
 
        /* If an origin is set, check if it's Linux, otherwise don't translate */
        sd_json_variant *e = sd_json_variant_by_key(parameters, "origin");
        if (e && (!sd_json_variant_is_string(e) ||
                  !streq(sd_json_variant_string(e), "linux")))
                return -EBADR;
 
        /* If a name is specified, go by name */
        e = sd_json_variant_by_key(parameters, "errnoName");
        if (e) {
                if (!sd_json_variant_is_string(e))
                        return -EBADR;
 
                r = errno_from_name(sd_json_variant_string(e));
                if (r < 0)
                        return -EBADR;
 
                assert(r > 0);
                return -r;
        }
 
        /* Finally, use the provided error number, if there is one */
        e = sd_json_variant_by_key(parameters, "errno");
        if (!e)
                return -EBADR;
        if (!sd_json_variant_is_integer(e))
                return -EBADR;
 
        int64_t i = sd_json_variant_integer(e);
        if (i <= 0 || i > ERRNO_MAX)
                return -EBADR;
 
        return (int) -i;
}
 
_public_ int sd_varlink_error_is_invalid_parameter(const char *error, sd_json_variant *parameter, const char *name) {
 
        /* Returns true if the specified error result is an invalid parameter error for the parameter 'name' */
 
        if (!streq_ptr(error, SD_VARLINK_ERROR_INVALID_PARAMETER))
                return false;
 
        if (!name)
                return true;
 
        if (!sd_json_variant_is_object(parameter))
                return false;
 
        sd_json_variant *e = sd_json_variant_by_key(parameter, "parameter");
        if (!e || !sd_json_variant_is_string(e))
                return false;
 
        return streq(sd_json_variant_string(e), name);
}