| 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 |
} |