HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-varlink/sd-varlink.c
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);
}