From 3b37fa735224e58fcc23c737b764d13e22c2885b Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Sun, 29 Nov 2015 14:12:05 +0100
Subject: dns-domain: be more strict when encoding/decoding labels

Labels of zero length are not OK, refuse them early on. The concept of a
"zero-length label" doesn't exist, a zero-length full domain name
however does (representing the root domain). See RFC 2181, Section 11.
---
 src/shared/dns-domain.c | 139 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 94 insertions(+), 45 deletions(-)

(limited to 'src/shared/dns-domain.c')

diff --git a/src/shared/dns-domain.c b/src/shared/dns-domain.c
index 09ec6e70a0..7a4093cc47 100644
--- a/src/shared/dns-domain.c
+++ b/src/shared/dns-domain.c
@@ -185,7 +185,11 @@ int dns_label_unescape_suffix(const char *name, const char **label_terminal, cha
 int dns_label_escape(const char *p, size_t l, char *dest, size_t sz) {
         char *q;
 
-        if (l > DNS_LABEL_MAX)
+        /* DNS labels must be between 1 and 63 characters long. A
+         * zero-length label does not exist. See RFC 2182, Section
+         * 11. */
+
+        if (l <= 0 || l > DNS_LABEL_MAX)
                 return -EINVAL;
         if (sz < 1)
                 return -ENOSPC;
@@ -198,10 +202,11 @@ int dns_label_escape(const char *p, size_t l, char *dest, size_t sz) {
 
                 if (*p == '.' || *p == '\\') {
 
+                        /* Dot or backslash */
+
                         if (sz < 3)
                                 return -ENOSPC;
 
-                        /* Dot or backslash */
                         *(q++) = '\\';
                         *(q++) = *p;
 
@@ -253,7 +258,7 @@ int dns_label_escape_new(const char *p, size_t l, char **ret) {
         assert(p);
         assert(ret);
 
-        if (l > DNS_LABEL_MAX)
+        if (l <= 0 || l > DNS_LABEL_MAX)
                 return -EINVAL;
 
         s = new(char, DNS_LABEL_ESCAPED_MAX);
@@ -273,32 +278,52 @@ int dns_label_escape_new(const char *p, size_t l, char **ret) {
 int dns_label_apply_idna(const char *encoded, size_t encoded_size, char *decoded, size_t decoded_max) {
 #ifdef HAVE_LIBIDN
         _cleanup_free_ uint32_t *input = NULL;
-        size_t input_size;
+        size_t input_size, l;
         const char *p;
         bool contains_8bit = false;
+        char buffer[DNS_LABEL_MAX+1];
 
         assert(encoded);
         assert(decoded);
-        assert(decoded_max >= DNS_LABEL_MAX);
+
+        /* Converts an U-label into an A-label */
 
         if (encoded_size <= 0)
-                return 0;
+                return -EINVAL;
 
         for (p = encoded; p < encoded + encoded_size; p++)
                 if ((uint8_t) *p > 127)
                         contains_8bit = true;
 
-        if (!contains_8bit)
+        if (!contains_8bit) {
+                if (encoded_size > DNS_LABEL_MAX)
+                        return -EINVAL;
+
                 return 0;
+        }
 
         input = stringprep_utf8_to_ucs4(encoded, encoded_size, &input_size);
         if (!input)
                 return -ENOMEM;
 
-        if (idna_to_ascii_4i(input, input_size, decoded, 0) != 0)
+        if (idna_to_ascii_4i(input, input_size, buffer, 0) != 0)
+                return -EINVAL;
+
+        l = strlen(buffer);
+
+        /* Verify that the the result is not longer than one DNS label. */
+        if (l <= 0 || l > DNS_LABEL_MAX)
                 return -EINVAL;
+        if (l > decoded_max)
+                return -ENOSPC;
+
+        memcpy(decoded, buffer, l);
 
-        return strlen(decoded);
+        /* If there's room, append a trailing NUL byte, but only then */
+        if (decoded_max > l)
+                decoded[l] = 0;
+
+        return (int) l;
 #else
         return 0;
 #endif
@@ -312,11 +337,14 @@ int dns_label_undo_idna(const char *encoded, size_t encoded_size, char *decoded,
         uint32_t *output = NULL;
         size_t w;
 
-        /* To be invoked after unescaping */
+        /* To be invoked after unescaping. Converts an A-label into an U-label. */
 
         assert(encoded);
         assert(decoded);
 
+        if (encoded_size <= 0 || encoded_size > DNS_LABEL_MAX)
+                return -EINVAL;
+
         if (encoded_size < sizeof(IDNA_ACE_PREFIX)-1)
                 return 0;
 
@@ -336,11 +364,16 @@ int dns_label_undo_idna(const char *encoded, size_t encoded_size, char *decoded,
         if (!result)
                 return -ENOMEM;
         if (w <= 0)
-                return 0;
-        if (w+1 > decoded_max)
                 return -EINVAL;
+        if (w > decoded_max)
+                return -ENOSPC;
+
+        memcpy(decoded, result, w);
+
+        /* Append trailing NUL byte if there's space, but only then. */
+        if (decoded_max > w)
+                decoded[w] = 0;
 
-        memcpy(decoded, result, w+1);
         return w;
 #else
         return 0;
@@ -511,24 +544,32 @@ int dns_name_equal(const char *x, const char *y) {
                 r = dns_label_unescape(&x, la, sizeof(la));
                 if (r < 0)
                         return r;
-
-                k = dns_label_undo_idna(la, r, la, sizeof(la));
-                if (k < 0)
-                        return k;
-                if (k > 0)
-                        r = k;
+                if (r > 0) {
+                        k = dns_label_undo_idna(la, r, la, sizeof(la));
+                        if (k < 0)
+                                return k;
+                        if (k > 0)
+                                r = k;
+                }
 
                 q = dns_label_unescape(&y, lb, sizeof(lb));
                 if (q < 0)
                         return q;
-                w = dns_label_undo_idna(lb, q, lb, sizeof(lb));
-                if (w < 0)
-                        return w;
-                if (w > 0)
-                        q = w;
+                if (q > 0) {
+                        w = dns_label_undo_idna(lb, q, lb, sizeof(lb));
+                        if (w < 0)
+                                return w;
+                        if (w > 0)
+                                q = w;
+                }
+
+                /* If one name had fewer labels than the other, this
+                 * will show up as empty label here, which the
+                 * strcasecmp() below will properly consider different
+                 * from a non-empty label. */
 
                 la[r] = lb[q] = 0;
-                if (strcasecmp(la, lb))
+                if (strcasecmp(la, lb) != 0)
                         return false;
         }
 }
@@ -549,11 +590,13 @@ int dns_name_endswith(const char *name, const char *suffix) {
                 r = dns_label_unescape(&n, ln, sizeof(ln));
                 if (r < 0)
                         return r;
-                k = dns_label_undo_idna(ln, r, ln, sizeof(ln));
-                if (k < 0)
-                        return k;
-                if (k > 0)
-                        r = k;
+                if (r > 0) {
+                        k = dns_label_undo_idna(ln, r, ln, sizeof(ln));
+                        if (k < 0)
+                                return k;
+                        if (k > 0)
+                                r = k;
+                }
 
                 if (!saved_n)
                         saved_n = n;
@@ -561,11 +604,13 @@ int dns_name_endswith(const char *name, const char *suffix) {
                 q = dns_label_unescape(&s, ls, sizeof(ls));
                 if (q < 0)
                         return q;
-                w = dns_label_undo_idna(ls, q, ls, sizeof(ls));
-                if (w < 0)
-                        return w;
-                if (w > 0)
-                        q = w;
+                if (q > 0) {
+                        w = dns_label_undo_idna(ls, q, ls, sizeof(ls));
+                        if (w < 0)
+                                return w;
+                        if (w > 0)
+                                q = w;
+                }
 
                 if (r == 0 && q == 0)
                         return true;
@@ -605,11 +650,13 @@ int dns_name_change_suffix(const char *name, const char *old_suffix, const char
                 r = dns_label_unescape(&n, ln, sizeof(ln));
                 if (r < 0)
                         return r;
-                k = dns_label_undo_idna(ln, r, ln, sizeof(ln));
-                if (k < 0)
-                        return k;
-                if (k > 0)
-                        r = k;
+                if (r > 0) {
+                        k = dns_label_undo_idna(ln, r, ln, sizeof(ln));
+                        if (k < 0)
+                                return k;
+                        if (k > 0)
+                                r = k;
+                }
 
                 if (!saved_after)
                         saved_after = n;
@@ -617,11 +664,13 @@ int dns_name_change_suffix(const char *name, const char *old_suffix, const char
                 q = dns_label_unescape(&s, ls, sizeof(ls));
                 if (q < 0)
                         return q;
-                w = dns_label_undo_idna(ls, q, ls, sizeof(ls));
-                if (w < 0)
-                        return w;
-                if (w > 0)
-                        q = w;
+                if (q > 0) {
+                        w = dns_label_undo_idna(ls, q, ls, sizeof(ls));
+                        if (w < 0)
+                                return w;
+                        if (w > 0)
+                                q = w;
+                }
 
                 if (r == 0 && q == 0)
                         break;
-- 
cgit v1.2.3-54-g00ecf


From 1dfbf0007af3023c2e3ae8282a0d0f229f3a89e3 Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Sun, 29 Nov 2015 14:27:28 +0100
Subject: dns-domain: don't accept overly long hostnames

Make sure dns_name_normalize(), dns_name_concat(), dns_name_is_valid()
do not accept/generate invalidly long hostnames, i.e. longer than 253
characters.
---
 src/shared/dns-domain.c    |  3 +++
 src/shared/dns-domain.h    |  3 +++
 src/test/test-dns-domain.c | 18 ++++++++++++++++++
 3 files changed, 24 insertions(+)

(limited to 'src/shared/dns-domain.c')

diff --git a/src/shared/dns-domain.c b/src/shared/dns-domain.c
index 7a4093cc47..ab61eb3b6e 100644
--- a/src/shared/dns-domain.c
+++ b/src/shared/dns-domain.c
@@ -442,6 +442,9 @@ int dns_name_concat(const char *a, const char *b, char **_ret) {
                 n += r;
         }
 
+        if (n > DNS_HOSTNAME_MAX)
+                return -EINVAL;
+
         if (_ret) {
                 if (!GREEDY_REALLOC(ret, allocated, n + 1))
                         return -ENOMEM;
diff --git a/src/shared/dns-domain.h b/src/shared/dns-domain.h
index c68f1945e1..44a9975541 100644
--- a/src/shared/dns-domain.h
+++ b/src/shared/dns-domain.h
@@ -31,6 +31,9 @@
 /* Worst case length of a single label, with all escaping applied and room for a trailing NUL byte. */
 #define DNS_LABEL_ESCAPED_MAX (DNS_LABEL_MAX*4+1)
 
+/* Maximum length of a full hostname, consisting of a series of unescaped labels, and no trailing dot or NUL byte */
+#define DNS_HOSTNAME_MAX 253
+
 int dns_label_unescape(const char **name, char *dest, size_t sz);
 int dns_label_unescape_suffix(const char *name, const char **label_end, char *dest, size_t sz);
 int dns_label_escape(const char *p, size_t l, char *dest, size_t sz);
diff --git a/src/test/test-dns-domain.c b/src/test/test-dns-domain.c
index 7ad59d378a..3e470c0ef2 100644
--- a/src/test/test-dns-domain.c
+++ b/src/test/test-dns-domain.c
@@ -314,6 +314,24 @@ static void test_dns_name_is_valid(void) {
         test_dns_name_is_valid_one("\\zbar", 0);
         test_dns_name_is_valid_one("ä", 1);
         test_dns_name_is_valid_one("\n", 0);
+
+        /* 256 characters*/
+        test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345", 0);
+
+        /* 255 characters*/
+        test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a1234", 0);
+
+        /* 254 characters*/
+        test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a123", 0);
+
+        /* 253 characters*/
+        test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12", 1);
+
+        /* label of 64 chars length */
+        test_dns_name_is_valid_one("a123456789a123456789a123456789a123456789a123456789a123456789a123", 0);
+
+        /* label of 63 chars length */
+        test_dns_name_is_valid_one("a123456789a123456789a123456789a123456789a123456789a123456789a12", 1);
 }
 
 static void test_dns_service_name_is_valid(void) {
-- 
cgit v1.2.3-54-g00ecf


From c6cefd13eb55c8124a01e90021282f8610a05012 Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Sun, 29 Nov 2015 14:29:31 +0100
Subject: dns-domain: make sure dns_name_to_wire_format() may properly encode
 the root domain

The root domain consists of zero labels, and we should be able to encode
that.
---
 src/shared/dns-domain.c    | 10 ++++------
 src/test/test-dns-domain.c |  3 ++-
 2 files changed, 6 insertions(+), 7 deletions(-)

(limited to 'src/shared/dns-domain.c')

diff --git a/src/shared/dns-domain.c b/src/shared/dns-domain.c
index ab61eb3b6e..ba6eff8f60 100644
--- a/src/shared/dns-domain.c
+++ b/src/shared/dns-domain.c
@@ -866,19 +866,17 @@ bool dns_name_is_single_label(const char *name) {
 
 /* Encode a domain name according to RFC 1035 Section 3.1 */
 int dns_name_to_wire_format(const char *domain, uint8_t *buffer, size_t len) {
-        uint8_t *label_length;
-        uint8_t *out;
+        uint8_t *label_length, *out;
         int r;
 
-        assert_return(buffer, -EINVAL);
-        assert_return(domain, -EINVAL);
-        assert_return(domain[0], -EINVAL);
+        assert(domain);
+        assert(buffer);
 
         out = buffer;
 
         do {
                 /* reserve a byte for label length */
-                if (len == 0)
+                if (len <= 0)
                         return -ENOBUFS;
                 len--;
                 label_length = out;
diff --git a/src/test/test-dns-domain.c b/src/test/test-dns-domain.c
index 3e470c0ef2..0762faa9a7 100644
--- a/src/test/test-dns-domain.c
+++ b/src/test/test-dns-domain.c
@@ -66,11 +66,12 @@ static void test_dns_name_to_wire_format_one(const char *what, const char *expec
 }
 
 static void test_dns_name_to_wire_format(void) {
+        const char out0[] = { 0 };
         const char out1[] = { 3, 'f', 'o', 'o', 0 };
         const char out2[] = { 5, 'h', 'a', 'l', 'l', 'o', 3, 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
         const char out3[] = { 4, ' ', 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
 
-        test_dns_name_to_wire_format_one("", NULL, 0, -EINVAL);
+        test_dns_name_to_wire_format_one("", out0, sizeof(out0), sizeof(out0));
 
         test_dns_name_to_wire_format_one("foo", out1, sizeof(out1), sizeof(out1));
         test_dns_name_to_wire_format_one("foo", out1, sizeof(out1) + 1, sizeof(out1));
-- 
cgit v1.2.3-54-g00ecf


From 50dee79bfbe0782a342ef864b28d7d6613c0b1fb Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Mon, 30 Nov 2015 19:39:19 +0100
Subject: dns-domain: check resulting domain name length in
 dns_name_to_wire_format()

Let's better be safe than sorry.
---
 src/shared/dns-domain.c    | 19 +++++++++++++++----
 src/test/test-dns-domain.c | 37 +++++++++++++++++++++++++++++++++----
 2 files changed, 48 insertions(+), 8 deletions(-)

(limited to 'src/shared/dns-domain.c')

diff --git a/src/shared/dns-domain.c b/src/shared/dns-domain.c
index ba6eff8f60..03c0107308 100644
--- a/src/shared/dns-domain.c
+++ b/src/shared/dns-domain.c
@@ -864,7 +864,7 @@ bool dns_name_is_single_label(const char *name) {
         return dns_name_is_root(name);
 }
 
-/* Encode a domain name according to RFC 1035 Section 3.1 */
+/* Encode a domain name according to RFC 1035 Section 3.1, without compression */
 int dns_name_to_wire_format(const char *domain, uint8_t *buffer, size_t len) {
         uint8_t *label_length, *out;
         int r;
@@ -875,24 +875,35 @@ int dns_name_to_wire_format(const char *domain, uint8_t *buffer, size_t len) {
         out = buffer;
 
         do {
-                /* reserve a byte for label length */
+                /* Reserve a byte for label length */
                 if (len <= 0)
                         return -ENOBUFS;
                 len--;
                 label_length = out;
                 out++;
 
-                /* convert and copy a single label */
+                /* Convert and copy a single label. Note that
+                 * dns_label_unescape() returns 0 when it hits the end
+                 * of the domain name, which we rely on here to encode
+                 * the trailing NUL byte. */
                 r = dns_label_unescape(&domain, (char *) out, len);
                 if (r < 0)
                         return r;
 
-                /* fill label length, move forward */
+                /* Fill label length, move forward */
                 *label_length = r;
                 out += r;
                 len -= r;
+
         } while (r != 0);
 
+        /* Verify the maximum size of the encoded name. The trailing
+         * dot + NUL byte account are included this time, hence
+         * compare against DNS_HOSTNAME_MAX + 2 (which is 255) this
+         * time. */
+        if (out - buffer > DNS_HOSTNAME_MAX + 2)
+                return -EINVAL;
+
         return out - buffer;
 }
 
diff --git a/src/test/test-dns-domain.c b/src/test/test-dns-domain.c
index 0762faa9a7..a1795b3be2 100644
--- a/src/test/test-dns-domain.c
+++ b/src/test/test-dns-domain.c
@@ -66,10 +66,36 @@ static void test_dns_name_to_wire_format_one(const char *what, const char *expec
 }
 
 static void test_dns_name_to_wire_format(void) {
-        const char out0[] = { 0 };
-        const char out1[] = { 3, 'f', 'o', 'o', 0 };
-        const char out2[] = { 5, 'h', 'a', 'l', 'l', 'o', 3, 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
-        const char out3[] = { 4, ' ', 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
+        static const char out0[] = { 0 };
+        static const char out1[] = { 3, 'f', 'o', 'o', 0 };
+        static const char out2[] = { 5, 'h', 'a', 'l', 'l', 'o', 3, 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
+        static const char out3[] = { 4, ' ', 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
+        static const char out4[] = { 9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
+                                     3, 'a', '1', '2', 0 };
 
         test_dns_name_to_wire_format_one("", out0, sizeof(out0), sizeof(out0));
 
@@ -81,6 +107,9 @@ static void test_dns_name_to_wire_format(void) {
         test_dns_name_to_wire_format_one("hallo.foo..bar", NULL, 32, -EINVAL);
 
         test_dns_name_to_wire_format_one("\\032foo.bar", out3, sizeof(out3), sizeof(out3));
+
+        test_dns_name_to_wire_format_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a123", NULL, 500, -EINVAL);
+        test_dns_name_to_wire_format_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12", out4, sizeof(out4), sizeof(out4));
 }
 
 static void test_dns_label_unescape_suffix_one(const char *what, const char *expect1, const char *expect2, size_t buffer_sz, int ret1, int ret2) {
-- 
cgit v1.2.3-54-g00ecf


From 37ade1283745f39e3fa37aa2603809fb2daf067c Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Mon, 30 Nov 2015 19:40:20 +0100
Subject: dns-domain: change error codes when dealing with too short buffers to
 ENOBUFS

Some calls used ENOBUFS to indicate too-short result buffers, others
used ENOSPC. Let's unify this on ENOBUFS.
---
 src/shared/dns-domain.c    | 18 +++++++++---------
 src/test/test-dns-domain.c |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'src/shared/dns-domain.c')

diff --git a/src/shared/dns-domain.c b/src/shared/dns-domain.c
index 03c0107308..5ac8ad5b7a 100644
--- a/src/shared/dns-domain.c
+++ b/src/shared/dns-domain.c
@@ -53,12 +53,12 @@ int dns_label_unescape(const char **name, char *dest, size_t sz) {
                 if (*n == 0)
                         break;
 
-                if (sz <= 0)
-                        return -ENOSPC;
-
                 if (r >= DNS_LABEL_MAX)
                         return -EINVAL;
 
+                if (sz <= 0)
+                        return -ENOBUFS;
+
                 if (*n == '\\') {
                         /* Escaped character */
 
@@ -192,7 +192,7 @@ int dns_label_escape(const char *p, size_t l, char *dest, size_t sz) {
         if (l <= 0 || l > DNS_LABEL_MAX)
                 return -EINVAL;
         if (sz < 1)
-                return -ENOSPC;
+                return -ENOBUFS;
 
         assert(p);
         assert(dest);
@@ -205,7 +205,7 @@ int dns_label_escape(const char *p, size_t l, char *dest, size_t sz) {
                         /* Dot or backslash */
 
                         if (sz < 3)
-                                return -ENOSPC;
+                                return -ENOBUFS;
 
                         *(q++) = '\\';
                         *(q++) = *p;
@@ -221,7 +221,7 @@ int dns_label_escape(const char *p, size_t l, char *dest, size_t sz) {
                         /* Proper character */
 
                         if (sz < 2)
-                                return -ENOSPC;
+                                return -ENOBUFS;
 
                         *(q++) = *p;
                         sz -= 1;
@@ -231,7 +231,7 @@ int dns_label_escape(const char *p, size_t l, char *dest, size_t sz) {
                         /* Everything else */
 
                         if (sz < 5)
-                                return -ENOSPC;
+                                return -ENOBUFS;
 
                         *(q++) = '\\';
                         *(q++) = '0' + (char) ((uint8_t) *p / 100);
@@ -315,7 +315,7 @@ int dns_label_apply_idna(const char *encoded, size_t encoded_size, char *decoded
         if (l <= 0 || l > DNS_LABEL_MAX)
                 return -EINVAL;
         if (l > decoded_max)
-                return -ENOSPC;
+                return -ENOBUFS;
 
         memcpy(decoded, buffer, l);
 
@@ -366,7 +366,7 @@ int dns_label_undo_idna(const char *encoded, size_t encoded_size, char *decoded,
         if (w <= 0)
                 return -EINVAL;
         if (w > decoded_max)
-                return -ENOSPC;
+                return -ENOBUFS;
 
         memcpy(decoded, result, w);
 
diff --git a/src/test/test-dns-domain.c b/src/test/test-dns-domain.c
index a1795b3be2..7f53a8cc56 100644
--- a/src/test/test-dns-domain.c
+++ b/src/test/test-dns-domain.c
@@ -39,7 +39,7 @@ static void test_dns_label_unescape_one(const char *what, const char *expect, si
 
 static void test_dns_label_unescape(void) {
         test_dns_label_unescape_one("hallo", "hallo", 6, 5);
-        test_dns_label_unescape_one("hallo", "hallo", 4, -ENOSPC);
+        test_dns_label_unescape_one("hallo", "hallo", 4, -ENOBUFS);
         test_dns_label_unescape_one("", "", 10, 0);
         test_dns_label_unescape_one("hallo\\.foobar", "hallo.foobar", 20, 12);
         test_dns_label_unescape_one("hallo.foobar", "hallo", 10, 5);
@@ -132,7 +132,7 @@ static void test_dns_label_unescape_suffix_one(const char *what, const char *exp
 
 static void test_dns_label_unescape_suffix(void) {
         test_dns_label_unescape_suffix_one("hallo", "hallo", "", 6, 5, 0);
-        test_dns_label_unescape_suffix_one("hallo", "hallo", "", 4, -ENOSPC, -ENOSPC);
+        test_dns_label_unescape_suffix_one("hallo", "hallo", "", 4, -ENOBUFS, -ENOBUFS);
         test_dns_label_unescape_suffix_one("", "", "", 10, 0, 0);
         test_dns_label_unescape_suffix_one("hallo\\.foobar", "hallo.foobar", "", 20, 12, 0);
         test_dns_label_unescape_suffix_one("hallo.foobar", "foobar", "hallo", 10, 6, 5);
-- 
cgit v1.2.3-54-g00ecf