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