Debian Codegraph @

src/machine/machined-varlink.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <linux/vm_sockets.h>
4
5 #include "sd-event.h"
6 #include "sd-varlink.h"
7
8 #include "bus-polkit.h"
9 #include "constants.h"
10 #include "discover-image.h"
11 #include "errno-util.h"
12 #include "format-util.h"
13 #include "hashmap.h"
14 #include "image-policy.h"
15 #include "image-varlink.h"
16 #include "json-util.h"
17 #include "local-addresses.h"
18 #include "machine.h"
19 #include "machine-varlink.h"
20 #include "machined.h"
21 #include "machined-resolve-hook.h"
22 #include "machined-varlink.h"
23 #include "path-lookup.h"
24 #include "set.h"
25 #include "string-util.h"
26 #include "strv.h"
27 #include "user-util.h"
28 #include "varlink-io.systemd.Machine.h"
29 #include "varlink-io.systemd.MachineImage.h"
30 #include "varlink-io.systemd.UserDatabase.h"
31 #include "varlink-io.systemd.Resolve.Hook.h"
32 #include "varlink-io.systemd.service.h"
33 #include "varlink-util.h"
34
35 typedef struct LookupParameters {
36 const char *user_name;
37 const char *group_name;
38 union {
39 uid_t uid;
40 gid_t gid;
41 };
42 const char *service;
43 } LookupParameters;
44
45 static int build_user_json(const char *user_name, uid_t uid, const char *real_name, sd_json_variant **ret) {
46 assert(user_name);
47 assert(uid_is_valid(uid));
48 assert(ret);
49
50 return sd_json_buildo(
51 ret,
52 SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_OBJECT(
53 SD_JSON_BUILD_PAIR_STRING("userName", user_name),
54 SD_JSON_BUILD_PAIR_UNSIGNED("uid", uid),
55 SD_JSON_BUILD_PAIR_UNSIGNED("gid", GID_NOBODY),
56 SD_JSON_BUILD_PAIR_CONDITION(!isempty(real_name), "realName", SD_JSON_BUILD_STRING(real_name)),
57 SD_JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_CONST_STRING("/")),
58 SD_JSON_BUILD_PAIR("shell", JSON_BUILD_CONST_STRING(NOLOGIN)),
59 SD_JSON_BUILD_PAIR_BOOLEAN("locked", true),
60 SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Machine")),
61 SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("container")))));
62 }
63
64 static bool user_match_lookup_parameters(LookupParameters *p, const char *name, uid_t uid) {
65 assert(p);
66
67 if (p->user_name && !streq(name, p->user_name))
68 return false;
69
70 if (uid_is_valid(p->uid) && uid != p->uid)
71 return false;
72
73 return true;
74 }
75
76 static int user_lookup_uid(Manager *m, uid_t uid, char **ret_name, char **ret_real_name) {
77 _cleanup_free_ char *n = NULL, *rn = NULL;
78 uid_t converted_uid;
79 Machine *machine;
80 int r;
81
82 assert(m);
83 assert(uid_is_valid(uid));
84 assert(ret_name);
85 assert(ret_real_name);
86
87 if (uid < 0x10000) /* Host UID range */
88 return -ESRCH;
89
90 r = manager_find_machine_for_uid(m, uid, &machine, &converted_uid);
91 if (r < 0)
92 return r;
93 if (!r)
94 return -ESRCH;
95
96 if (asprintf(&n, "vu-%s-" UID_FMT, machine->name, converted_uid) < 0)
97 return -ENOMEM;
98
99 /* Don't synthesize invalid user/group names (too long...) */
100 if (!valid_user_group_name(n, 0))
101 return -ESRCH;
102
103 if (asprintf(&rn, "UID " UID_FMT " of Container %s", converted_uid, machine->name) < 0)
104 return -ENOMEM;
105
106 /* Don't synthesize invalid real names either, but since this field doesn't matter much, simply invalidate things */
107 if (!valid_gecos(rn))
108 rn = mfree(rn);
109
110 *ret_name = TAKE_PTR(n);
111 *ret_real_name = TAKE_PTR(rn);
112 return 0;
113 }
114
115 static int user_lookup_name(Manager *m, const char *name, uid_t *ret_uid, char **ret_real_name) {
116 _cleanup_free_ char *mn = NULL, *rn = NULL;
117 uid_t uid, converted_uid;
118 Machine *machine;
119 const char *e, *d;
120 int r;
121
122 assert(m);
123 assert(ret_uid);
124 assert(ret_real_name);
125
126 if (!valid_user_group_name(name, 0))
127 return -ESRCH;
128
129 e = startswith(name, "vu-");
130 if (!e)
131 return -ESRCH;
132
133 d = strrchr(e, '-');
134 if (!d)
135 return -ESRCH;
136
137 if (parse_uid(d + 1, &uid) < 0)
138 return -ESRCH;
139
140 mn = strndup(e, d - e);
141 if (!mn)
142 return -ENOMEM;
143
144 machine = hashmap_get(m->machines, mn);
145 if (!machine)
146 return -ESRCH;
147
148 if (machine->class != MACHINE_CONTAINER)
149 return -ESRCH;
150
151 r = machine_translate_uid(machine, uid, &converted_uid);
152 if (r < 0)
153 return r;
154
155 if (asprintf(&rn, "UID " UID_FMT " of Container %s", uid, machine->name) < 0)
156 return -ENOMEM;
157 if (!valid_gecos(rn))
158 rn = mfree(rn);
159
160 *ret_uid = converted_uid;
161 *ret_real_name = TAKE_PTR(rn);
162 return 0;
163 }
164
165 static int vl_method_get_user_record(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
166
167 static const sd_json_dispatch_field dispatch_table[] = {
168 { "uid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, uid), 0 },
169 { "userName", SD_JSON_VARIANT_STRING, json_dispatch_const_user_group_name, offsetof(LookupParameters, user_name), SD_JSON_RELAX },
170 { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
171 {}
172 };
173
174 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
175 LookupParameters p = {
176 .uid = UID_INVALID,
177 };
178 _cleanup_free_ char *found_name = NULL, *found_real_name = NULL;
179 uid_t found_uid = UID_INVALID, uid;
180 Manager *m = ASSERT_PTR(userdata);
181 const char *un;
182 int r;
183
184 assert(parameters);
185
186 r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
187 if (r != 0)
188 return r;
189
190 if (!streq_ptr(p.service, "io.systemd.Machine"))
191 return sd_varlink_error(link, "io.systemd.UserDatabase.BadService", NULL);
192
193 if (uid_is_valid(p.uid))
194 r = user_lookup_uid(m, p.uid, &found_name, &found_real_name);
195 else if (p.user_name)
196 r = user_lookup_name(m, p.user_name, &found_uid, &found_real_name);
197 else
198 return sd_varlink_error(link, "io.systemd.UserDatabase.EnumerationNotSupported", NULL);
199 if (r == -ESRCH)
200 return sd_varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
201 if (r < 0)
202 return r;
203
204 uid = uid_is_valid(found_uid) ? found_uid : p.uid;
205 un = found_name ?: p.user_name;
206
207 if (!user_match_lookup_parameters(&p, un, uid))
208 return sd_varlink_error(link, "io.systemd.UserDatabase.ConflictingRecordFound", NULL);
209
210 r = build_user_json(un, uid, found_real_name, &v);
211 if (r < 0)
212 return r;
213
214 return sd_varlink_reply(link, v);
215 }
216
217 static int build_group_json(const char *group_name, gid_t gid, const char *description, sd_json_variant **ret) {
218 assert(group_name);
219 assert(gid_is_valid(gid));
220 assert(ret);
221
222 return sd_json_buildo(
223 ret,
224 SD_JSON_BUILD_PAIR("record", SD_JSON_BUILD_OBJECT(
225 SD_JSON_BUILD_PAIR_STRING("groupName", group_name),
226 SD_JSON_BUILD_PAIR_UNSIGNED("gid", gid),
227 SD_JSON_BUILD_PAIR_CONDITION(!isempty(description), "description", SD_JSON_BUILD_STRING(description)),
228 SD_JSON_BUILD_PAIR("service", JSON_BUILD_CONST_STRING("io.systemd.Machine")),
229 SD_JSON_BUILD_PAIR("disposition", JSON_BUILD_CONST_STRING("container")))));
230 }
231
232 static bool group_match_lookup_parameters(LookupParameters *p, const char *name, gid_t gid) {
233 assert(p);
234
235 if (p->group_name && !streq(name, p->group_name))
236 return false;
237
238 if (gid_is_valid(p->gid) && gid != p->gid)
239 return false;
240
241 return true;
242 }
243
244 static int group_lookup_gid(Manager *m, gid_t gid, char **ret_name, char **ret_description) {
245 _cleanup_free_ char *n = NULL, *d = NULL;
246 gid_t converted_gid;
247 Machine *machine;
248 int r;
249
250 assert(m);
251 assert(gid_is_valid(gid));
252 assert(ret_name);
253 assert(ret_description);
254
255 if (gid < 0x10000) /* Host GID range */
256 return -ESRCH;
257
258 r = manager_find_machine_for_gid(m, gid, &machine, &converted_gid);
259 if (r < 0)
260 return r;
261 if (!r)
262 return -ESRCH;
263
264 if (asprintf(&n, "vg-%s-" GID_FMT, machine->name, converted_gid) < 0)
265 return -ENOMEM;
266
267 if (!valid_user_group_name(n, 0))
268 return -ESRCH;
269
270 if (asprintf(&d, "GID " GID_FMT " of Container %s", converted_gid, machine->name) < 0)
271 return -ENOMEM;
272 if (!valid_gecos(d))
273 d = mfree(d);
274
275 *ret_name = TAKE_PTR(n);
276 *ret_description = TAKE_PTR(d);
277
278 return 0;
279 }
280
281 static int group_lookup_name(Manager *m, const char *name, gid_t *ret_gid, char **ret_description) {
282 _cleanup_free_ char *mn = NULL, *desc = NULL;
283 gid_t gid, converted_gid;
284 Machine *machine;
285 const char *e, *d;
286 int r;
287
288 assert(m);
289 assert(ret_gid);
290 assert(ret_description);
291
292 if (!valid_user_group_name(name, 0))
293 return -ESRCH;
294
295 e = startswith(name, "vg-");
296 if (!e)
297 return -ESRCH;
298
299 d = strrchr(e, '-');
300 if (!d)
301 return -ESRCH;
302
303 if (parse_gid(d + 1, &gid) < 0)
304 return -ESRCH;
305
306 mn = strndup(e, d - e);
307 if (!mn)
308 return -ENOMEM;
309
310 machine = hashmap_get(m->machines, mn);
311 if (!machine)
312 return -ESRCH;
313
314 if (machine->class != MACHINE_CONTAINER)
315 return -ESRCH;
316
317 r = machine_translate_gid(machine, gid, &converted_gid);
318 if (r < 0)
319 return r;
320
321 if (asprintf(&desc, "GID " GID_FMT " of Container %s", gid, machine->name) < 0)
322 return -ENOMEM;
323 if (!valid_gecos(desc))
324 desc = mfree(desc);
325
326 *ret_gid = converted_gid;
327 *ret_description = TAKE_PTR(desc);
328 return 0;
329 }
330
331 static int vl_method_get_group_record(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
332
333 static const sd_json_dispatch_field dispatch_table[] = {
334 { "gid", SD_JSON_VARIANT_UNSIGNED, sd_json_dispatch_uid_gid, offsetof(LookupParameters, gid), 0 },
335 { "groupName", SD_JSON_VARIANT_STRING, json_dispatch_const_user_group_name, offsetof(LookupParameters, group_name), SD_JSON_RELAX },
336 { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
337 {}
338 };
339
340 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
341 LookupParameters p = {
342 .gid = GID_INVALID,
343 };
344 _cleanup_free_ char *found_name = NULL, *found_description = NULL;
345 uid_t found_gid = GID_INVALID, gid;
346 Manager *m = ASSERT_PTR(userdata);
347 const char *gn;
348 int r;
349
350 assert(parameters);
351
352 r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
353 if (r != 0)
354 return r;
355
356 if (!streq_ptr(p.service, "io.systemd.Machine"))
357 return sd_varlink_error(link, "io.systemd.UserDatabase.BadService", NULL);
358
359 if (gid_is_valid(p.gid))
360 r = group_lookup_gid(m, p.gid, &found_name, &found_description);
361 else if (p.group_name)
362 r = group_lookup_name(m, p.group_name, &found_gid, &found_description);
363 else
364 return sd_varlink_error(link, "io.systemd.UserDatabase.EnumerationNotSupported", NULL);
365 if (r == -ESRCH)
366 return sd_varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
367 if (r < 0)
368 return r;
369
370 gid = gid_is_valid(found_gid) ? found_gid : p.gid;
371 gn = found_name ?: p.group_name;
372
373 if (!group_match_lookup_parameters(&p, gn, gid))
374 return sd_varlink_error(link, "io.systemd.UserDatabase.ConflictingRecordFound", NULL);
375
376 r = build_group_json(gn, gid, found_description, &v);
377 if (r < 0)
378 return r;
379
380 return sd_varlink_reply(link, v);
381 }
382
383 static int vl_method_get_memberships(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
384
385 static const sd_json_dispatch_field dispatch_table[] = {
386 { "userName", SD_JSON_VARIANT_STRING, json_dispatch_const_user_group_name, offsetof(LookupParameters, user_name), SD_JSON_RELAX },
387 { "groupName", SD_JSON_VARIANT_STRING, json_dispatch_const_user_group_name, offsetof(LookupParameters, group_name), SD_JSON_RELAX },
388 { "service", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(LookupParameters, service), 0 },
389 {}
390 };
391
392 LookupParameters p = {};
393 int r;
394
395 assert(parameters);
396
397 r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
398 if (r != 0)
399 return r;
400
401 if (!streq_ptr(p.service, "io.systemd.Machine"))
402 return sd_varlink_error(link, "io.systemd.UserDatabase.BadService", NULL);
403
404 /* We don't support auxiliary groups for machines. */
405 return sd_varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
406 }
407
408 static int json_build_local_addresses(const struct local_address *addresses, size_t n_addresses, sd_json_variant **ret) {
409 _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
410 int r;
411
412 assert(addresses || n_addresses == 0);
413 assert(ret);
414
415 FOREACH_ARRAY(a, addresses, n_addresses) {
416 r = sd_json_variant_append_arraybo(
417 &array,
418 JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("ifindex", a->ifindex),
419 SD_JSON_BUILD_PAIR_INTEGER("family", a->family),
420 SD_JSON_BUILD_PAIR_BYTE_ARRAY("address", &a->address.bytes, FAMILY_ADDRESS_SIZE(a->family)));
421 if (r < 0)
422 return r;
423 }
424
425 *ret = TAKE_PTR(array);
426 return 0;
427 }
428
429 static int list_machine_one_and_maybe_read_metadata(sd_varlink *link, Machine *m, AcquireMetadata am) {
430 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *addr_array = NULL;
431 _cleanup_strv_free_ char **os_release = NULL;
432 uid_t shift = UID_INVALID;
433 int r;
434
435 assert(link);
436 assert(m);
437
438 if (should_acquire_metadata(am)) {
439 _cleanup_free_ struct local_address *addresses = NULL;
440
441 r = machine_get_addresses(m, &addresses);
442 if (r < 0 && am == ACQUIRE_METADATA_GRACEFUL)
443 log_debug_errno(r, "Failed to get address (graceful mode), ignoring: %m");
444 else if (r == -ENONET)
445 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NO_PRIVATE_NETWORKING, NULL);
446 else if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
447 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NOT_AVAILABLE, NULL);
448 else if (r < 0)
449 return log_debug_errno(r, "Failed to get addresses: %m");
450 else {
451 r = json_build_local_addresses(addresses, r, &addr_array);
452 if (r < 0)
453 return r;
454 }
455
456 r = machine_get_os_release(m, &os_release);
457 if (r < 0 && am == ACQUIRE_METADATA_GRACEFUL)
458 log_debug_errno(r, "Failed to get OS release (graceful mode), ignoring: %m");
459 else if (r == -ENONET)
460 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NO_OS_RELEASE_INFORMATION, NULL);
461 else if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
462 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NOT_AVAILABLE, NULL);
463 else if (r < 0)
464 return log_debug_errno(r, "Failed to get OS release: %m");
465
466 r = machine_get_uid_shift(m, &shift);
467 if (r < 0 && am == ACQUIRE_METADATA_GRACEFUL)
468 log_debug_errno(r, "Failed to get UID shift (graceful mode), ignoring: %m");
469 else if (r == -ENXIO)
470 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NO_UID_SHIFT, NULL);
471 else if (ERRNO_IS_NEG_NOT_SUPPORTED(r))
472 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NOT_AVAILABLE, NULL);
473 else if (r < 0)
474 return log_debug_errno(r, "Failed to get UID shift: %m");
475 }
476
477 r = sd_json_buildo(
478 &v,
479 SD_JSON_BUILD_PAIR_STRING("name", m->name),
480 SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(m->id), "id", SD_JSON_BUILD_ID128(m->id)),
481 JSON_BUILD_PAIR_ENUM("class", machine_class_to_string(m->class)),
482 JSON_BUILD_PAIR_STRING_NON_EMPTY("service", m->service),
483 JSON_BUILD_PAIR_STRING_NON_EMPTY("rootDirectory", m->root_directory),
484 JSON_BUILD_PAIR_STRING_NON_EMPTY("unit", m->unit),
485 JSON_BUILD_PAIR_STRING_NON_EMPTY("subgroup", m->subgroup),
486 SD_JSON_BUILD_PAIR_CONDITION(pidref_is_set(&m->leader), "leader", JSON_BUILD_PIDREF(&m->leader)),
487 SD_JSON_BUILD_PAIR_CONDITION(pidref_is_set(&m->supervisor), "supervisor", JSON_BUILD_PIDREF(&m->supervisor)),
488 SD_JSON_BUILD_PAIR_CONDITION(dual_timestamp_is_set(&m->timestamp), "timestamp", JSON_BUILD_DUAL_TIMESTAMP(&m->timestamp)),
489 JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("vSockCid", m->vsock_cid, VMADDR_CID_ANY),
490 JSON_BUILD_PAIR_STRING_NON_EMPTY("sshAddress", m->ssh_address),
491 JSON_BUILD_PAIR_STRING_NON_EMPTY("sshPrivateKeyPath", m->ssh_private_key_path),
492 JSON_BUILD_PAIR_STRING_NON_EMPTY("controlAddress", m->control_address),
493 JSON_BUILD_PAIR_VARIANT_NON_NULL("addresses", addr_array),
494 JSON_BUILD_PAIR_STRV_ENV_PAIR_NON_EMPTY("OSRelease", os_release),
495 JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("UIDShift", shift, UID_INVALID),
496 SD_JSON_BUILD_PAIR_UNSIGNED("UID", m->uid));
497 if (r < 0)
498 return r;
499
500 return sd_varlink_reply(link, v);
501 }
502
503 typedef struct MachineLookupParameters {
504 const char *name;
505 PidRef pidref;
506 AcquireMetadata acquire_metadata;
507 } MachineLookupParameters;
508
509 static void machine_lookup_parameters_done(MachineLookupParameters *p) {
510 assert(p);
511
512 pidref_done(&p->pidref);
513 }
514
515 static JSON_DISPATCH_ENUM_DEFINE(json_dispatch_acquire_metadata, AcquireMetadata, acquire_metadata_from_string);
516
517 static int vl_method_list(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
518 static const sd_json_dispatch_field dispatch_table[] = {
519 VARLINK_DISPATCH_MACHINE_LOOKUP_FIELDS(MachineLookupParameters),
520 { "acquireMetadata", SD_JSON_VARIANT_STRING, json_dispatch_acquire_metadata, offsetof(MachineLookupParameters, acquire_metadata), 0 },
521 VARLINK_DISPATCH_POLKIT_FIELD,
522 {}
523 };
524
525 Manager *m = ASSERT_PTR(userdata);
526 _cleanup_(machine_lookup_parameters_done) MachineLookupParameters p = {
527 .pidref = PIDREF_NULL,
528 };
529 int r;
530
531 assert(link);
532 assert(parameters);
533
534 r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
535 if (r != 0)
536 return r;
537
538 if (m->runtime_scope != RUNTIME_SCOPE_USER && should_acquire_metadata(p.acquire_metadata)) {
539 r = varlink_verify_polkit_async(
540 link,
541 m->system_bus,
542 "org.freedesktop.machine1.inspect-machines",
543 (const char**) STRV_MAKE("name", strna(p.name)),
544 &m->polkit_registry);
545 if (r <= 0)
546 return r;
547 }
548
549 r = sd_varlink_set_sentinel(link, VARLINK_ERROR_MACHINE_NO_SUCH_MACHINE);
550 if (r < 0)
551 return r;
552
553 if (p.name || pidref_is_set(&p.pidref) || pidref_is_automatic(&p.pidref)) {
554 Machine *machine;
555 r = lookup_machine_by_name_or_pidref(link, m, p.name, &p.pidref, &machine);
556 if (r == -ESRCH)
557 return 0;
558 if (r < 0)
559 return r;
560
561 return list_machine_one_and_maybe_read_metadata(link, machine, p.acquire_metadata);
562 }
563
564 if (!FLAGS_SET(flags, SD_VARLINK_METHOD_MORE))
565 return sd_varlink_error(link, SD_VARLINK_ERROR_EXPECTED_MORE, NULL);
566
567 Machine *machine;
568 HASHMAP_FOREACH(machine, m->machines) {
569 r = list_machine_one_and_maybe_read_metadata(link, machine, p.acquire_metadata);
570 if (r < 0)
571 return r;
572 }
573
574 return 0;
575 }
576
577 static int lookup_machine_and_call_method(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata, sd_varlink_method_t method) {
578 static const sd_json_dispatch_field dispatch_table[] = {
579 VARLINK_DISPATCH_MACHINE_LOOKUP_FIELDS(MachineLookupParameters),
580 VARLINK_DISPATCH_POLKIT_FIELD,
581 {}
582 };
583
584 Manager *manager = ASSERT_PTR(userdata);
585 _cleanup_(machine_lookup_parameters_done) MachineLookupParameters p = {
586 .pidref = PIDREF_NULL,
587 };
588 Machine *machine;
589 int r;
590
591 assert(link);
592 assert(parameters);
593
594 r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
595 if (r != 0)
596 return r;
597
598 r = lookup_machine_by_name_or_pidref(link, manager, p.name, &p.pidref, &machine);
599 if (r == -ESRCH)
600 return sd_varlink_error(link, VARLINK_ERROR_MACHINE_NO_SUCH_MACHINE, NULL);
601 if (r < 0)
602 return r;
603
604 return method(link, parameters, flags, machine);
605 }
606
607 static int vl_method_unregister(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
608 return lookup_machine_and_call_method(link, parameters, flags, userdata, vl_method_unregister_internal);
609 }
610
611 static int vl_method_terminate(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
612 return lookup_machine_and_call_method(link, parameters, flags, userdata, vl_method_terminate_internal);
613 }
614
615 static int vl_method_copy_from(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
616 return vl_method_copy_internal(link, parameters, flags, userdata, /* copy_from= */ true);
617 }
618
619 static int vl_method_copy_to(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
620 return vl_method_copy_internal(link, parameters, flags, userdata, /* copy_from= */ false);
621 }
622
623 static int vl_method_open_root_directory(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
624 return lookup_machine_and_call_method(link, parameters, flags, userdata, vl_method_open_root_directory_internal);
625 }
626
627 static int list_image_one_and_maybe_read_metadata(Manager *m, sd_varlink *link, Image *image, AcquireMetadata am) {
628 int r;
629
630 assert(m);
631 assert(link);
632 assert(image);
633
634 if (should_acquire_metadata(am) && !image->metadata_valid) {
635 r = image_read_metadata(image, /* root= */ NULL, &image_policy_container, m->runtime_scope);
636 if (r < 0 && am != ACQUIRE_METADATA_GRACEFUL)
637 return log_debug_errno(r, "Failed to read image metadata: %m");
638 if (r < 0)
639 log_debug_errno(r, "Failed to read image metadata (graceful mode), ignoring: %m");
640 }
641
642 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
643
644 r = sd_json_buildo(
645 &v,
646 SD_JSON_BUILD_PAIR_STRING("name", image->name),
647 JSON_BUILD_PAIR_STRING_NON_EMPTY("path", image->path),
648 SD_JSON_BUILD_PAIR_STRING("type", image_type_to_string(image->type)),
649 SD_JSON_BUILD_PAIR_STRING("class", image_class_to_string(image->class)),
650 SD_JSON_BUILD_PAIR_BOOLEAN("readOnly", image_is_read_only(image)),
651 JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("creationTimestamp", image->crtime),
652 JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("modificationTimestamp", image->mtime),
653 JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("usage", image->usage, UINT64_MAX),
654 JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("usageExclusive", image->usage_exclusive, UINT64_MAX),
655 JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("limit", image->limit, UINT64_MAX),
656 JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("limitExclusive", image->limit_exclusive, UINT64_MAX));
657 if (r < 0)
658 return r;
659
660 if (should_acquire_metadata(am) && image->metadata_valid) {
661 r = sd_json_variant_merge_objectbo(
662 &v,
663 JSON_BUILD_PAIR_STRING_NON_EMPTY("hostname", image->hostname),
664 SD_JSON_BUILD_PAIR_CONDITION(!sd_id128_is_null(image->machine_id), "machineId", SD_JSON_BUILD_ID128(image->machine_id)),
665 JSON_BUILD_PAIR_STRV_ENV_PAIR_NON_EMPTY("machineInfo", image->machine_info),
666 JSON_BUILD_PAIR_STRV_ENV_PAIR_NON_EMPTY("OSRelease", image->os_release));
667 if (r < 0)
668 return r;
669 }
670
671 return sd_varlink_reply(link, v);
672 }
673
674 static int vl_method_list_images(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
675 Manager *m = ASSERT_PTR(userdata);
676 struct params {
677 const char *image_name;
678 AcquireMetadata acquire_metadata;
679 } p = {};
680 int r;
681
682 static const sd_json_dispatch_field dispatch_table[] = {
683 { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct params, image_name), 0 },
684 { "acquireMetadata", SD_JSON_VARIANT_STRING, json_dispatch_acquire_metadata, offsetof(struct params, acquire_metadata), 0 },
685 VARLINK_DISPATCH_POLKIT_FIELD,
686 {}
687 };
688
689 assert(link);
690 assert(parameters);
691
692 r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
693 if (r != 0)
694 return r;
695
696 if (m->runtime_scope != RUNTIME_SCOPE_USER && should_acquire_metadata(p.acquire_metadata)) {
697 r = varlink_verify_polkit_async(
698 link,
699 m->system_bus,
700 "org.freedesktop.machine1.inspect-images",
701 (const char**) STRV_MAKE("name", strna(p.image_name)),
702 &m->polkit_registry);
703 if (r <= 0)
704 return r;
705 }
706
707 r = sd_varlink_set_sentinel(link, VARLINK_ERROR_MACHINE_IMAGE_NO_SUCH_IMAGE);
708 if (r < 0)
709 return r;
710
711 if (p.image_name) {
712 _cleanup_(image_unrefp) Image *found = NULL;
713
714 if (!image_name_is_valid(p.image_name))
715 return sd_varlink_error_invalid_parameter_name(link, "name");
716
717 r = image_find(m->runtime_scope, IMAGE_MACHINE, p.image_name, /* root= */ NULL, &found);
718 if (r == -ENOENT)
719 return 0;
720 if (r < 0)
721 return log_debug_errno(r, "Failed to find image: %m");
722
723 return list_image_one_and_maybe_read_metadata(m, link, found, p.acquire_metadata);
724 }
725
726 if (!FLAGS_SET(flags, SD_VARLINK_METHOD_MORE))
727 return sd_varlink_error(link, SD_VARLINK_ERROR_EXPECTED_MORE, NULL);
728
729 _cleanup_hashmap_free_ Hashmap *images = NULL;
730 r = image_discover(m->runtime_scope, IMAGE_MACHINE, /* root= */ NULL, &images);
731 if (r < 0)
732 return log_debug_errno(r, "Failed to discover images: %m");
733
734 Image *image;
735 HASHMAP_FOREACH(image, images) {
736 r = list_image_one_and_maybe_read_metadata(m, link, image, p.acquire_metadata);
737 if (r < 0)
738 return r;
739 }
740
741 return 0;
742 }
743
744 static int manager_varlink_init_userdb(Manager *m) {
745 _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
746 int r;
747
748 assert(m);
749
750 if (m->varlink_userdb_server)
751 return 0;
752 if (m->runtime_scope != RUNTIME_SCOPE_SYSTEM) /* no userdb in per-user mode! */
753 return 0;
754
755 r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
756 if (r < 0)
757 return log_error_errno(r, "Failed to allocate varlink server object: %m");
758
759 (void) sd_varlink_server_set_description(s, "varlink-userdb");
760
761 r = sd_varlink_server_add_interface(s, &vl_interface_io_systemd_UserDatabase);
762 if (r < 0)
763 return log_error_errno(r, "Failed to add UserDatabase interface to varlink server: %m");
764
765 r = sd_varlink_server_bind_method_many(
766 s,
767 "io.systemd.UserDatabase.GetUserRecord", vl_method_get_user_record,
768 "io.systemd.UserDatabase.GetGroupRecord", vl_method_get_group_record,
769 "io.systemd.UserDatabase.GetMemberships", vl_method_get_memberships);
770 if (r < 0)
771 return log_error_errno(r, "Failed to register varlink methods: %m");
772
773 r = sd_varlink_server_listen_address(s, VARLINK_PATH_MACHINED_USERDB, 0666 | SD_VARLINK_SERVER_MODE_MKDIR_0755);
774 if (r < 0)
775 return log_error_errno(r, "Failed to bind to varlink socket %s: %m", VARLINK_PATH_MACHINED_USERDB);
776
777 r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
778 if (r < 0)
779 return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
780
781 m->varlink_userdb_server = TAKE_PTR(s);
782 return 0;
783 }
784
785 static int manager_varlink_init_machine(Manager *m) {
786 _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
787 int r;
788
789 assert(m);
790
791 if (m->varlink_machine_server)
792 return 0;
793
794 r = varlink_server_new(
795 &s,
796 SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|
797 SD_VARLINK_SERVER_ALLOW_FD_PASSING_OUTPUT,
798 m);
799 if (r < 0)
800 return log_error_errno(r, "Failed to allocate varlink server object: %m");
801
802 r = sd_varlink_server_add_interface_many(
803 s,
804 &vl_interface_io_systemd_Machine,
805 &vl_interface_io_systemd_MachineImage,
806 &vl_interface_io_systemd_service);
807 if (r < 0)
808 return log_error_errno(r, "Failed to add Machine and MachineImage interfaces to varlink server: %m");
809
810 r = sd_varlink_server_bind_method_many(
811 s,
812 "io.systemd.Machine.Register", vl_method_register,
813 "io.systemd.Machine.List", vl_method_list,
814 "io.systemd.Machine.Unregister", vl_method_unregister,
815 "io.systemd.Machine.Terminate", vl_method_terminate,
816 "io.systemd.Machine.Kill", vl_method_kill,
817 "io.systemd.Machine.Open", vl_method_open,
818 "io.systemd.Machine.OpenRootDirectory", vl_method_open_root_directory,
819 "io.systemd.Machine.MapFrom", vl_method_map_from,
820 "io.systemd.Machine.MapTo", vl_method_map_to,
821 "io.systemd.Machine.BindMount", vl_method_bind_mount,
822 "io.systemd.Machine.CopyFrom", vl_method_copy_from,
823 "io.systemd.Machine.CopyTo", vl_method_copy_to,
824 "io.systemd.MachineImage.List", vl_method_list_images,
825 "io.systemd.MachineImage.Update", vl_method_update_image,
826 "io.systemd.MachineImage.Clone", vl_method_clone_image,
827 "io.systemd.MachineImage.Remove", vl_method_remove_image,
828 "io.systemd.MachineImage.SetPoolLimit", vl_method_set_pool_limit,
829 "io.systemd.MachineImage.CleanPool", vl_method_clean_pool,
830 "io.systemd.service.Ping", varlink_method_ping,
831 "io.systemd.service.SetLogLevel", varlink_method_set_log_level,
832 "io.systemd.service.GetEnvironment", varlink_method_get_environment);
833 if (r < 0)
834 return log_error_errno(r, "Failed to register varlink methods: %m");
835
836 r = sd_varlink_server_listen_auto(s);
837 if (r < 0)
838 return log_error_errno(r, "Failed to bind to passed Varlink sockets: %m");
839 if (r == 0) {
840 _cleanup_free_ char *socket_path = NULL;
841 r = runtime_directory_generic(m->runtime_scope, "systemd/machine/io.systemd.Machine", &socket_path);
842 if (r < 0)
843 return log_error_errno(r, "Failed to determine socket path: %m");
844
845 r = sd_varlink_server_listen_address(s, socket_path, runtime_scope_to_socket_mode(m->runtime_scope) | SD_VARLINK_SERVER_MODE_MKDIR_0755);
846 if (r < 0)
847 return log_error_errno(r, "Failed to bind to io.systemd.Machine varlink socket: %m");
848
849 socket_path = mfree(socket_path);
850 r = runtime_directory_generic(m->runtime_scope, "systemd/machine/io.systemd.MachineImage", &socket_path);
851 if (r < 0)
852 return log_error_errno(r, "Failed to determine socket path: %m");
853 r = sd_varlink_server_listen_address(s, socket_path, runtime_scope_to_socket_mode(m->runtime_scope));
854 if (r < 0)
855 return log_error_errno(r, "Failed to bind to io.systemd.MachineImage varlink socket: %m");
856 }
857
858 r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
859 if (r < 0)
860 return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
861
862 m->varlink_machine_server = TAKE_PTR(s);
863 return 0;
864 }
865
866 static void on_resolve_hook_disconnect(sd_varlink_server *server, sd_varlink *link, void *userdata) {
867 Manager *m = ASSERT_PTR(userdata);
868
869 if (set_remove(m->query_filter_subscriptions, link))
870 sd_varlink_unref(link);
871 }
872
873 static int manager_varlink_init_resolve_hook(Manager *m) {
874 _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
875 int r;
876
877 assert(m);
878
879 if (m->varlink_resolve_hook_server)
880 return 0;
881 if (m->runtime_scope != RUNTIME_SCOPE_SYSTEM) /* no resolved in per-user mode! */
882 return 0;
883
884 r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
885 if (r < 0)
886 return log_error_errno(r, "Failed to allocate varlink server object: %m");
887
888 (void) sd_varlink_server_set_description(s, "varlink-resolve-hook");
889
890 r = sd_varlink_server_add_interface(s, &vl_interface_io_systemd_Resolve_Hook);
891 if (r < 0)
892 return log_error_errno(r, "Failed to add Resolve.Hook interface to varlink server: %m");
893
894 r = sd_varlink_server_bind_method_many(
895 s,
896 "io.systemd.Resolve.Hook.QueryFilter", vl_method_query_filter,
897 "io.systemd.Resolve.Hook.ResolveRecord", vl_method_resolve_record);
898 if (r < 0)
899 return log_error_errno(r, "Failed to register varlink methods: %m");
900
901 r = sd_varlink_server_bind_disconnect(s, on_resolve_hook_disconnect);
902 if (r < 0)
903 return log_error_errno(r, "Failed to bind on resolve hook disconnection events: %m");
904
905 r = sd_varlink_server_listen_address(s, VARLINK_PATH_MACHINED_RESOLVE_HOOK,
906 0666 | SD_VARLINK_SERVER_MODE_MKDIR_0755);
907 if (r < 0)
908 return log_error_errno(r, "Failed to bind to varlink socket %s: %m",
909 VARLINK_PATH_MACHINED_RESOLVE_HOOK);
910
911 r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
912 if (r < 0)
913 return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
914
915 m->varlink_resolve_hook_server = TAKE_PTR(s);
916 return 0;
917 }
918
919 int manager_varlink_init(Manager *m) {
920 int r;
921
922 r = manager_varlink_init_userdb(m);
923 if (r < 0)
924 return r;
925
926 r = manager_varlink_init_machine(m);
927 if (r < 0)
928 return r;
929
930 r = manager_varlink_init_resolve_hook(m);
931 if (r < 0)
932 return r;
933
934 return 0;
935 }
936
937 void manager_varlink_done(Manager *m) {
938 assert(m);
939
940 m->varlink_userdb_server = sd_varlink_server_unref(m->varlink_userdb_server);
941 m->varlink_machine_server = sd_varlink_server_unref(m->varlink_machine_server);
942 m->varlink_resolve_hook_server = sd_varlink_server_unref(m->varlink_resolve_hook_server);
943 }