src/resolve/resolved-dns-synthesize.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "hostname-util.h"
   5 #include "local-addresses.h"
   6 #include "missing_network.h"
   7 #include "resolved-dns-synthesize.h"
   8
   9 int dns_synthesize_ifindex(int ifindex) {
  10
  11         /* When the caller asked for resolving on a specific
  12          * interface, we synthesize the answer for that
  13          * interface. However, if nothing specific was claimed and we
  14          * only return localhost RRs, we synthesize the answer for
  15          * localhost. */
  16
  17         if (ifindex > 0)
  18                 return ifindex;
  19
  20         return LOOPBACK_IFINDEX;
  21 }
  22
  23 int dns_synthesize_family(uint64_t flags) {
  24
  25         /* Picks an address family depending on set flags. This is
  26          * purely for synthesized answers, where the family we return
  27          * for the reply should match what was requested in the
  28          * question, even though we are synthesizing the answer
  29          * here. */
  30
  31         if (!(flags & SD_RESOLVED_DNS)) {
  32                 if (flags & (SD_RESOLVED_LLMNR_IPV4|SD_RESOLVED_MDNS_IPV4))
  33                         return AF_INET;
  34                 if (flags & (SD_RESOLVED_LLMNR_IPV6|SD_RESOLVED_MDNS_IPV6))
  35                         return AF_INET6;
  36         }
  37
  38         return AF_UNSPEC;
  39 }
  40
  41 DnsProtocol dns_synthesize_protocol(uint64_t flags) {
  42
  43         /* Similar as dns_synthesize_family() but does this for the
  44          * protocol. If resolving via DNS was requested, we claim it
  45          * was DNS. Similar, if nothing specific was
  46          * requested. However, if only resolving via LLMNR was
  47          * requested we return that. */
  48
  49         if (flags & SD_RESOLVED_DNS)
  50                 return DNS_PROTOCOL_DNS;
  51         if (flags & SD_RESOLVED_LLMNR)
  52                 return DNS_PROTOCOL_LLMNR;
  53         if (flags & SD_RESOLVED_MDNS)
  54                 return DNS_PROTOCOL_MDNS;
  55
  56         return DNS_PROTOCOL_DNS;
  57 }
  58
  59 static int synthesize_localhost_rr(Manager *m, const DnsResourceKey *key, int ifindex, DnsAnswer **answer) {
  60         int r;
  61
  62         assert(m);
  63         assert(key);
  64         assert(answer);
  65
  66         r = dns_answer_reserve(answer, 2);
  67         if (r < 0)
  68                 return r;
  69
  70         if (IN_SET(key->type, DNS_TYPE_A, DNS_TYPE_ANY)) {
  71                 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
  72
  73                 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, dns_resource_key_name(key));
  74                 if (!rr)
  75                         return -ENOMEM;
  76
  77                 rr->a.in_addr.s_addr = htobe32(INADDR_LOOPBACK);
  78
  79                 r = dns_answer_add(*answer, rr, dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
  80                 if (r < 0)
  81                         return r;
  82         }
  83
  84         if (IN_SET(key->type, DNS_TYPE_AAAA, DNS_TYPE_ANY)) {
  85                 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
  86
  87                 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_AAAA, dns_resource_key_name(key));
  88                 if (!rr)
  89                         return -ENOMEM;
  90
  91                 rr->aaaa.in6_addr = in6addr_loopback;
  92
  93                 r = dns_answer_add(*answer, rr, dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
  94                 if (r < 0)
  95                         return r;
  96         }
  97
  98         return 0;
  99 }
 100
 101 static int answer_add_ptr(DnsAnswer **answer, const char *from, const char *to, int ifindex, DnsAnswerFlags flags) {
 102         _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 103
 104         rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_PTR, from);
 105         if (!rr)
 106                 return -ENOMEM;
 107
 108         rr->ptr.name = strdup(to);
 109         if (!rr->ptr.name)
 110                 return -ENOMEM;
 111
 112         return dns_answer_add(*answer, rr, ifindex, flags);
 113 }
 114
 115 static int synthesize_localhost_ptr(Manager *m, const DnsResourceKey *key, int ifindex, DnsAnswer **answer) {
 116         int r;
 117
 118         assert(m);
 119         assert(key);
 120         assert(answer);
 121
 122         if (IN_SET(key->type, DNS_TYPE_PTR, DNS_TYPE_ANY)) {
 123                 r = dns_answer_reserve(answer, 1);
 124                 if (r < 0)
 125                         return r;
 126
 127                 r = answer_add_ptr(answer, dns_resource_key_name(key), "localhost", dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
 128                 if (r < 0)
 129                         return r;
 130         }
 131
 132         return 0;
 133 }
 134
 135 static int answer_add_addresses_rr(
 136                 DnsAnswer **answer,
 137                 const char *name,
 138                 struct local_address *addresses,
 139                 unsigned n_addresses) {
 140
 141         unsigned j;
 142         int r;
 143
 144         assert(answer);
 145         assert(name);
 146
 147         r = dns_answer_reserve(answer, n_addresses);
 148         if (r < 0)
 149                 return r;
 150
 151         for (j = 0; j < n_addresses; j++) {
 152                 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 153
 154                 r = dns_resource_record_new_address(&rr, addresses[j].family, &addresses[j].address, name);
 155                 if (r < 0)
 156                         return r;
 157
 158                 r = dns_answer_add(*answer, rr, addresses[j].ifindex, DNS_ANSWER_AUTHENTICATED);
 159                 if (r < 0)
 160                         return r;
 161         }
 162
 163         return 0;
 164 }
 165
 166 static int answer_add_addresses_ptr(
 167                 DnsAnswer **answer,
 168                 const char *name,
 169                 struct local_address *addresses,
 170                 unsigned n_addresses,
 171                 int af, const union in_addr_union *match) {
 172
 173         bool added = false;
 174         unsigned j;
 175         int r;
 176
 177         assert(answer);
 178         assert(name);
 179
 180         for (j = 0; j < n_addresses; j++) {
 181                 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
 182
 183                 if (af != AF_UNSPEC) {
 184
 185                         if (addresses[j].family != af)
 186                                 continue;
 187
 188                         if (match && !in_addr_equal(af, match, &addresses[j].address))
 189                                 continue;
 190                 }
 191
 192                 r = dns_answer_reserve(answer, 1);
 193                 if (r < 0)
 194                         return r;
 195
 196                 r = dns_resource_record_new_reverse(&rr, addresses[j].family, &addresses[j].address, name);
 197                 if (r < 0)
 198                         return r;
 199
 200                 r = dns_answer_add(*answer, rr, addresses[j].ifindex, DNS_ANSWER_AUTHENTICATED);
 201                 if (r < 0)
 202                         return r;
 203
 204                 added = true;
 205         }
 206
 207         return added;
 208 }
 209
 210 static int synthesize_system_hostname_rr(Manager *m, const DnsResourceKey *key, int ifindex, DnsAnswer **answer) {
 211         _cleanup_free_ struct local_address *addresses = NULL;
 212         int n = 0, af;
 213
 214         assert(m);
 215         assert(key);
 216         assert(answer);
 217
 218         af = dns_type_to_af(key->type);
 219         if (af >= 0) {
 220                 n = local_addresses(m->rtnl, ifindex, af, &addresses);
 221                 if (n < 0)
 222                         return n;
 223
 224                 if (n == 0) {
 225                         struct local_address buffer[2];
 226
 227                         /* If we have no local addresses then use ::1
 228                          * and 127.0.0.2 as local ones. */
 229
 230                         if (IN_SET(af, AF_INET, AF_UNSPEC))
 231                                 buffer[n++] = (struct local_address) {
 232                                         .family = AF_INET,
 233                                         .ifindex = dns_synthesize_ifindex(ifindex),
 234                                         .address.in.s_addr = htobe32(0x7F000002),
 235                                 };
 236
 237                         if (IN_SET(af, AF_INET6, AF_UNSPEC))
 238                                 buffer[n++] = (struct local_address) {
 239                                         .family = AF_INET6,
 240                                         .ifindex = dns_synthesize_ifindex(ifindex),
 241                                         .address.in6 = in6addr_loopback,
 242                                 };
 243
 244                         return answer_add_addresses_rr(answer,
 245                                                        dns_resource_key_name(key),
 246                                                        buffer, n);
 247                 }
 248         }
 249
 250         return answer_add_addresses_rr(answer, dns_resource_key_name(key), addresses, n);
 251 }
 252
 253 static int synthesize_system_hostname_ptr(Manager *m, int af, const union in_addr_union *address, int ifindex, DnsAnswer **answer) {
 254         _cleanup_free_ struct local_address *addresses = NULL;
 255         bool added = false;
 256         int n, r;
 257
 258         assert(m);
 259         assert(address);
 260         assert(answer);
 261
 262         if (af == AF_INET && address->in.s_addr == htobe32(0x7F000002)) {
 263
 264                 /* Always map the IPv4 address 127.0.0.2 to the local hostname, in addition to "localhost": */
 265
 266                 r = dns_answer_reserve(answer, 4);
 267                 if (r < 0)
 268                         return r;
 269
 270                 r = answer_add_ptr(answer, "2.0.0.127.in-addr.arpa", m->full_hostname, dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
 271                 if (r < 0)
 272                         return r;
 273
 274                 r = answer_add_ptr(answer, "2.0.0.127.in-addr.arpa", m->llmnr_hostname, dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
 275                 if (r < 0)
 276                         return r;
 277
 278                 r = answer_add_ptr(answer, "2.0.0.127.in-addr.arpa", m->mdns_hostname, dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
 279                 if (r < 0)
 280                         return r;
 281
 282                 r = answer_add_ptr(answer, "2.0.0.127.in-addr.arpa", "localhost", dns_synthesize_ifindex(ifindex), DNS_ANSWER_AUTHENTICATED);
 283                 if (r < 0)
 284                         return r;
 285
 286                 return 1;
 287         }
 288
 289         n = local_addresses(m->rtnl, ifindex, af, &addresses);
 290         if (n <= 0)
 291                 return n;
 292
 293         r = answer_add_addresses_ptr(answer, m->full_hostname, addresses, n, af, address);
 294         if (r < 0)
 295                 return r;
 296         if (r > 0)
 297                 added = true;
 298
 299         r = answer_add_addresses_ptr(answer, m->llmnr_hostname, addresses, n, af, address);
 300         if (r < 0)
 301                 return r;
 302         if (r > 0)
 303                 added = true;
 304
 305         r = answer_add_addresses_ptr(answer, m->mdns_hostname, addresses, n, af, address);
 306         if (r < 0)
 307                 return r;
 308         if (r > 0)
 309                 added = true;
 310
 311         return added;
 312 }
 313
 314 static int synthesize_gateway_rr(Manager *m, const DnsResourceKey *key, int ifindex, DnsAnswer **answer) {
 315         _cleanup_free_ struct local_address *addresses = NULL;
 316         int n = 0, af, r;
 317
 318         assert(m);
 319         assert(key);
 320         assert(answer);
 321
 322         af = dns_type_to_af(key->type);
 323         if (af >= 0) {
 324                 n = local_gateways(m->rtnl, ifindex, af, &addresses);
 325                 if (n <= 0)
 326                         return n;  /* < 0 means: error; == 0 means we have no gateway */
 327         }
 328
 329         r = answer_add_addresses_rr(answer, dns_resource_key_name(key), addresses, n);
 330         if (r < 0)
 331                 return r;
 332
 333         return 1; /* > 0 means: we have some gateway */
 334 }
 335
 336 static int synthesize_gateway_ptr(Manager *m, int af, const union in_addr_union *address, int ifindex, DnsAnswer **answer) {
 337         _cleanup_free_ struct local_address *addresses = NULL;
 338         int n;
 339
 340         assert(m);
 341         assert(address);
 342         assert(answer);
 343
 344         n = local_gateways(m->rtnl, ifindex, af, &addresses);
 345         if (n <= 0)
 346                 return n;
 347
 348         return answer_add_addresses_ptr(answer, "_gateway", addresses, n, af, address);
 349 }
 350
 351 int dns_synthesize_answer(
 352                 Manager *m,
 353                 DnsQuestion *q,
 354                 int ifindex,
 355                 DnsAnswer **ret) {
 356
 357         _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
 358         DnsResourceKey *key;
 359         bool found = false, nxdomain = false;
 360         int r;
 361
 362         assert(m);
 363         assert(q);
 364
 365         DNS_QUESTION_FOREACH(key, q) {
 366                 union in_addr_union address;
 367                 const char *name;
 368                 int af;
 369
 370                 if (!IN_SET(key->class, DNS_CLASS_IN, DNS_CLASS_ANY))
 371                         continue;
 372
 373                 name = dns_resource_key_name(key);
 374
 375                 if (is_localhost(name)) {
 376
 377                         r = synthesize_localhost_rr(m, key, ifindex, &answer);
 378                         if (r < 0)
 379                                 return log_error_errno(r, "Failed to synthesize localhost RRs: %m");
 380
 381                 } else if (manager_is_own_hostname(m, name)) {
 382
 383                         r = synthesize_system_hostname_rr(m, key, ifindex, &answer);
 384                         if (r < 0)
 385                                 return log_error_errno(r, "Failed to synthesize system hostname RRs: %m");
 386
 387                 } else if (is_gateway_hostname(name)) {
 388
 389                         r = synthesize_gateway_rr(m, key, ifindex, &answer);
 390                         if (r < 0)
 391                                 return log_error_errno(r, "Failed to synthesize gateway RRs: %m");
 392                         if (r == 0) { /* if we have no gateway return NXDOMAIN */
 393                                 nxdomain = true;
 394                                 continue;
 395                         }
 396
 397                 } else if ((dns_name_endswith(name, "127.in-addr.arpa") > 0 && dns_name_equal(name, "2.0.0.127.in-addr.arpa") == 0) ||
 398                            dns_name_equal(name, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa") > 0) {
 399
 400                         r = synthesize_localhost_ptr(m, key, ifindex, &answer);
 401                         if (r < 0)
 402                                 return log_error_errno(r, "Failed to synthesize localhost PTR RRs: %m");
 403
 404                 } else if (dns_name_address(name, &af, &address) > 0) {
 405                         int v, w;
 406
 407                         v = synthesize_system_hostname_ptr(m, af, &address, ifindex, &answer);
 408                         if (v < 0)
 409                                 return log_error_errno(v, "Failed to synthesize system hostname PTR RR: %m");
 410
 411                         w = synthesize_gateway_ptr(m, af, &address, ifindex, &answer);
 412                         if (w < 0)
 413                                 return log_error_errno(w, "Failed to synthesize gateway hostname PTR RR: %m");
 414
 415                         if (v == 0 && w == 0) /* This IP address is neither a local one nor a gateway */
 416                                 continue;
 417
 418                 } else
 419                         continue;
 420
 421                 found = true;
 422         }
 423
 424         if (found) {
 425
 426                 if (ret)
 427                         *ret = TAKE_PTR(answer);
 428
 429                 return 1;
 430         } else if (nxdomain)
 431                 return -ENXIO;
 432
 433         return 0;
 434 }