src/nss-resolve/nss-resolve.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <netdb.h>
   5 #include <nss.h>
   6 #include <pthread.h>
   7 #include <stdlib.h>
   8 #include <sys/types.h>
   9 #include <unistd.h>
  10
  11 #include "env-util.h"
  12 #include "errno-util.h"
  13 #include "glyph-util.h"
  14 #include "in-addr-util.h"
  15 #include "macro.h"
  16 #include "nss-util.h"
  17 #include "resolved-def.h"
  18 #include "signal-util.h"
  19 #include "string-util.h"
  20 #include "strv.h"
  21 #include "varlink.h"
  22
  23 static JsonDispatchFlags json_dispatch_flags = 0;
  24
  25 static void setup_logging(void) {
  26         log_parse_environment_variables();
  27
  28         if (DEBUG_LOGGING)
  29                 json_dispatch_flags = JSON_LOG;
  30 }
  31
  32 static void setup_logging_once(void) {
  33         static pthread_once_t once = PTHREAD_ONCE_INIT;
  34         assert_se(pthread_once(&once, setup_logging) == 0);
  35 }
  36
  37 #define NSS_ENTRYPOINT_BEGIN                    \
  38         BLOCK_SIGNALS(NSS_SIGNALS_BLOCK);       \
  39         setup_logging_once()
  40
  41 NSS_GETHOSTBYNAME_PROTOTYPES(resolve);
  42 NSS_GETHOSTBYADDR_PROTOTYPES(resolve);
  43
  44 static bool error_shall_fallback(const char *error_id) {
  45         /* The Varlink errors where we shall signal "please fallback" back to the NSS stack, so that some
  46          * fallback module can be loaded. (These are mostly all Varlink-internal errors, as apparently we
  47          * then were unable to even do IPC with systemd-resolved.) */
  48         return STR_IN_SET(error_id,
  49                           VARLINK_ERROR_DISCONNECTED,
  50                           VARLINK_ERROR_TIMEOUT,
  51                           VARLINK_ERROR_PROTOCOL,
  52                           VARLINK_ERROR_INTERFACE_NOT_FOUND,
  53                           VARLINK_ERROR_METHOD_NOT_FOUND,
  54                           VARLINK_ERROR_METHOD_NOT_IMPLEMENTED);
  55 }
  56
  57 static bool error_shall_try_again(const char *error_id) {
  58         /* The Varlink errors where we shall signal "can't answer now but might be able to later" back to the
  59          * NSS stack. These are all errors that indicate lack of configuration or network problems. */
  60         return STR_IN_SET(error_id,
  61                           "io.systemd.Resolve.NoNameServers",
  62                           "io.systemd.Resolve.QueryTimedOut",
  63                           "io.systemd.Resolve.MaxAttemptsReached",
  64                           "io.systemd.Resolve.NetworkDown");
  65 }
  66
  67 static int connect_to_resolved(Varlink **ret) {
  68         _cleanup_(varlink_unrefp) Varlink *link = NULL;
  69         int r;
  70
  71         r = varlink_connect_address(&link, "/run/systemd/resolve/io.systemd.Resolve");
  72         if (r < 0)
  73                 return r;
  74
  75         r = varlink_set_relative_timeout(link, SD_RESOLVED_QUERY_TIMEOUT_USEC);
  76         if (r < 0)
  77                 return r;
  78
  79         *ret = TAKE_PTR(link);
  80         return 0;
  81 }
  82
  83 static uint32_t ifindex_to_scopeid(int family, const void *a, int ifindex) {
  84         struct in6_addr in6;
  85
  86         if (family != AF_INET6 || ifindex == 0)
  87                 return 0;
  88
  89         /* Some apps can't deal with the scope ID attached to non-link-local addresses. Hence, let's suppress that. */
  90
  91         assert(sizeof(in6) == FAMILY_ADDRESS_SIZE(AF_INET6));
  92         memcpy(&in6, a, sizeof(struct in6_addr));
  93
  94         return in6_addr_is_link_local(&in6) ? ifindex : 0;
  95 }
  96
  97 static int json_dispatch_ifindex(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
  98         int *ifi = userdata;
  99         int64_t t;
 100
 101         assert(variant);
 102         assert(ifi);
 103
 104         if (!json_variant_is_integer(variant))
 105                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
 106
 107         t = json_variant_integer(variant);
 108         if (t > INT_MAX)
 109                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is out of bounds for an interface index.", strna(name));
 110
 111         *ifi = (int) t;
 112         return 0;
 113 }
 114
 115 static int json_dispatch_family(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
 116         int *family = userdata;
 117         int64_t t;
 118
 119         assert(variant);
 120         assert(family);
 121
 122         if (!json_variant_is_integer(variant))
 123                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an integer.", strna(name));
 124
 125         t = json_variant_integer(variant);
 126         if (t < 0 || t > INT_MAX)
 127                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid family.", strna(name));
 128
 129         *family = (int) t;
 130         return 0;
 131 }
 132
 133 typedef struct ResolveHostnameReply {
 134         JsonVariant *addresses;
 135         char *name;
 136         uint64_t flags;
 137 } ResolveHostnameReply;
 138
 139 static void resolve_hostname_reply_destroy(ResolveHostnameReply *p) {
 140         assert(p);
 141
 142         json_variant_unref(p->addresses);
 143         free(p->name);
 144 }
 145
 146 static const JsonDispatch resolve_hostname_reply_dispatch_table[] = {
 147         { "addresses", JSON_VARIANT_ARRAY,    json_dispatch_variant, offsetof(ResolveHostnameReply, addresses), JSON_MANDATORY },
 148         { "name",      JSON_VARIANT_STRING,   json_dispatch_string,  offsetof(ResolveHostnameReply, name),      0              },
 149         { "flags",     JSON_VARIANT_UNSIGNED, json_dispatch_uint64,  offsetof(ResolveHostnameReply, flags),     0              },
 150         {}
 151 };
 152
 153 typedef struct AddressParameters {
 154         int ifindex;
 155         int family;
 156         union in_addr_union address;
 157         size_t address_size;
 158 } AddressParameters;
 159
 160 static int json_dispatch_address(const char *name, JsonVariant *variant, JsonDispatchFlags flags, void *userdata) {
 161         AddressParameters *p = userdata;
 162         union in_addr_union buf = {};
 163         JsonVariant *i;
 164         size_t n, k = 0;
 165
 166         assert(variant);
 167         assert(p);
 168
 169         if (!json_variant_is_array(variant))
 170                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
 171
 172         n = json_variant_elements(variant);
 173         if (!IN_SET(n, 4, 16))
 174                 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is array of unexpected size.", strna(name));
 175
 176         JSON_VARIANT_ARRAY_FOREACH(i, variant) {
 177                 int64_t b;
 178
 179                 if (!json_variant_is_integer(i))
 180                         return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "Element %zu of JSON field '%s' is not an integer.", k, strna(name));
 181
 182                 b = json_variant_integer(i);
 183                 if (b < 0 || b > 0xff)
 184                         return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL),
 185                                         "Element %zu of JSON field '%s' is out of range 0%s255.",
 186                                         k, strna(name), special_glyph(SPECIAL_GLYPH_ELLIPSIS));
 187
 188                 buf.bytes[k++] = (uint8_t) b;
 189         }
 190
 191         p->address = buf;
 192         p->address_size = k;
 193
 194         return 0;
 195 }
 196
 197 static const JsonDispatch address_parameters_dispatch_table[] = {
 198         { "ifindex", JSON_VARIANT_INTEGER,  json_dispatch_ifindex, offsetof(AddressParameters, ifindex), 0              },
 199         { "family",  JSON_VARIANT_INTEGER,  json_dispatch_family,  offsetof(AddressParameters, family),  JSON_MANDATORY },
 200         { "address", JSON_VARIANT_ARRAY,    json_dispatch_address, 0,                                    JSON_MANDATORY },
 201         {}
 202 };
 203
 204 static uint64_t query_flag(
 205                 const char *name,
 206                 const int value,
 207                 uint64_t flag) {
 208         int r;
 209
 210         r = getenv_bool_secure(name);
 211         if (r >= 0)
 212                 return r == value ? flag : 0;
 213         if (r != -ENXIO)
 214                 log_debug_errno(r, "Failed to parse $%s, ignoring.", name);
 215         return 0;
 216 }
 217
 218 static uint64_t query_flags(void) {
 219         /* Allow callers to turn off validation, synthetization, caching, etc., when we resolve via
 220          * nss-resolve. */
 221         return  query_flag("SYSTEMD_NSS_RESOLVE_VALIDATE", 0, SD_RESOLVED_NO_VALIDATE) |
 222                 query_flag("SYSTEMD_NSS_RESOLVE_SYNTHESIZE", 0, SD_RESOLVED_NO_SYNTHESIZE) |
 223                 query_flag("SYSTEMD_NSS_RESOLVE_CACHE", 0, SD_RESOLVED_NO_CACHE) |
 224                 query_flag("SYSTEMD_NSS_RESOLVE_ZONE", 0, SD_RESOLVED_NO_ZONE) |
 225                 query_flag("SYSTEMD_NSS_RESOLVE_TRUST_ANCHOR", 0, SD_RESOLVED_NO_TRUST_ANCHOR) |
 226                 query_flag("SYSTEMD_NSS_RESOLVE_NETWORK", 0, SD_RESOLVED_NO_NETWORK);
 227 }
 228
 229 enum nss_status _nss_resolve_gethostbyname4_r(
 230                 const char *name,
 231                 struct gaih_addrtuple **pat,
 232                 char *buffer, size_t buflen,
 233                 int *errnop, int *h_errnop,
 234                 int32_t *ttlp) {
 235
 236         _cleanup_(varlink_unrefp) Varlink *link = NULL;
 237         _cleanup_(json_variant_unrefp) JsonVariant *cparams = NULL;
 238         _cleanup_(resolve_hostname_reply_destroy) ResolveHostnameReply p = {};
 239         JsonVariant *rparams, *entry;
 240         int r;
 241
 242         PROTECT_ERRNO;
 243         NSS_ENTRYPOINT_BEGIN;
 244
 245         assert(name);
 246         assert(pat);
 247         assert(buffer);
 248         assert(errnop);
 249         assert(h_errnop);
 250
 251         r = connect_to_resolved(&link);
 252         if (r < 0)
 253                 goto fail;
 254
 255         r = json_build(&cparams, JSON_BUILD_OBJECT(
 256                                        JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
 257                                        JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(query_flags()))));
 258         if (r < 0)
 259                 goto fail;
 260
 261         /* Return NSS_STATUS_UNAVAIL when communication with systemd-resolved fails, allowing falling
 262          * back to other nss modules. Treat all other error conditions as NOTFOUND. This includes
 263          * DNSSEC errors and suchlike. (We don't use UNAVAIL in this case so that the nsswitch.conf
 264          * configuration can distinguish such executed but negative replies from complete failure to
 265          * talk to resolved). */
 266         const char *error_id;
 267         r = varlink_call(link, "io.systemd.Resolve.ResolveHostname", cparams, &rparams, &error_id, NULL);
 268         if (r < 0)
 269                 goto fail;
 270         if (!isempty(error_id)) {
 271                 if (error_shall_try_again(error_id))
 272                         goto try_again;
 273                 if (error_shall_fallback(error_id))
 274                         goto fail;
 275                 goto not_found;
 276         }
 277
 278         r = json_dispatch(rparams, resolve_hostname_reply_dispatch_table, NULL, json_dispatch_flags, &p);
 279         if (r < 0)
 280                 goto fail;
 281         if (json_variant_is_blank_object(p.addresses))
 282                 goto not_found;
 283
 284         size_t n_addresses = 0;
 285         JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
 286                 AddressParameters q = {};
 287
 288                 r = json_dispatch(entry, address_parameters_dispatch_table, NULL, json_dispatch_flags, &q);
 289                 if (r < 0)
 290                         goto fail;
 291
 292                 if (!IN_SET(q.family, AF_INET, AF_INET6))
 293                         continue;
 294
 295                 if (q.address_size != FAMILY_ADDRESS_SIZE(q.family)) {
 296                         r = -EINVAL;
 297                         goto fail;
 298                 }
 299
 300                 n_addresses++;
 301         }
 302
 303         const char *canonical = p.name ?: name;
 304         size_t l = strlen(canonical);
 305         size_t idx, ms = ALIGN(l+1) + ALIGN(sizeof(struct gaih_addrtuple)) * n_addresses;
 306
 307         if (buflen < ms) {
 308                 UNPROTECT_ERRNO;
 309                 *errnop = ERANGE;
 310                 *h_errnop = NETDB_INTERNAL;
 311                 return NSS_STATUS_TRYAGAIN;
 312         }
 313
 314         /* First, append name */
 315         char *r_name = buffer;
 316         memcpy(r_name, canonical, l + 1);
 317         idx = ALIGN(l + 1);
 318
 319         /* Second, append addresses */
 320         struct gaih_addrtuple *r_tuple = NULL,
 321                 *r_tuple_first = (struct gaih_addrtuple*) (buffer + idx);
 322
 323         JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
 324                 AddressParameters q = {};
 325
 326                 r = json_dispatch(entry, address_parameters_dispatch_table, NULL, json_dispatch_flags, &q);
 327                 if (r < 0)
 328                         goto fail;
 329
 330                 if (!IN_SET(q.family, AF_INET, AF_INET6))
 331                         continue;
 332
 333                 r_tuple = (struct gaih_addrtuple*) (buffer + idx);
 334                 r_tuple->next = (struct gaih_addrtuple*) ((char*) r_tuple + ALIGN(sizeof(struct gaih_addrtuple)));
 335                 r_tuple->name = r_name;
 336                 r_tuple->family = q.family;
 337                 r_tuple->scopeid = ifindex_to_scopeid(q.family, &q.address, q.ifindex);
 338                 memcpy(r_tuple->addr, &q.address, q.address_size);
 339
 340                 idx += ALIGN(sizeof(struct gaih_addrtuple));
 341         }
 342
 343         assert(r_tuple);  /* We had at least one address, so r_tuple must be set */
 344         r_tuple->next = NULL;  /* Override last next pointer */
 345
 346         assert(idx == ms);
 347
 348         if (*pat)
 349                 **pat = *r_tuple_first;
 350         else
 351                 *pat = r_tuple_first;
 352
 353         if (ttlp)
 354                 *ttlp = 0;
 355
 356         /* Explicitly reset both *h_errnop and h_errno to work around
 357          * https://bugzilla.redhat.com/show_bug.cgi?id=1125975 */
 358         *h_errnop = NETDB_SUCCESS;
 359         h_errno = 0;
 360
 361         return NSS_STATUS_SUCCESS;
 362
 363 fail:
 364         UNPROTECT_ERRNO;
 365         *errnop = -r;
 366         *h_errnop = NO_RECOVERY;
 367         return NSS_STATUS_UNAVAIL;
 368
 369 not_found:
 370         *h_errnop = HOST_NOT_FOUND;
 371         return NSS_STATUS_NOTFOUND;
 372
 373 try_again:
 374         UNPROTECT_ERRNO;
 375         *errnop = -r;
 376         *h_errnop = TRY_AGAIN;
 377         return NSS_STATUS_TRYAGAIN;
 378 }
 379
 380 enum nss_status _nss_resolve_gethostbyname3_r(
 381                 const char *name,
 382                 int af,
 383                 struct hostent *result,
 384                 char *buffer, size_t buflen,
 385                 int *errnop, int *h_errnop,
 386                 int32_t *ttlp,
 387                 char **canonp) {
 388
 389         _cleanup_(varlink_unrefp) Varlink *link = NULL;
 390         _cleanup_(json_variant_unrefp) JsonVariant *cparams = NULL;
 391         _cleanup_(resolve_hostname_reply_destroy) ResolveHostnameReply p = {};
 392         JsonVariant *rparams, *entry;
 393         int r;
 394
 395         PROTECT_ERRNO;
 396         NSS_ENTRYPOINT_BEGIN;
 397
 398         assert(name);
 399         assert(result);
 400         assert(buffer);
 401         assert(errnop);
 402         assert(h_errnop);
 403
 404         if (af == AF_UNSPEC)
 405                 af = AF_INET;
 406
 407         if (!IN_SET(af, AF_INET, AF_INET6)) {
 408                 r = -EAFNOSUPPORT;
 409                 goto fail;
 410         }
 411
 412         r = connect_to_resolved(&link);
 413         if (r < 0)
 414                 goto fail;
 415
 416         r = json_build(&cparams, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("name", JSON_BUILD_STRING(name)),
 417                                                    JSON_BUILD_PAIR("family", JSON_BUILD_INTEGER(af)),
 418                                                    JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(query_flags()))));
 419         if (r < 0)
 420                 goto fail;
 421
 422         const char *error_id;
 423         r = varlink_call(link, "io.systemd.Resolve.ResolveHostname", cparams, &rparams, &error_id, NULL);
 424         if (r < 0)
 425                 goto fail;
 426         if (!isempty(error_id)) {
 427                 if (error_shall_try_again(error_id))
 428                         goto try_again;
 429                 if (error_shall_fallback(error_id))
 430                         goto fail;
 431                 goto not_found;
 432         }
 433
 434         r = json_dispatch(rparams, resolve_hostname_reply_dispatch_table, NULL, json_dispatch_flags, &p);
 435         if (r < 0)
 436                 goto fail;
 437         if (json_variant_is_blank_object(p.addresses))
 438                 goto not_found;
 439
 440         size_t n_addresses = 0;
 441         JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
 442                 AddressParameters q = {};
 443
 444                 r = json_dispatch(entry, address_parameters_dispatch_table, NULL, json_dispatch_flags, &q);
 445                 if (r < 0)
 446                         goto fail;
 447
 448                 if (!IN_SET(q.family, AF_INET, AF_INET6))
 449                         continue;
 450
 451                 if (q.address_size != FAMILY_ADDRESS_SIZE(q.family)) {
 452                         r = -EINVAL;
 453                         goto fail;
 454                 }
 455
 456                 n_addresses++;
 457         }
 458
 459         const char *canonical = p.name ?: name;
 460
 461         size_t alen = FAMILY_ADDRESS_SIZE(af);
 462         size_t l = strlen(canonical);
 463
 464         size_t idx, ms = ALIGN(l + 1) + n_addresses * ALIGN(alen) + (n_addresses + 2) * sizeof(char*);
 465
 466         if (buflen < ms) {
 467                 UNPROTECT_ERRNO;
 468                 *errnop = ERANGE;
 469                 *h_errnop = NETDB_INTERNAL;
 470                 return NSS_STATUS_TRYAGAIN;
 471         }
 472
 473         /* First, append name */
 474         char *r_name = buffer;
 475         memcpy(r_name, canonical, l+1);
 476         idx = ALIGN(l+1);
 477
 478         /* Second, create empty aliases array */
 479         char *r_aliases = buffer + idx;
 480         ((char**) r_aliases)[0] = NULL;
 481         idx += sizeof(char*);
 482
 483         /* Third, append addresses */
 484         char *r_addr = buffer + idx;
 485
 486         size_t i = 0;
 487         JSON_VARIANT_ARRAY_FOREACH(entry, p.addresses) {
 488                 AddressParameters q = {};
 489
 490                 r = json_dispatch(entry, address_parameters_dispatch_table, NULL, json_dispatch_flags, &q);
 491                 if (r < 0)
 492                         goto fail;
 493
 494                 if (q.family != af)
 495                         continue;
 496
 497                 if (q.address_size != alen) {
 498                         r = -EINVAL;
 499                         goto fail;
 500                 }
 501
 502                 memcpy(r_addr + i*ALIGN(alen), &q.address, alen);
 503                 i++;
 504         }
 505
 506         assert(i == n_addresses);
 507         idx += n_addresses * ALIGN(alen);
 508
 509         /* Fourth, append address pointer array */
 510         char *r_addr_list = buffer + idx;
 511         for (i = 0; i < n_addresses; i++)
 512                 ((char**) r_addr_list)[i] = r_addr + i*ALIGN(alen);
 513
 514         ((char**) r_addr_list)[i] = NULL;
 515         idx += (n_addresses + 1) * sizeof(char*);
 516
 517         assert(idx == ms);
 518
 519         result->h_name = r_name;
 520         result->h_aliases = (char**) r_aliases;
 521         result->h_addrtype = af;
 522         result->h_length = alen;
 523         result->h_addr_list = (char**) r_addr_list;
 524
 525         if (ttlp)
 526                 *ttlp = 0;
 527
 528         if (canonp)
 529                 *canonp = r_name;
 530
 531         /* Explicitly reset both *h_errnop and h_errno to work around
 532          * https://bugzilla.redhat.com/show_bug.cgi?id=1125975 */
 533         *h_errnop = NETDB_SUCCESS;
 534         h_errno = 0;
 535
 536         return NSS_STATUS_SUCCESS;
 537
 538 fail:
 539         UNPROTECT_ERRNO;
 540         *errnop = -r;
 541         *h_errnop = NO_RECOVERY;
 542         return NSS_STATUS_UNAVAIL;
 543
 544 not_found:
 545         *h_errnop = HOST_NOT_FOUND;
 546         return NSS_STATUS_NOTFOUND;
 547
 548 try_again:
 549         UNPROTECT_ERRNO;
 550         *errnop = -r;
 551         *h_errnop = TRY_AGAIN;
 552         return NSS_STATUS_TRYAGAIN;
 553 }
 554
 555 typedef struct ResolveAddressReply {
 556         JsonVariant *names;
 557         uint64_t flags;
 558 } ResolveAddressReply;
 559
 560 static void resolve_address_reply_destroy(ResolveAddressReply *p) {
 561         assert(p);
 562
 563         json_variant_unref(p->names);
 564 }
 565
 566 static const JsonDispatch resolve_address_reply_dispatch_table[] = {
 567         { "names", JSON_VARIANT_ARRAY,    json_dispatch_variant, offsetof(ResolveAddressReply, names), JSON_MANDATORY },
 568         { "flags", JSON_VARIANT_UNSIGNED, json_dispatch_uint64,  offsetof(ResolveAddressReply, flags), 0              },
 569         {}
 570 };
 571
 572 typedef struct NameParameters {
 573         int ifindex;
 574         char *name;
 575 } NameParameters;
 576
 577 static void name_parameters_destroy(NameParameters *p) {
 578         assert(p);
 579
 580         free(p->name);
 581 }
 582
 583 static const JsonDispatch name_parameters_dispatch_table[] = {
 584         { "ifindex", JSON_VARIANT_INTEGER, json_dispatch_ifindex, offsetof(NameParameters, ifindex), 0              },
 585         { "name",    JSON_VARIANT_STRING,  json_dispatch_string,  offsetof(NameParameters, name),    JSON_MANDATORY },
 586         {}
 587 };
 588
 589 enum nss_status _nss_resolve_gethostbyaddr2_r(
 590                 const void* addr, socklen_t len,
 591                 int af,
 592                 struct hostent *result,
 593                 char *buffer, size_t buflen,
 594                 int *errnop, int *h_errnop,
 595                 int32_t *ttlp) {
 596
 597         _cleanup_(varlink_unrefp) Varlink *link = NULL;
 598         _cleanup_(json_variant_unrefp) JsonVariant *cparams = NULL;
 599         _cleanup_(resolve_address_reply_destroy) ResolveAddressReply p = {};
 600         JsonVariant *rparams, *entry;
 601         int r;
 602
 603         PROTECT_ERRNO;
 604         NSS_ENTRYPOINT_BEGIN;
 605
 606         assert(addr);
 607         assert(result);
 608         assert(buffer);
 609         assert(errnop);
 610         assert(h_errnop);
 611
 612         if (!IN_SET(af, AF_INET, AF_INET6)) {
 613                 UNPROTECT_ERRNO;
 614                 *errnop = EAFNOSUPPORT;
 615                 *h_errnop = NO_DATA;
 616                 return NSS_STATUS_UNAVAIL;
 617         }
 618
 619         if (len != FAMILY_ADDRESS_SIZE(af)) {
 620                 r = -EINVAL;
 621                 goto fail;
 622         }
 623
 624         r = connect_to_resolved(&link);
 625         if (r < 0)
 626                 goto fail;
 627
 628         r = json_build(&cparams, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("address", JSON_BUILD_BYTE_ARRAY(addr, len)),
 629                                                    JSON_BUILD_PAIR("family", JSON_BUILD_INTEGER(af)),
 630                                                    JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(query_flags()))));
 631         if (r < 0)
 632                 goto fail;
 633
 634         const char* error_id;
 635         r = varlink_call(link, "io.systemd.Resolve.ResolveAddress", cparams, &rparams, &error_id, NULL);
 636         if (r < 0)
 637                 goto fail;
 638         if (!isempty(error_id)) {
 639                 if (error_shall_try_again(error_id))
 640                         goto try_again;
 641                 if (error_shall_fallback(error_id))
 642                         goto fail;
 643                 goto not_found;
 644         }
 645
 646         r = json_dispatch(rparams, resolve_address_reply_dispatch_table, NULL, json_dispatch_flags, &p);
 647         if (r < 0)
 648                 goto fail;
 649         if (json_variant_is_blank_object(p.names))
 650                 goto not_found;
 651
 652         size_t ms = 0, idx;
 653
 654         JSON_VARIANT_ARRAY_FOREACH(entry, p.names) {
 655                 _cleanup_(name_parameters_destroy) NameParameters q = {};
 656
 657                 r = json_dispatch(entry, name_parameters_dispatch_table, NULL, json_dispatch_flags, &q);
 658                 if (r < 0)
 659                         goto fail;
 660
 661                 ms += ALIGN(strlen(q.name) + 1);
 662         }
 663
 664         size_t n_names = json_variant_elements(p.names);
 665         ms += ALIGN(len) +                    /* the address */
 666               2 * sizeof(char*) +             /* pointer to the address, plus trailing NULL */
 667               n_names * sizeof(char*);        /* pointers to aliases, plus trailing NULL */
 668
 669         if (buflen < ms) {
 670                 UNPROTECT_ERRNO;
 671                 *errnop = ERANGE;
 672                 *h_errnop = NETDB_INTERNAL;
 673                 return NSS_STATUS_TRYAGAIN;
 674         }
 675
 676         /* First, place address */
 677         char *r_addr = buffer;
 678         memcpy(r_addr, addr, len);
 679         idx = ALIGN(len);
 680
 681         /* Second, place address list */
 682         char *r_addr_list = buffer + idx;
 683         ((char**) r_addr_list)[0] = r_addr;
 684         ((char**) r_addr_list)[1] = NULL;
 685         idx += sizeof(char*) * 2;
 686
 687         /* Third, reserve space for the aliases array, plus trailing NULL */
 688         char *r_aliases = buffer + idx;
 689         idx += sizeof(char*) * n_names;
 690
 691         /* Fourth, place aliases */
 692         char *r_name = buffer + idx;
 693
 694         size_t i = 0;
 695         JSON_VARIANT_ARRAY_FOREACH(entry, p.names) {
 696                 _cleanup_(name_parameters_destroy) NameParameters q = {};
 697
 698                 r = json_dispatch(entry, name_parameters_dispatch_table, NULL, json_dispatch_flags, &q);
 699                 if (r < 0)
 700                         goto fail;
 701
 702                 size_t l = strlen(q.name);
 703                 char *z = buffer + idx;
 704                 memcpy(z, q.name, l + 1);
 705
 706                 if (i > 0)
 707                         ((char**) r_aliases)[i - 1] = z;
 708                 i++;
 709
 710                 idx += ALIGN(l + 1);
 711         }
 712         ((char**) r_aliases)[n_names - 1] = NULL;
 713
 714         assert(idx == ms);
 715
 716         result->h_name = r_name;
 717         result->h_aliases = (char**) r_aliases;
 718         result->h_addrtype = af;
 719         result->h_length = len;
 720         result->h_addr_list = (char**) r_addr_list;
 721
 722         if (ttlp)
 723                 *ttlp = 0;
 724
 725         /* Explicitly reset both *h_errnop and h_errno to work around
 726          * https://bugzilla.redhat.com/show_bug.cgi?id=1125975 */
 727         *h_errnop = NETDB_SUCCESS;
 728         h_errno = 0;
 729
 730         return NSS_STATUS_SUCCESS;
 731
 732 fail:
 733         UNPROTECT_ERRNO;
 734         *errnop = -r;
 735         *h_errnop = NO_RECOVERY;
 736         return NSS_STATUS_UNAVAIL;
 737
 738 not_found:
 739         *h_errnop = HOST_NOT_FOUND;
 740         return NSS_STATUS_NOTFOUND;
 741
 742 try_again:
 743         UNPROTECT_ERRNO;
 744         *errnop = -r;
 745         *h_errnop = TRY_AGAIN;
 746         return NSS_STATUS_TRYAGAIN;
 747 }
 748
 749 NSS_GETHOSTBYNAME_FALLBACKS(resolve);
 750 NSS_GETHOSTBYADDR_FALLBACKS(resolve);