src/nss-mymachines/nss-mymachines.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <netdb.h>
   4 #include <nss.h>
   5
   6 #include "sd-bus.h"
   7 #include "sd-login.h"
   8
   9 #include "alloc-util.h"
  10 #include "bus-common-errors.h"
  11 #include "env-util.h"
  12 #include "errno-util.h"
  13 #include "hostname-util.h"
  14 #include "in-addr-util.h"
  15 #include "macro.h"
  16 #include "memory-util.h"
  17 #include "nss-util.h"
  18 #include "signal-util.h"
  19 #include "string-util.h"
  20 #include "user-util.h"
  21
  22 NSS_GETHOSTBYNAME_PROTOTYPES(mymachines);
  23 NSS_GETPW_PROTOTYPES(mymachines);
  24 NSS_GETGR_PROTOTYPES(mymachines);
  25
  26 #define HOST_UID_LIMIT ((uid_t) UINT32_C(0x10000))
  27 #define HOST_GID_LIMIT ((gid_t) UINT32_C(0x10000))
  28
  29 static int count_addresses(sd_bus_message *m, int af, unsigned *ret) {
  30         unsigned c = 0;
  31         int r;
  32
  33         assert(m);
  34         assert(ret);
  35
  36         while ((r = sd_bus_message_enter_container(m, 'r', "iay")) > 0) {
  37                 int family;
  38
  39                 r = sd_bus_message_read(m, "i", &family);
  40                 if (r < 0)
  41                         return r;
  42
  43                 r = sd_bus_message_skip(m, "ay");
  44                 if (r < 0)
  45                         return r;
  46
  47                 r = sd_bus_message_exit_container(m);
  48                 if (r < 0)
  49                         return r;
  50
  51                 if (af != AF_UNSPEC && family != af)
  52                         continue;
  53
  54                 c++;
  55         }
  56         if (r < 0)
  57                 return r;
  58
  59         r = sd_bus_message_rewind(m, false);
  60         if (r < 0)
  61                 return r;
  62
  63         *ret = c;
  64         return 0;
  65 }
  66
  67 static bool avoid_deadlock(void) {
  68
  69         /* Check whether this lookup might have a chance of deadlocking because we are called from the service manager
  70          * code activating systemd-machined.service. After all, we shouldn't synchronously do lookups to
  71          * systemd-machined if we are required to finish before it can be started. This of course won't detect all
  72          * possible dead locks of this kind, but it should work for the most obvious cases. */
  73
  74         if (geteuid() != 0) /* Ignore the env vars unless we are privileged. */
  75                 return false;
  76
  77         return streq_ptr(getenv("SYSTEMD_ACTIVATION_UNIT"), "systemd-machined.service") &&
  78                streq_ptr(getenv("SYSTEMD_ACTIVATION_SCOPE"), "system");
  79 }
  80
  81 enum nss_status _nss_mymachines_gethostbyname4_r(
  82                 const char *name,
  83                 struct gaih_addrtuple **pat,
  84                 char *buffer, size_t buflen,
  85                 int *errnop, int *h_errnop,
  86                 int32_t *ttlp) {
  87
  88         struct gaih_addrtuple *r_tuple, *r_tuple_first = NULL;
  89         _cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
  90         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
  91         _cleanup_free_ int *ifindices = NULL;
  92         _cleanup_free_ char *class = NULL;
  93         size_t l, ms, idx;
  94         unsigned i = 0, c = 0;
  95         char *r_name;
  96         int n_ifindices, r;
  97
  98         PROTECT_ERRNO;
  99         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
 100
 101         assert(name);
 102         assert(pat);
 103         assert(buffer);
 104         assert(errnop);
 105         assert(h_errnop);
 106
 107         r = sd_machine_get_class(name, &class);
 108         if (r < 0)
 109                 goto fail;
 110         if (!streq(class, "container")) {
 111                 r = -ENOTTY;
 112                 goto fail;
 113         }
 114
 115         n_ifindices = sd_machine_get_ifindices(name, &ifindices);
 116         if (n_ifindices < 0) {
 117                 r = n_ifindices;
 118                 goto fail;
 119         }
 120
 121         if (avoid_deadlock()) {
 122                 r = -EDEADLK;
 123                 goto fail;
 124         }
 125
 126         r = sd_bus_open_system(&bus);
 127         if (r < 0)
 128                 goto fail;
 129
 130         r = sd_bus_call_method(bus,
 131                                "org.freedesktop.machine1",
 132                                "/org/freedesktop/machine1",
 133                                "org.freedesktop.machine1.Manager",
 134                                "GetMachineAddresses",
 135                                NULL,
 136                                &reply,
 137                                "s", name);
 138         if (r < 0)
 139                 goto fail;
 140
 141         r = sd_bus_message_enter_container(reply, 'a', "(iay)");
 142         if (r < 0)
 143                 goto fail;
 144
 145         r = count_addresses(reply, AF_UNSPEC, &c);
 146         if (r < 0)
 147                 goto fail;
 148
 149         if (c <= 0) {
 150                 *h_errnop = HOST_NOT_FOUND;
 151                 return NSS_STATUS_NOTFOUND;
 152         }
 153
 154         l = strlen(name);
 155         ms = ALIGN(l+1) + ALIGN(sizeof(struct gaih_addrtuple)) * c;
 156         if (buflen < ms) {
 157                 UNPROTECT_ERRNO;
 158                 *errnop = ERANGE;
 159                 *h_errnop = NETDB_INTERNAL;
 160                 return NSS_STATUS_TRYAGAIN;
 161         }
 162
 163         /* First, append name */
 164         r_name = buffer;
 165         memcpy(r_name, name, l+1);
 166         idx = ALIGN(l+1);
 167
 168         /* Second, append addresses */
 169         r_tuple_first = (struct gaih_addrtuple*) (buffer + idx);
 170         while ((r = sd_bus_message_enter_container(reply, 'r', "iay")) > 0) {
 171                 int family;
 172                 const void *a;
 173                 size_t sz;
 174
 175                 r = sd_bus_message_read(reply, "i", &family);
 176                 if (r < 0)
 177                         goto fail;
 178
 179                 r = sd_bus_message_read_array(reply, 'y', &a, &sz);
 180                 if (r < 0)
 181                         goto fail;
 182
 183                 r = sd_bus_message_exit_container(reply);
 184                 if (r < 0)
 185                         goto fail;
 186
 187                 if (!IN_SET(family, AF_INET, AF_INET6)) {
 188                         r = -EAFNOSUPPORT;
 189                         goto fail;
 190                 }
 191
 192                 if (sz != FAMILY_ADDRESS_SIZE(family)) {
 193                         r = -EINVAL;
 194                         goto fail;
 195                 }
 196
 197                 r_tuple = (struct gaih_addrtuple*) (buffer + idx);
 198                 r_tuple->next = i == c-1 ? NULL : (struct gaih_addrtuple*) ((char*) r_tuple + ALIGN(sizeof(struct gaih_addrtuple)));
 199                 r_tuple->name = r_name;
 200                 r_tuple->family = family;
 201                 r_tuple->scopeid = n_ifindices == 1 ? ifindices[0] : 0;
 202                 memcpy(r_tuple->addr, a, sz);
 203
 204                 idx += ALIGN(sizeof(struct gaih_addrtuple));
 205                 i++;
 206         }
 207
 208         assert(i == c);
 209
 210         r = sd_bus_message_exit_container(reply);
 211         if (r < 0)
 212                 goto fail;
 213
 214         assert(idx == ms);
 215
 216         if (*pat)
 217                 **pat = *r_tuple_first;
 218         else
 219                 *pat = r_tuple_first;
 220
 221         if (ttlp)
 222                 *ttlp = 0;
 223
 224         /* Explicitly reset both *h_errnop and h_errno to work around
 225          * https://bugzilla.redhat.com/show_bug.cgi?id=1125975 */
 226         *h_errnop = NETDB_SUCCESS;
 227         h_errno = 0;
 228
 229         return NSS_STATUS_SUCCESS;
 230
 231 fail:
 232         UNPROTECT_ERRNO;
 233         *errnop = -r;
 234         *h_errnop = NO_DATA;
 235         return NSS_STATUS_UNAVAIL;
 236 }
 237
 238 enum nss_status _nss_mymachines_gethostbyname3_r(
 239                 const char *name,
 240                 int af,
 241                 struct hostent *result,
 242                 char *buffer, size_t buflen,
 243                 int *errnop, int *h_errnop,
 244                 int32_t *ttlp,
 245                 char **canonp) {
 246
 247         _cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
 248         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 249         _cleanup_free_ char *class = NULL;
 250         unsigned c = 0, i = 0;
 251         char *r_name, *r_aliases, *r_addr, *r_addr_list;
 252         size_t l, idx, ms, alen;
 253         int r;
 254
 255         PROTECT_ERRNO;
 256         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
 257
 258         assert(name);
 259         assert(result);
 260         assert(buffer);
 261         assert(errnop);
 262         assert(h_errnop);
 263
 264         if (af == AF_UNSPEC)
 265                 af = AF_INET;
 266
 267         if (af != AF_INET && af != AF_INET6) {
 268                 r = -EAFNOSUPPORT;
 269                 goto fail;
 270         }
 271
 272         r = sd_machine_get_class(name, &class);
 273         if (r < 0)
 274                 goto fail;
 275         if (!streq(class, "container")) {
 276                 r = -ENOTTY;
 277                 goto fail;
 278         }
 279
 280         if (avoid_deadlock()) {
 281                 r = -EDEADLK;
 282                 goto fail;
 283         }
 284
 285         r = sd_bus_open_system(&bus);
 286         if (r < 0)
 287                 goto fail;
 288
 289         r = sd_bus_call_method(bus,
 290                                "org.freedesktop.machine1",
 291                                "/org/freedesktop/machine1",
 292                                "org.freedesktop.machine1.Manager",
 293                                "GetMachineAddresses",
 294                                NULL,
 295                                &reply,
 296                                "s", name);
 297         if (r < 0)
 298                 goto fail;
 299
 300         r = sd_bus_message_enter_container(reply, 'a', "(iay)");
 301         if (r < 0)
 302                 goto fail;
 303
 304         r = count_addresses(reply, af, &c);
 305         if (r < 0)
 306                 goto fail;
 307
 308         if (c <= 0) {
 309                 *h_errnop = HOST_NOT_FOUND;
 310                 return NSS_STATUS_NOTFOUND;
 311         }
 312
 313         alen = FAMILY_ADDRESS_SIZE(af);
 314         l = strlen(name);
 315
 316         ms = ALIGN(l+1) + c * ALIGN(alen) + (c+2) * sizeof(char*);
 317
 318         if (buflen < ms) {
 319                 UNPROTECT_ERRNO;
 320                 *errnop = ERANGE;
 321                 *h_errnop = NETDB_INTERNAL;
 322                 return NSS_STATUS_TRYAGAIN;
 323         }
 324
 325         /* First, append name */
 326         r_name = buffer;
 327         memcpy(r_name, name, l+1);
 328         idx = ALIGN(l+1);
 329
 330         /* Second, create aliases array */
 331         r_aliases = buffer + idx;
 332         ((char**) r_aliases)[0] = NULL;
 333         idx += sizeof(char*);
 334
 335         /* Third, append addresses */
 336         r_addr = buffer + idx;
 337         while ((r = sd_bus_message_enter_container(reply, 'r', "iay")) > 0) {
 338                 int family;
 339                 const void *a;
 340                 size_t sz;
 341
 342                 r = sd_bus_message_read(reply, "i", &family);
 343                 if (r < 0)
 344                         goto fail;
 345
 346                 r = sd_bus_message_read_array(reply, 'y', &a, &sz);
 347                 if (r < 0)
 348                         goto fail;
 349
 350                 r = sd_bus_message_exit_container(reply);
 351                 if (r < 0)
 352                         goto fail;
 353
 354                 if (family != af)
 355                         continue;
 356
 357                 if (sz != alen) {
 358                         r = -EINVAL;
 359                         goto fail;
 360                 }
 361
 362                 memcpy(r_addr + i*ALIGN(alen), a, alen);
 363                 i++;
 364         }
 365
 366         assert(i == c);
 367         idx += c * ALIGN(alen);
 368
 369         r = sd_bus_message_exit_container(reply);
 370         if (r < 0)
 371                 goto fail;
 372
 373         /* Third, append address pointer array */
 374         r_addr_list = buffer + idx;
 375         for (i = 0; i < c; i++)
 376                 ((char**) r_addr_list)[i] = r_addr + i*ALIGN(alen);
 377
 378         ((char**) r_addr_list)[i] = NULL;
 379         idx += (c+1) * sizeof(char*);
 380
 381         assert(idx == ms);
 382
 383         result->h_name = r_name;
 384         result->h_aliases = (char**) r_aliases;
 385         result->h_addrtype = af;
 386         result->h_length = alen;
 387         result->h_addr_list = (char**) r_addr_list;
 388
 389         if (ttlp)
 390                 *ttlp = 0;
 391
 392         if (canonp)
 393                 *canonp = r_name;
 394
 395         /* Explicitly reset both *h_errnop and h_errno to work around
 396          * https://bugzilla.redhat.com/show_bug.cgi?id=1125975 */
 397         *h_errnop = NETDB_SUCCESS;
 398         h_errno = 0;
 399
 400         return NSS_STATUS_SUCCESS;
 401
 402 fail:
 403         UNPROTECT_ERRNO;
 404         *errnop = -r;
 405         *h_errnop = NO_DATA;
 406         return NSS_STATUS_UNAVAIL;
 407 }
 408
 409 NSS_GETHOSTBYNAME_FALLBACKS(mymachines);
 410
 411 enum nss_status _nss_mymachines_getpwnam_r(
 412                 const char *name,
 413                 struct passwd *pwd,
 414                 char *buffer, size_t buflen,
 415                 int *errnop) {
 416
 417         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 418         _cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
 419         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 420         const char *p, *e, *machine;
 421         uint32_t mapped;
 422         uid_t uid;
 423         size_t l;
 424         int r;
 425
 426         PROTECT_ERRNO;
 427         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
 428
 429         assert(name);
 430         assert(pwd);
 431
 432         p = startswith(name, "vu-");
 433         if (!p)
 434                 return NSS_STATUS_NOTFOUND;
 435
 436         e = strrchr(p, '-');
 437         if (!e || e == p)
 438                 return NSS_STATUS_NOTFOUND;
 439
 440         if (e - p > HOST_NAME_MAX - 1) /* -1 for the last dash */
 441                 return NSS_STATUS_NOTFOUND;
 442
 443         r = parse_uid(e + 1, &uid);
 444         if (r < 0)
 445                 return NSS_STATUS_NOTFOUND;
 446
 447         machine = strndupa(p, e - p);
 448         if (!machine_name_is_valid(machine))
 449                 return NSS_STATUS_NOTFOUND;
 450
 451         if (getenv_bool_secure("SYSTEMD_NSS_BYPASS_BUS") > 0)
 452                 /* Make sure we can't deadlock if we are invoked by dbus-daemon. This way, it won't be able to resolve
 453                  * these UIDs, but that should be unproblematic as containers should never be able to connect to a bus
 454                  * running on the host. */
 455                 return NSS_STATUS_NOTFOUND;
 456
 457         if (avoid_deadlock()) {
 458                 r = -EDEADLK;
 459                 goto fail;
 460         }
 461
 462         r = sd_bus_open_system(&bus);
 463         if (r < 0)
 464                 goto fail;
 465
 466         r = sd_bus_call_method(bus,
 467                                "org.freedesktop.machine1",
 468                                "/org/freedesktop/machine1",
 469                                "org.freedesktop.machine1.Manager",
 470                                "MapFromMachineUser",
 471                                &error,
 472                                &reply,
 473                                "su",
 474                                machine, (uint32_t) uid);
 475         if (r < 0) {
 476                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_USER_MAPPING))
 477                         return NSS_STATUS_NOTFOUND;
 478
 479                 goto fail;
 480         }
 481
 482         r = sd_bus_message_read(reply, "u", &mapped);
 483         if (r < 0)
 484                 goto fail;
 485
 486         /* Refuse to work if the mapped address is in the host UID range, or if there was no mapping at all. */
 487         if (mapped < HOST_UID_LIMIT || mapped == uid)
 488                 return NSS_STATUS_NOTFOUND;
 489
 490         l = strlen(name);
 491         if (buflen < l+1) {
 492                 UNPROTECT_ERRNO;
 493                 *errnop = ERANGE;
 494                 return NSS_STATUS_TRYAGAIN;
 495         }
 496
 497         memcpy(buffer, name, l+1);
 498
 499         pwd->pw_name = buffer;
 500         pwd->pw_uid = mapped;
 501         pwd->pw_gid = GID_NOBODY;
 502         pwd->pw_gecos = buffer;
 503         pwd->pw_passwd = (char*) "*"; /* locked */
 504         pwd->pw_dir = (char*) "/";
 505         pwd->pw_shell = (char*) "/sbin/nologin";
 506
 507         return NSS_STATUS_SUCCESS;
 508
 509 fail:
 510         UNPROTECT_ERRNO;
 511         *errnop = -r;
 512         return NSS_STATUS_UNAVAIL;
 513 }
 514
 515 enum nss_status _nss_mymachines_getpwuid_r(
 516                 uid_t uid,
 517                 struct passwd *pwd,
 518                 char *buffer, size_t buflen,
 519                 int *errnop) {
 520
 521         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 522         _cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
 523         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 524         const char *machine;
 525         uint32_t mapped;
 526         int r;
 527
 528         PROTECT_ERRNO;
 529         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
 530
 531         if (!uid_is_valid(uid))
 532                 return NSS_STATUS_NOTFOUND;
 533
 534         /* We consider all uids < 65536 host uids */
 535         if (uid < HOST_UID_LIMIT)
 536                 return NSS_STATUS_NOTFOUND;
 537
 538         if (getenv_bool_secure("SYSTEMD_NSS_BYPASS_BUS") > 0)
 539                 return NSS_STATUS_NOTFOUND;
 540
 541         if (avoid_deadlock()) {
 542                 r = -EDEADLK;
 543                 goto fail;
 544         }
 545
 546         r = sd_bus_open_system(&bus);
 547         if (r < 0)
 548                 goto fail;
 549
 550         r = sd_bus_call_method(bus,
 551                                "org.freedesktop.machine1",
 552                                "/org/freedesktop/machine1",
 553                                "org.freedesktop.machine1.Manager",
 554                                "MapToMachineUser",
 555                                &error,
 556                                &reply,
 557                                "u",
 558                                (uint32_t) uid);
 559         if (r < 0) {
 560                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_USER_MAPPING))
 561                         return NSS_STATUS_NOTFOUND;
 562
 563                 goto fail;
 564         }
 565
 566         r = sd_bus_message_read(reply, "sou", &machine, NULL, &mapped);
 567         if (r < 0)
 568                 goto fail;
 569
 570         if (mapped == uid)
 571                 return NSS_STATUS_NOTFOUND;
 572
 573         if (snprintf(buffer, buflen, "vu-%s-" UID_FMT, machine, (uid_t) mapped) >= (int) buflen) {
 574                 UNPROTECT_ERRNO;
 575                 *errnop = ERANGE;
 576                 return NSS_STATUS_TRYAGAIN;
 577         }
 578
 579         pwd->pw_name = buffer;
 580         pwd->pw_uid = uid;
 581         pwd->pw_gid = GID_NOBODY;
 582         pwd->pw_gecos = buffer;
 583         pwd->pw_passwd = (char*) "*"; /* locked */
 584         pwd->pw_dir = (char*) "/";
 585         pwd->pw_shell = (char*) "/sbin/nologin";
 586
 587         return NSS_STATUS_SUCCESS;
 588
 589 fail:
 590         UNPROTECT_ERRNO;
 591         *errnop = -r;
 592         return NSS_STATUS_UNAVAIL;
 593 }
 594
 595 #pragma GCC diagnostic ignored "-Wsizeof-pointer-memaccess"
 596
 597 enum nss_status _nss_mymachines_getgrnam_r(
 598                 const char *name,
 599                 struct group *gr,
 600                 char *buffer, size_t buflen,
 601                 int *errnop) {
 602
 603         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 604         _cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
 605         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 606         const char *p, *e, *machine;
 607         uint32_t mapped;
 608         uid_t gid;
 609         size_t l;
 610         int r;
 611
 612         PROTECT_ERRNO;
 613         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
 614
 615         assert(name);
 616         assert(gr);
 617
 618         p = startswith(name, "vg-");
 619         if (!p)
 620                 return NSS_STATUS_NOTFOUND;
 621
 622         e = strrchr(p, '-');
 623         if (!e || e == p)
 624                 return NSS_STATUS_NOTFOUND;
 625
 626         if (e - p > HOST_NAME_MAX - 1)  /* -1 for the last dash */
 627                 return NSS_STATUS_NOTFOUND;
 628
 629         r = parse_gid(e + 1, &gid);
 630         if (r < 0)
 631                 return NSS_STATUS_NOTFOUND;
 632
 633         machine = strndupa(p, e - p);
 634         if (!machine_name_is_valid(machine))
 635                 return NSS_STATUS_NOTFOUND;
 636
 637         if (getenv_bool_secure("SYSTEMD_NSS_BYPASS_BUS") > 0)
 638                 return NSS_STATUS_NOTFOUND;
 639
 640         if (avoid_deadlock()) {
 641                 r = -EDEADLK;
 642                 goto fail;
 643         }
 644
 645         r = sd_bus_open_system(&bus);
 646         if (r < 0)
 647                 goto fail;
 648
 649         r = sd_bus_call_method(bus,
 650                                "org.freedesktop.machine1",
 651                                "/org/freedesktop/machine1",
 652                                "org.freedesktop.machine1.Manager",
 653                                "MapFromMachineGroup",
 654                                &error,
 655                                &reply,
 656                                "su",
 657                                machine, (uint32_t) gid);
 658         if (r < 0) {
 659                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_GROUP_MAPPING))
 660                         return NSS_STATUS_NOTFOUND;
 661
 662                 goto fail;
 663         }
 664
 665         r = sd_bus_message_read(reply, "u", &mapped);
 666         if (r < 0)
 667                 goto fail;
 668
 669         if (mapped < HOST_GID_LIMIT || mapped == gid)
 670                 return NSS_STATUS_NOTFOUND;
 671
 672         l = sizeof(char*) + strlen(name) + 1;
 673         if (buflen < l) {
 674                 UNPROTECT_ERRNO;
 675                 *errnop = ERANGE;
 676                 return NSS_STATUS_TRYAGAIN;
 677         }
 678
 679         memzero(buffer, sizeof(char*));
 680         strcpy(buffer + sizeof(char*), name);
 681
 682         gr->gr_name = buffer + sizeof(char*);
 683         gr->gr_gid = mapped;
 684         gr->gr_passwd = (char*) "*"; /* locked */
 685         gr->gr_mem = (char**) buffer;
 686
 687         return NSS_STATUS_SUCCESS;
 688
 689 fail:
 690         UNPROTECT_ERRNO;
 691         *errnop = -r;
 692         return NSS_STATUS_UNAVAIL;
 693 }
 694
 695 enum nss_status _nss_mymachines_getgrgid_r(
 696                 gid_t gid,
 697                 struct group *gr,
 698                 char *buffer, size_t buflen,
 699                 int *errnop) {
 700
 701         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 702         _cleanup_(sd_bus_message_unrefp) sd_bus_message* reply = NULL;
 703         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 704         const char *machine;
 705         uint32_t mapped;
 706         int r;
 707
 708         PROTECT_ERRNO;
 709         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);
 710
 711         if (!gid_is_valid(gid))
 712                 return NSS_STATUS_NOTFOUND;
 713
 714         /* We consider all gids < 65536 host gids */
 715         if (gid < HOST_GID_LIMIT)
 716                 return NSS_STATUS_NOTFOUND;
 717
 718         if (getenv_bool_secure("SYSTEMD_NSS_BYPASS_BUS") > 0)
 719                 return NSS_STATUS_NOTFOUND;
 720
 721         if (avoid_deadlock()) {
 722                 r = -EDEADLK;
 723                 goto fail;
 724         }
 725
 726         r = sd_bus_open_system(&bus);
 727         if (r < 0)
 728                 goto fail;
 729
 730         r = sd_bus_call_method(bus,
 731                                "org.freedesktop.machine1",
 732                                "/org/freedesktop/machine1",
 733                                "org.freedesktop.machine1.Manager",
 734                                "MapToMachineGroup",
 735                                &error,
 736                                &reply,
 737                                "u",
 738                                (uint32_t) gid);
 739         if (r < 0) {
 740                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_GROUP_MAPPING))
 741                         return NSS_STATUS_NOTFOUND;
 742
 743                 goto fail;
 744         }
 745
 746         r = sd_bus_message_read(reply, "sou", &machine, NULL, &mapped);
 747         if (r < 0)
 748                 goto fail;
 749
 750         if (mapped == gid)
 751                 return NSS_STATUS_NOTFOUND;
 752
 753         if (buflen < sizeof(char*) + 1) {
 754                 UNPROTECT_ERRNO;
 755                 *errnop = ERANGE;
 756                 return NSS_STATUS_TRYAGAIN;
 757         }
 758
 759         memzero(buffer, sizeof(char*));
 760         if (snprintf(buffer + sizeof(char*), buflen - sizeof(char*), "vg-%s-" GID_FMT, machine, (gid_t) mapped) >= (int) buflen) {
 761                 UNPROTECT_ERRNO;
 762                 *errnop = ERANGE;
 763                 return NSS_STATUS_TRYAGAIN;
 764         }
 765
 766         gr->gr_name = buffer + sizeof(char*);
 767         gr->gr_gid = gid;
 768         gr->gr_passwd = (char*) "*"; /* locked */
 769         gr->gr_mem = (char**) buffer;
 770
 771         return NSS_STATUS_SUCCESS;
 772
 773 fail:
 774         UNPROTECT_ERRNO;
 775         *errnop = -r;
 776         return NSS_STATUS_UNAVAIL;
 777 }