resolve: add more record types and convert to gperf table

[elogind.git] / src / resolve / resolved-dns-rr.c

diff --git a/src/resolve/resolved-dns-rr.c b/src/resolve/resolved-dns-rr.c
index b6a2c04cb51d88c1e749d30859fb94b0ddb28bd1..af22a8901d6233ef69663bb57801da2ff1b8cc7e 100644 (file)
--- a/src/resolve/resolved-dns-rr.c
+++ b/src/resolve/resolved-dns-rr.c
@@ -25,6 +25,7 @@
 
 #include "resolved-dns-domain.h"
 #include "resolved-dns-rr.h"
+#include "dns-type.h"
 
 DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
         DnsResourceKey *k;
@@ -180,8 +181,7 @@ int dns_resource_key_to_string(const DnsResourceKey *key, char **ret) {
                 t = tbuf;
         }
 
-        s = strjoin(DNS_RESOURCE_KEY_NAME(key), " ", c, " ", t, NULL);
-        if (!s)
+        if (asprintf(&s, "%s %s %-5s", DNS_RESOURCE_KEY_NAME(key), c, t) < 0)
                 return -ENOMEM;
 
         *ret = s;
@@ -234,30 +234,46 @@ DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr) {
 
         if (rr->key) {
                 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);
                         break;
+
                 case DNS_TYPE_HINFO:
                         free(rr->hinfo.cpu);
                         free(rr->hinfo.os);
                         break;
-                case DNS_TYPE_SPF:
+
                 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);
                         break;
+
                 case DNS_TYPE_MX:
                         free(rr->mx.exchange);
                         break;
+
+                case DNS_TYPE_SSHFP:
+                        free(rr->sshfp.key);
+                        break;
+
                 case DNS_TYPE_LOC:
                 case DNS_TYPE_A:
                 case DNS_TYPE_AAAA:
                         break;
+
                 default:
                         free(rr->generic.data);
                 }
@@ -314,11 +330,24 @@ int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecor
         if (r <= 0)
                 return r;
 
-        switch (a->key->type) {
+        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);
 
         case DNS_TYPE_HINFO:
@@ -354,6 +383,7 @@ 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;
+
         case DNS_TYPE_MX:
                 if (a->mx.priority != b->mx.priority)
                         return 0;
@@ -370,6 +400,12 @@ int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecor
                        a->loc.longitude == b->loc.longitude &&
                        a->loc.altitude == b->loc.altitude;
 
+        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;
+
         default:
                 return a->generic.size == b->generic.size &&
                         memcmp(a->generic.data, b->generic.data, a->generic.size) == 0;
@@ -407,7 +443,6 @@ static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t alt
         return s;
 }
 
-
 int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
         _cleanup_free_ char *k = NULL;
         char *s;
@@ -421,9 +456,21 @@ int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
 
         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:
         case DNS_TYPE_NS:
         case DNS_TYPE_CNAME:
+        case DNS_TYPE_DNAME:
                 s = strjoin(k, " ", rr->ptr.name, NULL);
                 if (!s)
                         return -ENOMEM;
@@ -520,6 +567,23 @@ int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret) {
                 break;
         }
 
+        case DNS_TYPE_SSHFP: {
+                _cleanup_free_ char *x = NULL;
+
+                x = hexmem(rr->sshfp.key, rr->sshfp.key_size);
+                if (!x)
+                        return -ENOMEM;
+
+                r = asprintf(&s, "%s %u %u %s",
+                             k,
+                             rr->sshfp.algorithm,
+                             rr->sshfp.fptype,
+                             x);
+                if (r < 0)
+                        return -ENOMEM;
+                break;
+        }
+
         default: {
                 _cleanup_free_ char *x = NULL;
 
@@ -564,55 +628,3 @@ int dns_class_from_string(const char *s, uint16_t *class) {
 
         return 0;
 }
-
-static const struct {
-        uint16_t type;
-        const char *name;
-} dns_types[] = {
-        { DNS_TYPE_A,     "A"     },
-        { DNS_TYPE_NS,    "NS"    },
-        { DNS_TYPE_CNAME, "CNAME" },
-        { DNS_TYPE_SOA,   "SOA"   },
-        { DNS_TYPE_PTR,   "PTR"   },
-        { DNS_TYPE_HINFO, "HINFO" },
-        { DNS_TYPE_MX,    "MX"    },
-        { DNS_TYPE_TXT,   "TXT"   },
-        { DNS_TYPE_AAAA,  "AAAA"  },
-        { DNS_TYPE_LOC,   "LOC"   },
-        { DNS_TYPE_SRV,   "SRV"   },
-        { DNS_TYPE_SSHFP, "SSHFP" },
-        { DNS_TYPE_SPF,   "SPF"   },
-        { DNS_TYPE_DNAME, "DNAME" },
-        { DNS_TYPE_ANY,   "ANY"   },
-        { DNS_TYPE_OPT,   "OPT"   },
-        { DNS_TYPE_TKEY,  "TKEY"  },
-        { DNS_TYPE_TSIG,  "TSIG"  },
-        { DNS_TYPE_IXFR,  "IXFR"  },
-        { DNS_TYPE_AXFR,  "AXFR"  },
-};
-
-
-const char *dns_type_to_string(uint16_t type) {
-        unsigned i;
-
-        for (i = 0; i < ELEMENTSOF(dns_types); i++)
-                if (dns_types[i].type == type)
-                        return dns_types[i].name;
-
-        return NULL;
-}
-
-int dns_type_from_string(const char *s, uint16_t *type) {
-        unsigned i;
-
-        assert(s);
-        assert(type);
-
-        for (i = 0; i < ELEMENTSOF(dns_types); i++)
-                if (strcaseeq(dns_types[i].name, s)) {
-                        *type = dns_types[i].type;
-                        return 0;
-                }
-
-        return -EINVAL;
-}