X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fresolve%2Fresolved-dns-rr.c;h=fd5ecf413dc76921b3c6f72783ba8b79bf16cf24;hb=d1bddcec98551ea748f39a742a4cbcf9ea9254ef;hp=5097eff0838f36c24b46106bc5b4ce1705912916;hpb=623a4c97b9175f95c4b1c6fc34e36c56f1e4ddbf;p=elogind.git

diff --git a/src/resolve/resolved-dns-rr.c b/src/resolve/resolved-dns-rr.c
index 5097eff08..fd5ecf413 100644
--- a/src/resolve/resolved-dns-rr.c
+++ b/src/resolve/resolved-dns-rr.c
@@ -19,8 +19,14 @@
   along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/
 
+#include <math.h>
+
+#include "strv.h"
+
 #include "resolved-dns-domain.h"
 #include "resolved-dns-rr.h"
+#include "resolved-dns-packet.h"
+#include "dns-type.h"
 
 DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
         DnsResourceKey *k;
@@ -127,7 +133,7 @@ int dns_resource_key_match_cname(const DnsResourceKey *key, const DnsResourceRec
         return dns_name_equal(DNS_RESOURCE_KEY_NAME(rr->key), DNS_RESOURCE_KEY_NAME(key));
 }
 
-unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
+static unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[HASH_KEY_SIZE]) {
         const DnsResourceKey *k = i;
         unsigned long ul;
 
@@ -138,7 +144,7 @@ unsigned long dns_resource_key_hash_func(const void *i, const uint8_t hash_key[H
         return ul;
 }
 
-int dns_resource_key_compare_func(const void *a, const void *b) {
+static int dns_resource_key_compare_func(const void *a, const void *b) {
         const DnsResourceKey *x = a, *y = b;
         int ret;
 
@@ -159,6 +165,35 @@ int dns_resource_key_compare_func(const void *a, const void *b) {
         return 0;
 }
 
+const struct hash_ops dns_resource_key_hash_ops = {
+        .hash = dns_resource_key_hash_func,
+        .compare = dns_resource_key_compare_func
+};
+
+int dns_resource_key_to_string(const DnsResourceKey *key, char **ret) {
+        char cbuf[DECIMAL_STR_MAX(uint16_t)], tbuf[DECIMAL_STR_MAX(uint16_t)];
+        const char *c, *t;
+        char *s;
+
+        c = dns_class_to_string(key->class);
+        if (!c) {
+                sprintf(cbuf, "%i", key->class);
+                c = cbuf;
+        }
+
+        t = dns_type_to_string(key->type);
+        if (!t){
+                sprintf(tbuf, "%i", key->type);
+                t = tbuf;
+        }
+
+        if (asprintf(&s, "%s %s %-5s", DNS_RESOURCE_KEY_NAME(key), c, t) < 0)
+                return -ENOMEM;
+
+        *ret = s;
+        return 0;
+}
+
 DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
         DnsResourceRecord *rr;
 
@@ -172,6 +207,16 @@ DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
         return rr;
 }
 
+DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name) {
+        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
+
+        key = dns_resource_key_new(class, type, name);
+        if (!key)
+                return NULL;
+
+        return dns_resource_record_new(key);
+}
+
 DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr) {
         if (!rr)
                 return NULL;
@@ -194,16 +239,59 @@ DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
         }
 
         if (rr->key) {
-                if (IN_SET(rr->key->type, DNS_TYPE_PTR, DNS_TYPE_NS, DNS_TYPE_CNAME))
+                switch(rr->key->type) {
+
+                case DNS_TYPE_SRV:
+                        free(rr->srv.name);
+                        break;
+
+                case DNS_TYPE_PTR:
+                case DNS_TYPE_NS:
+                case DNS_TYPE_CNAME:
+                case DNS_TYPE_DNAME:
                         free(rr->ptr.name);
-                else if (rr->key->type == DNS_TYPE_HINFO) {
+                        break;
+
+                case DNS_TYPE_HINFO:
                         free(rr->hinfo.cpu);
                         free(rr->hinfo.os);
-                } else if (rr->key->type == DNS_TYPE_SOA) {
+                        break;
+
+                case DNS_TYPE_TXT:
+                case DNS_TYPE_SPF:
+                        strv_free(rr->txt.strings);
+                        break;
+
+                case DNS_TYPE_SOA:
                         free(rr->soa.mname);
                         free(rr->soa.rname);
-                } else if (!IN_SET(rr->key->type, DNS_TYPE_A, DNS_TYPE_AAAA))
+                        break;
+
+                case DNS_TYPE_MX:
+                        free(rr->mx.exchange);
+                        break;
+
+                case DNS_TYPE_SSHFP:
+                        free(rr->sshfp.key);
+                        break;
+
+                case DNS_TYPE_DNSKEY:
+                        free(rr->dnskey.key);
+                        break;
+
+                case DNS_TYPE_RRSIG:
+                        free(rr->rrsig.signer);
+                        free(rr->rrsig.signature);
+                        break;
+
+                case DNS_TYPE_LOC:
+                case DNS_TYPE_A:
+                case DNS_TYPE_AAAA:
+                        break;
+
+                default:
                         free(rr->generic.data);
+                }
 
                 dns_resource_key_unref(rr->key);
         }
@@ -257,16 +345,47 @@ int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecor
         if (r <= 0)
                 return r;
 
-        if (IN_SET(a->key->type, DNS_TYPE_PTR, DNS_TYPE_NS, DNS_TYPE_CNAME))
+        if (a->unparseable != b->unparseable)
+                return 0;
+
+        switch (a->unparseable ? _DNS_TYPE_INVALID : a->key->type) {
+
+        case DNS_TYPE_SRV:
+                r = dns_name_equal(a->srv.name, b->srv.name);
+                if (r <= 0)
+                        return r;
+
+                return a->srv.priority == b->srv.priority &&
+                       a->srv.weight == b->srv.weight &&
+                       a->srv.port == b->srv.port;
+
+        case DNS_TYPE_PTR:
+        case DNS_TYPE_NS:
+        case DNS_TYPE_CNAME:
+        case DNS_TYPE_DNAME:
                 return dns_name_equal(a->ptr.name, b->ptr.name);
-        else if (a->key->type == DNS_TYPE_HINFO)
-                return strcasecmp(a->hinfo.cpu, b->hinfo.cpu) == 0 &&
-                       strcasecmp(a->hinfo.os, b->hinfo.os) == 0;
-        else if (a->key->type == DNS_TYPE_A)
+
+        case DNS_TYPE_HINFO:
+                return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
+                       strcaseeq(a->hinfo.os, b->hinfo.os);
+
+        case DNS_TYPE_SPF: /* exactly the same as TXT */
+        case DNS_TYPE_TXT: {
+                int i;
+
+                for (i = 0; a->txt.strings[i] || b->txt.strings[i]; i++)
+                        if (!streq_ptr(a->txt.strings[i], b->txt.strings[i]))
+                                return false;
+                return true;
+        }
+
+        case DNS_TYPE_A:
                 return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
-        else if (a->key->type == DNS_TYPE_AAAA)
+
+        case DNS_TYPE_AAAA:
                 return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
-        else if (a->key->type == DNS_TYPE_SOA) {
+
+        case DNS_TYPE_SOA:
                 r = dns_name_equal(a->soa.mname, b->soa.mname);
                 if (r <= 0)
                         return r;
@@ -279,83 +398,307 @@ int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecor
                        a->soa.retry   == b->soa.retry &&
                        a->soa.expire  == b->soa.expire &&
                        a->soa.minimum == b->soa.minimum;
-        } else
-                return a->generic.size == b->generic.size &&
-                        memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
-}
 
-const char *dns_class_to_string(uint16_t class) {
+        case DNS_TYPE_MX:
+                if (a->mx.priority != b->mx.priority)
+                        return 0;
 
-        switch (class) {
+                return dns_name_equal(a->mx.exchange, b->mx.exchange);
 
-        case DNS_CLASS_IN:
-                return "IN";
+        case DNS_TYPE_LOC:
+                assert(a->loc.version == b->loc.version);
 
-        case DNS_CLASS_ANY:
-                return "ANY";
-        }
+                return a->loc.size == b->loc.size &&
+                       a->loc.horiz_pre == b->loc.horiz_pre &&
+                       a->loc.vert_pre == b->loc.vert_pre &&
+                       a->loc.latitude == b->loc.latitude &&
+                       a->loc.longitude == b->loc.longitude &&
+                       a->loc.altitude == b->loc.altitude;
 
-        return NULL;
+        case DNS_TYPE_SSHFP:
+                return a->sshfp.algorithm == b->sshfp.algorithm &&
+                       a->sshfp.fptype == b->sshfp.fptype &&
+                       a->sshfp.key_size == b->sshfp.key_size &&
+                       memcmp(a->sshfp.key, b->sshfp.key, a->sshfp.key_size) == 0;
+
+        case DNS_TYPE_DNSKEY:
+                return a->dnskey.zone_key_flag == b->dnskey.zone_key_flag &&
+                       a->dnskey.sep_flag == b->dnskey.sep_flag &&
+                       a->dnskey.algorithm == b->dnskey.algorithm &&
+                       a->dnskey.key_size == b->dnskey.key_size &&
+                       memcmp(a->dnskey.key, b->dnskey.key, a->dnskey.key_size) == 0;
+
+        case DNS_TYPE_RRSIG:
+                /* do the fast comparisons first */
+                if (a->rrsig.type_covered != b->rrsig.type_covered ||
+                    a->rrsig.algorithm != b->rrsig.algorithm ||
+                    a->rrsig.labels != b->rrsig.labels ||
+                    a->rrsig.original_ttl != b->rrsig.original_ttl ||
+                    a->rrsig.expiration != b->rrsig.expiration ||
+                    a->rrsig.inception != b->rrsig.inception ||
+                    a->rrsig.key_tag != b->rrsig.key_tag ||
+                    a->rrsig.signature_size != b->rrsig.signature_size ||
+                    memcmp(a->rrsig.signature, b->rrsig.signature, a->rrsig.signature_size) != 0)
+                        return false;
+
+                return dns_name_equal(a->rrsig.signer, b->rrsig.signer);
+
+        default:
+                return a->generic.size == b->generic.size &&
+                        memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
+        }
 }
 
