shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2025-02-02 13:47:27 +03:00
Code

sd-varlink: add function to configure server object info (#35519)

Browse Source
This commit is contained in:
Luca Boccassi 2024-12-10 15:26:24 +00:00 committed by GitHub
commit 29d1f4dbd0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
26 changed files with 162 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/bootctl/bootctl.c
View File

@ -27,6 +27,7 @@
#include "pretty-print.h"
#include "utf8.h"
#include "varlink-io.systemd.BootControl.h"
#include "varlink-util.h"
#include "verbs.h"
#include "virt.h"
@ -656,7 +657,7 @@ static int run(int argc, char *argv[]) {
/* Invocation as Varlink service */
r = sd_varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY);
r = varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");

6
src/core/core-varlink.c
View File

@ -582,11 +582,9 @@ int manager_setup_varlink_server(Manager *m) {
if (!MANAGER_IS_SYSTEM(m))
return -EINVAL;
r = sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_debug_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(s, m);
return log_debug_errno(r, "Failed to allocate Varlink server: %m");
r = sd_varlink_server_add_interface_many(
s,

6
src/creds/creds.c
View File

@ -32,6 +32,7 @@
#include "user-util.h"
#include "varlink-io.systemd.Credentials.h"
#include "verbs.h"
#include "varlink-util.h"
typedef enum TranscodeMode {
TRANSCODE_OFF,
@ -1378,7 +1379,10 @@ static int run(int argc, char *argv[]) {
/* Invocation as Varlink service */
r = sd_varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|SD_VARLINK_SERVER_INPUT_SENSITIVE);
r = varlink_server_new(
&varlink_server,
SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|SD_VARLINK_SERVER_INPUT_SENSITIVE,
NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");

1
src/fuzz/fuzz-varlink.c
View File

@ -102,6 +102,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
/* Test one: write the data as method call to a server */
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, server_pair) >= 0);
assert_se(sd_varlink_server_new(&s, 0) >= 0);
assert_se(sd_varlink_server_set_info(s, "Vendor", "Product", "Version", "URL") >= 0);
assert_se(sd_varlink_server_set_description(s, "myserver") >= 0);
assert_se(sd_varlink_server_attach_event(s, e, 0) >= 0);
assert_se(sd_varlink_server_add_connection(s, server_pair[0], NULL) >= 0);

10
src/home/homed-manager.c
View File

@ -55,6 +55,7 @@
#include "user-record.h"
#include "user-util.h"
#include "varlink-io.systemd.UserDatabase.h"
#include "varlink-util.h"
/* Where to look for private/public keys that are used to sign the user records. We are not using
* CONF_PATHS_NULSTR() here since we want to insert /var/lib/systemd/home/ in the middle. And we insert that
@ -1004,11 +1005,12 @@ static int manager_bind_varlink(Manager *m) {
assert(m);
assert(!m->varlink_server);
r = sd_varlink_server_new(&m->varlink_server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|SD_VARLINK_SERVER_INPUT_SENSITIVE);
r = varlink_server_new(
&m->varlink_server,
SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|SD_VARLINK_SERVER_INPUT_SENSITIVE,
m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(m->varlink_server, m);
return log_error_errno(r, "Failed to allocate varlink server: %m");
r = sd_varlink_server_add_interface(m->varlink_server, &vl_interface_io_systemd_UserDatabase);
if (r < 0)

8
src/hostname/hostnamed.c
View File

@ -40,6 +40,7 @@
#include "user-util.h"
#include "utf8.h"
#include "varlink-io.systemd.Hostname.h"
#include "varlink-util.h"
#include "virt.h"
#define VALID_DEPLOYMENT_CHARS (DIGITS LETTERS "-.:")
@ -1648,12 +1649,13 @@ static int connect_varlink(Context *c) {
assert(c->event);
assert(!c->varlink_server);
r = sd_varlink_server_new(&c->varlink_server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(
&c->varlink_server,
SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
c);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");
sd_varlink_server_set_userdata(c->varlink_server, c);
r = sd_varlink_server_add_interface(c->varlink_server, &vl_interface_io_systemd_Hostname);
if (r < 0)
return log_error_errno(r, "Failed to add Hostname interface to Varlink server: %m");

8
src/import/importd.c
View File

@ -1969,11 +1969,11 @@ static int manager_connect_varlink(Manager *m) {
assert(m->event);
assert(!m->varlink_server);
r = sd_varlink_server_new(&m->varlink_server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&m->varlink_server,
SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA,
m);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");
sd_varlink_server_set_userdata(m->varlink_server, m);
return log_error_errno(r, "Failed to allocate varlink server object: %m");
r = sd_varlink_server_add_interface(m->varlink_server, &vl_interface_io_systemd_Import);
if (r < 0)

10
src/journal/journald-server.c
View File

@ -64,6 +64,7 @@
#include "uid-classification.h"
#include "user-util.h"
#include "varlink-io.systemd.Journal.h"
#include "varlink-util.h"
#define USER_JOURNALS_MAX 1024
@ -2326,11 +2327,12 @@ static int server_open_varlink(Server *s, const char *socket, int fd) {
assert(s);
r = sd_varlink_server_new(&s->varlink_server, SD_VARLINK_SERVER_ROOT_ONLY|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(
&s->varlink_server,
SD_VARLINK_SERVER_ROOT_ONLY|SD_VARLINK_SERVER_INHERIT_USERDATA,
s);
if (r < 0)
return r;
sd_varlink_server_set_userdata(s->varlink_server, s);
return log_error_errno(r, "Failed to allocate varlink server object: %m");
r = sd_varlink_server_add_interface(s->varlink_server, &vl_interface_io_systemd_Journal);
if (r < 0)

1
src/libsystemd/libsystemd.sym
View File

@ -1037,6 +1037,7 @@ global:
sd_varlink_server_set_connections_max;
sd_varlink_server_set_connections_per_uid_max;
sd_varlink_server_set_description;
sd_varlink_server_set_info;
sd_varlink_server_set_exit_on_idle;
sd_varlink_server_set_userdata;
sd_varlink_server_shutdown;

56
src/libsystemd/sd-varlink/sd-varlink.c
View File

@ -31,7 +31,6 @@
#include "varlink-internal.h"
#include "varlink-io.systemd.h"
#include "varlink-org.varlink.service.h"
#include "version.h"
#define VARLINK_DEFAULT_CONNECTIONS_MAX 4096U
#define VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX 1024U
@ -70,7 +69,7 @@ DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(varlink_state, VarlinkState);
static int varlink_format_queue(sd_varlink *v);
static void varlink_server_test_exit_on_idle(sd_varlink_server *s);
static VarlinkJsonQueueItem *varlink_json_queue_item_free(VarlinkJsonQueueItem *q) {
static VarlinkJsonQueueItem* varlink_json_queue_item_free(VarlinkJsonQueueItem *q) {
if (!q)
return NULL;
@ -80,7 +79,7 @@ static VarlinkJsonQueueItem *varlink_json_queue_item_free(VarlinkJsonQueueItem *
return mfree(q);
}
static VarlinkJsonQueueItem *varlink_json_queue_item_new(sd_json_variant *m, const int fds[], size_t n_fds) {
static VarlinkJsonQueueItem* varlink_json_queue_item_new(sd_json_variant *m, const int fds[], size_t n_fds) {
VarlinkJsonQueueItem *q;
assert(m);
@ -1193,20 +1192,16 @@ static int generic_method_get_info(
void *userdata) {
_cleanup_strv_free_ char **interfaces = NULL;
_cleanup_free_ char *product = NULL;
int r;
assert(link);
assert(link->server);
if (sd_json_variant_elements(parameters) != 0)
return sd_varlink_error_invalid_parameter(link, parameters);
product = strjoin("systemd (", program_invocation_short_name, ")");
if (!product)
return -ENOMEM;
sd_varlink_interface *interface;
HASHMAP_FOREACH(interface, ASSERT_PTR(link->server)->interfaces) {
HASHMAP_FOREACH(interface, link->server->interfaces) {
r = strv_extend(&interfaces, interface->name);
if (r < 0)
return r;
@ -1216,10 +1211,10 @@ static int generic_method_get_info(
return sd_varlink_replybo(
link,
SD_JSON_BUILD_PAIR_STRING("vendor", "The systemd Project"),
SD_JSON_BUILD_PAIR_STRING("product", product),
SD_JSON_BUILD_PAIR_STRING("version", PROJECT_VERSION_FULL " (" GIT_VERSION ")"),
SD_JSON_BUILD_PAIR_STRING("url", "https://systemd.io/"),
SD_JSON_BUILD_PAIR_STRING("vendor", strempty(link->server->vendor)),
SD_JSON_BUILD_PAIR_STRING("product", strempty(link->server->product)),
SD_JSON_BUILD_PAIR_STRING("version", strempty(link->server->version)),
SD_JSON_BUILD_PAIR_STRING("url", strempty(link->server->url)),
SD_JSON_BUILD_PAIR_STRV("interfaces", interfaces));
}
@ -3035,7 +3030,7 @@ _public_ void sd_varlink_detach_event(sd_varlink *v) {
v->event = sd_event_unref(v->event);
}
_public_ sd_event *sd_varlink_get_event(sd_varlink *v) {
_public_ sd_event* sd_varlink_get_event(sd_varlink *v) {
assert_return(v, NULL);
return v->event;
@ -3262,12 +3257,41 @@ static sd_varlink_server* varlink_server_destroy(sd_varlink_server *s) {
sd_event_unref(s->event);
free(s->description);
free(s->vendor);
free(s->product);
free(s->version);
free(s->url);
return mfree(s);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_varlink_server, sd_varlink_server, varlink_server_destroy);
_public_ int sd_varlink_server_set_info(
sd_varlink_server *s,
const char *vendor,
const char *product,
const char *version,
const char *url) {
assert_return(s, -EINVAL);
_cleanup_free_ char
*a = vendor ? strdup(vendor) : NULL,
*b = product ? strdup(product) : NULL,
*c = version ? strdup(version) : NULL,
*d = url ? strdup(url) : NULL;
if ((vendor && !a) || (product && !b) || (version && !c) || (url && !d))
return log_oom_debug();
free_and_replace(s->vendor, a);
free_and_replace(s->product, b);
free_and_replace(s->version, c);
free_and_replace(s->url, d);
return 0;
}
static int validate_connection(sd_varlink_server *server, const struct ucred *ucred) {
int allowed = -1;
@ -3429,7 +3453,7 @@ _public_ int sd_varlink_server_add_connection(sd_varlink_server *server, int fd,
return sd_varlink_server_add_connection_pair(server, fd, fd, /* override_ucred= */ NULL, ret);
}
VarlinkServerSocket *varlink_server_socket_free(VarlinkServerSocket *ss) {
VarlinkServerSocket* varlink_server_socket_free(VarlinkServerSocket *ss) {
if (!ss)
return NULL;
@ -3835,7 +3859,7 @@ _public_ int sd_varlink_server_detach_event(sd_varlink_server *s) {
return 0;
}
_public_ sd_event *sd_varlink_server_get_event(sd_varlink_server *s) {
_public_ sd_event* sd_varlink_server_get_event(sd_varlink_server *s) {
assert_return(s, NULL);
return s->event;

5
src/libsystemd/sd-varlink/varlink-internal.h
View File

@ -222,7 +222,12 @@ struct sd_varlink_server {
Hashmap *by_uid; /* UID_TO_PTR(uid) → UINT_TO_PTR(n_connections) */
void *userdata;
char *description;
char *vendor;
char *product;
char *version;
char *url;
unsigned connections_max;
unsigned connections_per_uid_max;

40
src/libsystemd/sd-varlink/varlink-util.c
View File

@ -1,8 +1,11 @@
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "errno-util.h"
#include "string-util.h"
#include "varlink-internal.h"
#include "varlink-util.h"
#include "version.h"
int varlink_get_peer_pidref(sd_varlink *v, PidRef *ret) {
int r;
@ -133,3 +136,40 @@ int varlink_many_error(Set *s, const char *error_id, sd_json_variant *parameters
return r;
}
int varlink_set_info_systemd(sd_varlink_server *server) {
_cleanup_free_ char *product = NULL;
product = strjoin("systemd (", program_invocation_short_name, ")");
if (!product)
return -ENOMEM;
return sd_varlink_server_set_info(
server,
"The systemd Project",
product,
PROJECT_VERSION_FULL " (" GIT_VERSION ")",
"https://systemd.io/");
}
int varlink_server_new(
sd_varlink_server **ret,
sd_varlink_server_flags_t flags,
void *userdata) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
int r;
r = sd_varlink_server_new(&s, flags);
if (r < 0)
return log_debug_errno(r, "Failed to allocate varlink server object: %m");
r = varlink_set_info_systemd(s);
if (r < 0)
return log_debug_errno(r, "Failed to configure varlink server object: %m");
sd_varlink_server_set_userdata(s, userdata);
*ret = TAKE_PTR(s);
return 0;
}

7
src/libsystemd/sd-varlink/varlink-util.h
View File

@ -18,3 +18,10 @@ int varlink_many_notifyb(Set *s, ...);
varlink_many_notifyb((s), SD_JSON_BUILD_OBJECT(__VA_ARGS__))
int varlink_many_reply(Set *s, sd_json_variant *parameters);
int varlink_many_error(Set *s, const char *error_id, sd_json_variant *parameters);
int varlink_set_info_systemd(sd_varlink_server *server);
int varlink_server_new(
sd_varlink_server **ret,
sd_varlink_server_flags_t flags,
void *userdata);

9
src/machine/machined-varlink.c
View File

@ -17,6 +17,7 @@
#include "varlink-io.systemd.Machine.h"
#include "varlink-io.systemd.MachineImage.h"
#include "varlink-io.systemd.UserDatabase.h"
#include "varlink-util.h"
typedef struct LookupParameters {
const char *user_name;
@ -712,12 +713,10 @@ static int manager_varlink_init_userdb(Manager *m) {
if (m->varlink_userdb_server)
return 0;
r = sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(s, m);
r = sd_varlink_server_add_interface(s, &vl_interface_io_systemd_UserDatabase);
if (r < 0)
return log_error_errno(r, "Failed to add UserDatabase interface to varlink server: %m");
@ -753,12 +752,10 @@ static int manager_varlink_init_machine(Manager *m) {
if (m->varlink_machine_server)
return 0;
r = sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(s, m);
r = sd_varlink_server_add_interface_many(
s,
&vl_interface_io_systemd_Machine,

3
src/mountfsd/mountwork.c
View File

@ -23,6 +23,7 @@
#include "stat-util.h"
#include "user-util.h"
#include "varlink-io.systemd.MountFileSystem.h"
#include "varlink-util.h"
#define ITERATIONS_MAX 64U
#define RUNTIME_MAX_USEC (5 * USEC_PER_MINUTE)
@ -595,7 +596,7 @@ static int run(int argc, char *argv[]) {
if (r < 0)
return log_error_errno(r, "Failed to turn off non-blocking mode for listening socket: %m");
r = sd_varlink_server_new(&server, SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&server, SD_VARLINK_SERVER_INHERIT_USERDATA, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate server: %m");

5
src/network/networkd-manager-varlink.c
View File

@ -12,6 +12,7 @@
#include "networkd-manager-varlink.h"
#include "stat-util.h"
#include "varlink-io.systemd.Network.h"
#include "varlink-util.h"
static int vl_method_get_states(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
@ -270,12 +271,10 @@ int manager_connect_varlink(Manager *m) {
if (m->varlink_server)
return 0;
r = sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(s, m);
(void) sd_varlink_server_set_description(s, "varlink-api-network");
r = sd_varlink_server_add_interface(s, &vl_interface_io_systemd_Network);

5
src/nsresourced/nsresourcework.c
View File

@ -44,6 +44,7 @@
#include "userns-restrict.h"
#include "varlink-io.systemd.NamespaceResource.h"
#include "varlink-io.systemd.UserDatabase.h"
#include "varlink-util.h"
#define ITERATIONS_MAX 64U
#define RUNTIME_MAX_USEC (5 * USEC_PER_MINUTE)
@ -1689,9 +1690,9 @@ static int run(int argc, char *argv[]) {
if (r < 0)
return log_error_errno(r, "Failed to turn off non-blocking mode for listening socket: %m");
r = sd_varlink_server_new(&server, SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&server, SD_VARLINK_SERVER_INHERIT_USERDATA, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate server: %m");
return log_error_errno(r, "Failed to allocate varlink server: %m");
r = sd_varlink_server_add_interface_many(
server,

5
src/oom/oomd-manager.c
View File

@ -18,6 +18,7 @@
#include "path-util.h"
#include "percent-util.h"
#include "varlink-io.systemd.oom.h"
#include "varlink-util.h"
typedef struct ManagedOOMMessage {
ManagedOOMMode mode;
@ -720,12 +721,10 @@ static int manager_varlink_init(Manager *m, int fd) {
assert(m);
assert(!m->varlink_server);
r = sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(s, m);
r = sd_varlink_server_add_interface(s, &vl_interface_io_systemd_oom);
if (r < 0)
return log_error_errno(r, "Failed to add oom interface to varlink server: %m");

3
src/pcrextend/pcrextend.c
View File

@ -20,6 +20,7 @@
#include "tpm2-pcr.h"
#include "tpm2-util.h"
#include "varlink-io.systemd.PCRExtend.h"
#include "varlink-util.h"
static bool arg_graceful = false;
static char *arg_tpm2_device = NULL;
@ -312,7 +313,7 @@ static int run(int argc, char *argv[]) {
/* Invocation as Varlink service */
r = sd_varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY);
r = varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");

3
src/pcrlock/pcrlock.c
View File

@ -53,6 +53,7 @@
#include "unit-name.h"
#include "utf8.h"
#include "varlink-io.systemd.PCRLock.h"
#include "varlink-util.h"
#include "verbs.h"
typedef enum RecoveryPinMode {
@ -5352,7 +5353,7 @@ static int run(int argc, char *argv[]) {
/* Invocation as Varlink service */
r = sd_varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY);
r = varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");

9
src/resolve/resolved-varlink.c
View File

@ -9,6 +9,7 @@
#include "socket-netlink.h"
#include "varlink-io.systemd.Resolve.h"
#include "varlink-io.systemd.Resolve.Monitor.h"
#include "varlink-util.h"
typedef struct LookupParameters {
int ifindex;
@ -1361,12 +1362,10 @@ static int varlink_monitor_server_init(Manager *m) {
if (m->varlink_monitor_server)
return 0;
r = sd_varlink_server_new(&server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA);
r = varlink_server_new(&server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(server, m);
r = sd_varlink_server_add_interface(server, &vl_interface_io_systemd_Resolve_Monitor);
if (r < 0)
return log_error_errno(r, "Failed to add Resolve.Monitor interface to varlink server: %m");
@ -1407,12 +1406,10 @@ static int varlink_main_server_init(Manager *m) {
if (m->varlink_server)
return 0;
r = sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID);
r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate varlink server object: %m");
sd_varlink_server_set_userdata(s, m);
r = sd_varlink_server_add_interface(s, &vl_interface_io_systemd_Resolve);
if (r < 0)
return log_error_errno(r, "Failed to add Resolve interface to varlink server: %m");

3
src/sysext/sysext.c
View File

@ -52,6 +52,7 @@
#include "terminal-util.h"
#include "user-util.h"
#include "varlink-io.systemd.sysext.h"
#include "varlink-util.h"
#include "verbs.h"
typedef enum MutableMode {
@ -2568,7 +2569,7 @@ static int run(int argc, char *argv[]) {
/* Invocation as Varlink service */
r = sd_varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY);
r = varlink_server_new(&varlink_server, SD_VARLINK_SERVER_ROOT_ONLY, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate Varlink server: %m");

9
src/systemd/sd-varlink.h
View File

@ -219,6 +219,13 @@ int sd_varlink_server_new(sd_varlink_server **ret, sd_varlink_server_flags_t fla
sd_varlink_server* sd_varlink_server_ref(sd_varlink_server *s);
sd_varlink_server* sd_varlink_server_unref(sd_varlink_server *s);
int sd_varlink_server_set_info(
sd_varlink_server *s,
const char *vendor,
const char *product,
const char *version,
const char *url);
/* Add addresses or fds to listen on */
int sd_varlink_server_listen_address(sd_varlink_server *s, const char *address, mode_t mode);
int sd_varlink_server_listen_fd(sd_varlink_server *s, int fd);
@ -244,7 +251,7 @@ void* sd_varlink_server_get_userdata(sd_varlink_server *s);
int sd_varlink_server_attach_event(sd_varlink_server *v, sd_event *e, int64_t priority);
int sd_varlink_server_detach_event(sd_varlink_server *v);
sd_event *sd_varlink_server_get_event(sd_varlink_server *v);
sd_event* sd_varlink_server_get_event(sd_varlink_server *v);
int sd_varlink_server_loop_auto(sd_varlink_server *server);

2
src/test/test-varlink-idl.c
View File

@ -29,6 +29,7 @@
#include "varlink-io.systemd.service.h"
#include "varlink-io.systemd.sysext.h"
#include "varlink-org.varlink.service.h"
#include "varlink-util.h"
static SD_VARLINK_DEFINE_ENUM_TYPE(
EnumTest,
@ -378,6 +379,7 @@ static void* server_thread(void *userdata) {
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
assert_se(sd_varlink_server_new(&server, 0) >= 0);
assert_se(varlink_set_info_systemd(server) >= 0);
assert_se(sd_varlink_server_add_interface(server, &vl_interface_xyz) >= 0);
assert_se(sd_varlink_server_bind_method(server, "xyz.TestMethod", test_method) >= 0);
assert_se(sd_varlink_server_bind_method(server, "xyz.Done", done_method) >= 0);

5
src/test/test-varlink.c
View File

@ -16,6 +16,7 @@
#include "tests.h"
#include "tmpfile-util.h"
#include "user-util.h"
#include "varlink-util.h"
/* Let's pick some high value, that is higher than the largest listen() backlog, but leaves enough room below
the typical RLIMIT_NOFILE value of 1024 so that we can process both sides of each socket in our
@ -359,7 +360,9 @@ TEST(chat) {
assert_se(sd_event_source_set_priority(block_event, SD_EVENT_PRIORITY_IMPORTANT) >= 0);
block_write_fd = TAKE_FD(block_fds[1]);
assert_se(sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID) >= 0);
assert_se(varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID, NULL) >= 0);
assert_se(sd_varlink_server_set_info(s, "Vendor", "Product", "Version", "URL") >= 0);
assert_se(varlink_set_info_systemd(s) >= 0);
assert_se(sd_varlink_server_set_description(s, "our-server") >= 0);
assert_se(sd_varlink_server_bind_method(s, "io.test.PassFD", method_passfd) >= 0);

5
src/userdb/userwork.c
View File

@ -20,6 +20,7 @@
#include "user-util.h"
#include "userdb.h"
#include "varlink-io.systemd.UserDatabase.h"
#include "varlink-util.h"
#define ITERATIONS_MAX 64U
#define RUNTIME_MAX_USEC (5 * USEC_PER_MINUTE)
@ -489,9 +490,9 @@ static int run(int argc, char *argv[]) {
if (r < 0)
return log_error_errno(r, "Failed to turn off non-blocking mode for listening socket: %m");
r = sd_varlink_server_new(&server, 0);
r = varlink_server_new(&server, 0, NULL);
if (r < 0)
return log_error_errno(r, "Failed to allocate server: %m");
return log_error_errno(r, "Failed to allocate varlink server: %m");
r = sd_varlink_server_add_interface(server, &vl_interface_io_systemd_UserDatabase);
if (r < 0)