src/resolve/resolved-dns-synthesize.c

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