-const char *dns_type_to_string(uint16_t type) {
+static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t altitude,
+                             uint8_t size, uint8_t horiz_pre, uint8_t vert_pre) {
+        char *s;
+        char NS = latitude >= 1U<<31 ? 'N' : 'S';
+        char EW = longitude >= 1U<<31 ? 'E' : 'W';
+
+        int lat = latitude >= 1U<<31 ? (int) (latitude - (1U<<31)) : (int) ((1U<<31) - latitude);
+        int lon = longitude >= 1U<<31 ? (int) (longitude - (1U<<31)) : (int) ((1U<<31) - longitude);
+        double alt = altitude >= 10000000u ? altitude - 10000000u : -(double)(10000000u - altitude);
+        double siz = (size >> 4) * exp10((double) (size & 0xF));
+        double hor = (horiz_pre >> 4) * exp10((double) (horiz_pre & 0xF));
+        double ver = (vert_pre >> 4) * exp10((double) (vert_pre & 0xF));
+
+        if (asprintf(&s, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
+                     (lat / 60000 / 60),
+                     (lat / 60000) % 60,
+                     (lat % 60000) / 1000.,
+                     NS,
+                     (lon / 60000 / 60),
+                     (lon / 60000) % 60,
+                     (lon % 60000) / 1000.,
+                     EW,
+                     alt / 100.,
+                     siz / 100.,
+                     hor / 100.,
+                     ver / 100.) < 0)
+                return NULL;
 
-        switch (type) {
+        return s;
+}
 
-        case DNS_TYPE_A:
-                return "A";
+int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
+        _cleanup_free_ char *k = NULL, *t = NULL;
+        char *s;
+        int r;
 
-        case DNS_TYPE_NS:
-                return "NS";
+        assert(rr);
 
-        case DNS_TYPE_CNAME:
-                return "CNAME";
+        r = dns_resource_key_to_string(rr->key, &k);
+        if (r < 0)
+                return r;
 
-        case DNS_TYPE_SOA:
-                return "SOA";
+        switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {
+
+        case DNS_TYPE_SRV:
+                r = asprintf(&s, "%s %u %u %u %s",
+                             k,
+                             rr->srv.priority,
+                             rr->srv.weight,
+                             rr->srv.port,
+                             strna(rr->srv.name));
+                if (r < 0)
+                        return -ENOMEM;
+                break;
 
         case DNS_TYPE_PTR:
-                return "PTR";
+        case DNS_TYPE_NS:
+        case DNS_TYPE_CNAME:
+        case DNS_TYPE_DNAME:
+                s = strjoin(k, " ", rr->ptr.name, NULL);
+                if (!s)
+                        return -ENOMEM;
 
-        case DNS_TYPE_HINFO:
-                return "HINFO";
+                break;
 
-        case DNS_TYPE_MX:
-                return "MX";
+        case DNS_TYPE_HINFO:
+                s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
+                if (!s)
+                        return -ENOMEM;
+                break;
 
+        case DNS_TYPE_SPF: /* exactly the same as TXT */
         case DNS_TYPE_TXT:
-                return "TXT";
+                t = strv_join_quoted(rr->txt.strings);
+                if (!t)
+                        return -ENOMEM;
+
+                s = strjoin(k, " ", t, NULL);
+                if (!s)
+                        return -ENOMEM;
+
+                break;
+
+        case DNS_TYPE_A: {
+                _cleanup_free_ char *x = NULL;
+
+                r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &x);
+                if (r < 0)
+                        return r;
+
+                s = strjoin(k, " ", x, NULL);
+                if (!s)
+                        return -ENOMEM;
+                break;
+        }
 
         case DNS_TYPE_AAAA:
-                return "AAAA";
+                r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
+                if (r < 0)
+                        return r;
 
-        case DNS_TYPE_SRV:
-                return "SRV";
+                s = strjoin(k, " ", t, NULL);
+                if (!s)
+                        return -ENOMEM;
+                break;
+
+        case DNS_TYPE_SOA:
+                r = asprintf(&s, "%s %s %s %u %u %u %u %u",
+                             k,
+                             strna(rr->soa.mname),
+                             strna(rr->soa.rname),
+                             rr->soa.serial,
+                             rr->soa.refresh,
+                             rr->soa.retry,
+                             rr->soa.expire,
+                             rr->soa.minimum);
+                if (r < 0)
+                        return -ENOMEM;
+                break;
+
+        case DNS_TYPE_MX:
+                r = asprintf(&s, "%s %u %s",
+                             k,
+                             rr->mx.priority,
+                             rr->mx.exchange);
+                if (r < 0)
+                        return -ENOMEM;
+                break;
+
+        case DNS_TYPE_LOC:
+                assert(rr->loc.version == 0);
+
+                t = format_location(rr->loc.latitude,
+                                    rr->loc.longitude,
+                                    rr->loc.altitude,
+                                    rr->loc.size,
+                                    rr->loc.horiz_pre,
+                                    rr->loc.vert_pre);
+                if (!t)
+                        return -ENOMEM;
+
+                s = strjoin(k, " ", t, NULL);
+                if (!s)
+                        return -ENOMEM;
+                break;
 
         case DNS_TYPE_SSHFP:
-                return "SSHFP";
+                t = hexmem(rr->sshfp.key, rr->sshfp.key_size);
+                if (!t)
+                        return -ENOMEM;
+
+                r = asprintf(&s, "%s %u %u %s",
+                             k,
+                             rr->sshfp.algorithm,
+                             rr->sshfp.fptype,
+                             t);
+                if (r < 0)
+                        return -ENOMEM;
+                break;
+
+        case DNS_TYPE_DNSKEY: {
+                const char *alg;
+
+                alg = dnssec_algorithm_to_string(rr->dnskey.algorithm);
+
+                t = hexmem(rr->dnskey.key, rr->dnskey.key_size);
+                if (!t)
+                        return -ENOMEM;
+
+                r = asprintf(&s, "%s %u 3 %.*s%.*u %s",
+                             k,
+                             dnskey_to_flags(rr),
+                             alg ? -1 : 0, alg,
+                             alg ? 0 : 1, alg ? 0u : (unsigned) rr->dnskey.algorithm,
+                             t);
+                if (r < 0)
+                        return -ENOMEM;
+                break;
+        }
 
-        case DNS_TYPE_DNAME:
-                return "DNAME";
+        case DNS_TYPE_RRSIG: {
+                const char *type, *alg;
+
+                type = dns_type_to_string(rr->rrsig.type_covered);
+                alg = dnssec_algorithm_to_string(rr->rrsig.algorithm);
+
+                t = hexmem(rr->rrsig.signature, rr->rrsig.signature_size);
+                if (!t)
+                        return -ENOMEM;
+
+                /* TYPE?? follows
+                 * http://tools.ietf.org/html/rfc3597#section-5 */
+
+                r = asprintf(&s, "%s %s%.*u %.*s%.*u %u %u %u %u %u %s %s",
+                             k,
+                             type ?: "TYPE",
+                             type ? 0 : 1, type ? 0u : (unsigned) rr->rrsig.type_covered,
+                             alg ? -1 : 0, alg,
+                             alg ? 0 : 1, alg ? 0u : (unsigned) rr->rrsig.algorithm,
+                             rr->rrsig.labels,
+                             rr->rrsig.original_ttl,
+                             rr->rrsig.expiration,
+                             rr->rrsig.inception,
+                             rr->rrsig.key_tag,
+                             rr->rrsig.signer,
+                             t);
+                if (r < 0)
+                        return -ENOMEM;
+                break;
+        }
 
-        case DNS_TYPE_ANY:
-                return "ANY";
+        default:
+                t = hexmem(rr->generic.data, rr->generic.size);
+                if (!t)
+                        return -ENOMEM;
 
-        case DNS_TYPE_OPT:
-                return "OPT";
+                s = strjoin(k, " ", t, NULL);
+                if (!s)
+                        return -ENOMEM;
+                break;
+        }
+
+        *ret = s;
+        return 0;
+}
 
-        case DNS_TYPE_TKEY:
-                return "TKEY";
+const char *dns_class_to_string(uint16_t class) {
 
-        case DNS_TYPE_TSIG:
-                return "TSIG";
+        switch (class) {
 
-        case DNS_TYPE_IXFR:
-                return "IXFR";
+        case DNS_CLASS_IN:
+                return "IN";
 
-        case DNS_TYPE_AXFR:
-                return "AXFR";
+        case DNS_CLASS_ANY:
+                return "ANY";
         }
 
         return NULL;
 }
+
+int dns_class_from_string(const char *s, uint16_t *class) {
+        assert(s);
+        assert(class);
+
+        if (strcaseeq(s, "IN"))
+                *class = DNS_CLASS_IN;
+        else if (strcaseeq(s, "ANY"))
+                *class = DNS_TYPE_ANY;
+        else
+                return -EINVAL;
+
+        return 0;
+}