[systemd.git] / src / shared / dns-domain.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2014 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/

#ifdef HAVE_LIBIDN
#include <idna.h>
#include <stringprep.h>
#endif

#include "dns-domain.h"

int dns_label_unescape(const char **name, char *dest, size_t sz) {
        const char *n;
        char *d;
        int r = 0;

        assert(name);
        assert(*name);
        assert(dest);

        n = *name;
        d = dest;

        for (;;) {
                if (*n == '.') {
                        n++;
                        break;
                }

                if (*n == 0)
                        break;

                if (sz <= 0)
                        return -ENOSPC;

                if (r >= DNS_LABEL_MAX)
                        return -EINVAL;

                if (*n == '\\') {
                        /* Escaped character */

                        n++;

                        if (*n == 0)
                                /* Ending NUL */
                                return -EINVAL;

                        else if (*n == '\\' || *n == '.') {
                                /* Escaped backslash or dot */
                                *(d++) = *(n++);
                                sz--;
                                r++;

                        } else if (n[0] >= '0' && n[0] <= '9') {
                                unsigned k;

                                /* Escaped literal ASCII character */

                                if (!(n[1] >= '0' && n[1] <= '9') ||
                                    !(n[2] >= '0' && n[2] <= '9'))
                                        return -EINVAL;

                                k = ((unsigned) (n[0] - '0') * 100) +
                                        ((unsigned) (n[1] - '0') * 10) +
                                        ((unsigned) (n[2] - '0'));

                                /* Don't allow CC characters or anything that doesn't fit in 8bit */
                                if (k < ' ' || k > 255 || k == 127)
                                        return -EINVAL;

                                *(d++) = (char) k;
                                sz--;
                                r++;

                                n += 3;
                        } else
                                return -EINVAL;

                } else if ((uint8_t) *n >= (uint8_t) ' ' && *n != 127) {

                        /* Normal character */
                        *(d++) = *(n++);
                        sz--;
                        r++;
                } else
                        return -EINVAL;
        }

        /* Empty label that is not at the end? */
        if (r == 0 && *n)
                return -EINVAL;

        if (sz >= 1)
                *d = 0;

        *name = n;
        return r;
}

/* @label_terminal: terminal character of a label, updated to point to the terminal character of
 *                  the previous label (always skipping one dot) or to NULL if there are no more
 *                  labels. */
int dns_label_unescape_suffix(const char *name, const char **label_terminal, char *dest, size_t sz) {
        const char *terminal;
        int r;

        assert(name);
        assert(label_terminal);
        assert(dest);

        /* no more labels */
        if (!*label_terminal) {
                if (sz >= 1)
                        *dest = 0;

                return 0;
        }

        assert(**label_terminal == '.' || **label_terminal == 0);

        /* skip current terminal character */
        terminal = *label_terminal - 1;

        /* point name to the last label, and terminal to the preceding terminal symbol (or make it a NULL pointer) */
        for (;;) {
                if (terminal < name) {
                        /* reached the first label, so indicate that there are no more */
                        terminal = NULL;
                        break;
                }

                /* find the start of the last label */
                if (*terminal == '.') {
                        const char *y;
                        unsigned slashes = 0;

                        for (y = terminal - 1; y >= name && *y == '\\'; y--)
                                slashes ++;

                        if (slashes % 2 == 0) {
                                /* the '.' was not escaped */
                                name = terminal + 1;
                                break;
                        } else {
                                terminal = y;
                                continue;
                        }
                }

                terminal --;
        }

        r = dns_label_unescape(&name, dest, sz);
        if (r < 0)
                return r;

        *label_terminal = terminal;

        return r;
}

int dns_label_escape(const char *p, size_t l, char **ret) {
        _cleanup_free_ char *s = NULL;
        char *q;
        int r;

        assert(p);
        assert(ret);

        if (l > DNS_LABEL_MAX)
                return -EINVAL;

        s = malloc(l * 4 + 1);
        if (!s)
                return -ENOMEM;

        q = s;
        while (l > 0) {

                if (*p == '.' || *p == '\\') {

                        /* Dot or backslash */
                        *(q++) = '\\';
                        *(q++) = *p;

                } else if (*p == '_' ||
                           *p == '-' ||
                           (*p >= '0' && *p <= '9') ||
                           (*p >= 'a' && *p <= 'z') ||
                           (*p >= 'A' && *p <= 'Z')) {

                        /* Proper character */
                        *(q++) = *p;
                } else if ((uint8_t) *p >= (uint8_t) ' ' && *p != 127) {

                        /* Everything else */
                        *(q++) = '\\';
                        *(q++) = '0' + (char) ((uint8_t) *p / 100);
                        *(q++) = '0' + (char) (((uint8_t) *p / 10) % 10);
                        *(q++) = '0' + (char) ((uint8_t) *p % 10);

                } else
                        return -EINVAL;

                p++;
                l--;
        }

        *q = 0;
        *ret = s;
        r = q - s;
        s = NULL;

        return r;
}

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;
        const char *p;
        bool contains_8bit = false;

        assert(encoded);
        assert(decoded);
        assert(decoded_max >= DNS_LABEL_MAX);

        if (encoded_size <= 0)
                return 0;

        for (p = encoded; p < encoded + encoded_size; p++)
                if ((uint8_t) *p > 127)
                        contains_8bit = true;

        if (!contains_8bit)
                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)
                return -EINVAL;

        return strlen(decoded);
#else
        return 0;
#endif
}

int dns_label_undo_idna(const char *encoded, size_t encoded_size, char *decoded, size_t decoded_max) {
#ifdef HAVE_LIBIDN
        size_t input_size, output_size;
        _cleanup_free_ uint32_t *input = NULL;
        _cleanup_free_ char *result = NULL;
        uint32_t *output = NULL;
        size_t w;

        /* To be invoked after unescaping */

        assert(encoded);
        assert(decoded);

        if (encoded_size < sizeof(IDNA_ACE_PREFIX)-1)
                return 0;

        if (memcmp(encoded, IDNA_ACE_PREFIX, sizeof(IDNA_ACE_PREFIX) -1) != 0)
                return 0;

        input = stringprep_utf8_to_ucs4(encoded, encoded_size, &input_size);
        if (!input)
                return -ENOMEM;

        output_size = input_size;
        output = newa(uint32_t, output_size);

        idna_to_unicode_44i(input, input_size, output, &output_size, 0);

        result = stringprep_ucs4_to_utf8(output, output_size, NULL, &w);
        if (!result)
                return -ENOMEM;
        if (w <= 0)
                return 0;
        if (w+1 > decoded_max)
                return -EINVAL;

        memcpy(decoded, result, w+1);
        return w;
#else
        return 0;
#endif
}

int dns_name_normalize(const char *s, char **_ret) {
        _cleanup_free_ char *ret = NULL;
        size_t n = 0, allocated = 0;
        const char *p = s;
        bool first = true;
        int r;

        assert(s);

        for (;;) {
                _cleanup_free_ char *t = NULL;
                char label[DNS_LABEL_MAX];
                int k;

                r = dns_label_unescape(&p, label, sizeof(label));
                if (r < 0)
                        return r;
                if (r == 0) {
                        if (*p != 0)
                                return -EINVAL;
                        break;
                }

                k = dns_label_undo_idna(label, r, label, sizeof(label));
                if (k < 0)
                        return k;
                if (k > 0)
                        r = k;

                r = dns_label_escape(label, r, &t);
                if (r < 0)
                        return r;

                if (!GREEDY_REALLOC(ret, allocated, n + !first + strlen(t) + 1))
                        return -ENOMEM;

                if (!first)
                        ret[n++] = '.';
                else
                        first = false;

                memcpy(ret + n, t, r);
                n += r;
        }

        if (n > DNS_NAME_MAX)
                return -EINVAL;

        if (!GREEDY_REALLOC(ret, allocated, n + 1))
                return -ENOMEM;

        ret[n] = 0;

        if (_ret) {
                *_ret = ret;
                ret = NULL;
        }

        return 0;
}

unsigned long dns_name_hash_func(const void *s, const uint8_t hash_key[HASH_KEY_SIZE]) {
        const char *p = s;
        unsigned long ul = hash_key[0];
        int r;

        assert(p);

        while (*p) {
                char label[DNS_LABEL_MAX+1];
                int k;

                r = dns_label_unescape(&p, label, sizeof(label));
                if (r < 0)
                        break;

                k = dns_label_undo_idna(label, r, label, sizeof(label));
                if (k < 0)
                        break;
                if (k > 0)
                        r = k;

                label[r] = 0;
                ascii_strlower(label);

                ul = ul * hash_key[1] + ul + string_hash_func(label, hash_key);
        }

        return ul;
}

int dns_name_compare_func(const void *a, const void *b) {
        const char *x, *y;
        int r, q, k, w;

        assert(a);
        assert(b);

        x = (const char *) a + strlen(a);
        y = (const char *) b + strlen(b);

        for (;;) {
                char la[DNS_LABEL_MAX+1], lb[DNS_LABEL_MAX+1];

                if (x == NULL && y == NULL)
                        return 0;

                r = dns_label_unescape_suffix(a, &x, la, sizeof(la));
                q = dns_label_unescape_suffix(b, &y, lb, sizeof(lb));
                if (r < 0 || q < 0)
                        return r - q;

                k = dns_label_undo_idna(la, r, la, sizeof(la));
                w = dns_label_undo_idna(lb, q, lb, sizeof(lb));
                if (k < 0 || w < 0)
                        return k - w;
                if (k > 0)
                        r = k;
                if (w > 0)
                        r = w;

                la[r] = lb[q] = 0;
                r = strcasecmp(la, lb);
                if (r != 0)
                        return r;
        }
}

const struct hash_ops dns_name_hash_ops = {
        .hash = dns_name_hash_func,
        .compare = dns_name_compare_func
};

int dns_name_equal(const char *x, const char *y) {
        int r, q, k, w;

        assert(x);
        assert(y);

        for (;;) {
                char la[DNS_LABEL_MAX+1], lb[DNS_LABEL_MAX+1];

                if (*x == 0 && *y == 0)
                        return true;

                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;

                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;

                la[r] = lb[q] = 0;
                if (strcasecmp(la, lb))
                        return false;
        }
}

int dns_name_endswith(const char *name, const char *suffix) {
        const char *n, *s, *saved_n = NULL;
        int r, q, k, w;

        assert(name);
        assert(suffix);

        n = name;
        s = suffix;

        for (;;) {
                char ln[DNS_LABEL_MAX+1], ls[DNS_LABEL_MAX+1];

                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 (!saved_n)
                        saved_n = n;

                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 (r == 0 && q == 0)
                        return true;
                if (r == 0 && saved_n == n)
                        return false;

                ln[r] = ls[q] = 0;

                if (r != q || strcasecmp(ln, ls)) {

                        /* Not the same, let's jump back, and try with the next label again */
                        s = suffix;
                        n = saved_n;
                        saved_n = NULL;
                }
        }
}

int dns_name_between(const char *a, const char *b, const char *c) {
        int n;

        /* Determine if b is strictly greater than a and strictly smaller than c.
           We consider the order of names to be circular, so that if a is
           strictly greater than c, we consider b to be between them if it is
           either greater than a or smaller than c. This is how the canonical
           DNS name order used in NSEC records work. */

        n = dns_name_compare_func(a, c);
        if (n == 0)
                return -EINVAL;
        else if (n < 0)
                /*       a<---b--->c       */
                return dns_name_compare_func(a, b) < 0 &&
                       dns_name_compare_func(b, c) < 0;
        else
                /* <--b--c         a--b--> */
                return dns_name_compare_func(b, c) < 0 ||
                       dns_name_compare_func(a, b) < 0;
}

int dns_name_reverse(int family, const union in_addr_union *a, char **ret) {
        const uint8_t *p;
        int r;

        assert(a);
        assert(ret);

        p = (const uint8_t*) a;

        if (family == AF_INET)
                r = asprintf(ret, "%u.%u.%u.%u.in-addr.arpa", p[3], p[2], p[1], p[0]);
        else if (family == AF_INET6)
                r = asprintf(ret, "%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.ip6.arpa",
                             hexchar(p[15] & 0xF), hexchar(p[15] >> 4), hexchar(p[14] & 0xF), hexchar(p[14] >> 4),
                             hexchar(p[13] & 0xF), hexchar(p[13] >> 4), hexchar(p[12] & 0xF), hexchar(p[12] >> 4),
                             hexchar(p[11] & 0xF), hexchar(p[11] >> 4), hexchar(p[10] & 0xF), hexchar(p[10] >> 4),
                             hexchar(p[ 9] & 0xF), hexchar(p[ 9] >> 4), hexchar(p[ 8] & 0xF), hexchar(p[ 8] >> 4),
                             hexchar(p[ 7] & 0xF), hexchar(p[ 7] >> 4), hexchar(p[ 6] & 0xF), hexchar(p[ 6] >> 4),
                             hexchar(p[ 5] & 0xF), hexchar(p[ 5] >> 4), hexchar(p[ 4] & 0xF), hexchar(p[ 4] >> 4),
                             hexchar(p[ 3] & 0xF), hexchar(p[ 3] >> 4), hexchar(p[ 2] & 0xF), hexchar(p[ 2] >> 4),
                             hexchar(p[ 1] & 0xF), hexchar(p[ 1] >> 4), hexchar(p[ 0] & 0xF), hexchar(p[ 0] >> 4));
        else
                return -EAFNOSUPPORT;
        if (r < 0)
                return -ENOMEM;

        return 0;
}

int dns_name_address(const char *p, int *family, union in_addr_union *address) {
        int r;

        assert(p);
        assert(family);
        assert(address);

        r = dns_name_endswith(p, "in-addr.arpa");
        if (r < 0)
                return r;
        if (r > 0) {
                uint8_t a[4];
                unsigned i;

                for (i = 0; i < ELEMENTSOF(a); i++) {
                        char label[DNS_LABEL_MAX+1];

                        r = dns_label_unescape(&p, label, sizeof(label));
                        if (r < 0)
                                return r;
                        if (r == 0)
                                return -EINVAL;
                        if (r > 3)
                                return -EINVAL;

                        r = safe_atou8(label, &a[i]);
                        if (r < 0)
                                return r;
                }

                r = dns_name_equal(p, "in-addr.arpa");
                if (r <= 0)
                        return r;

                *family = AF_INET;
                address->in.s_addr = htobe32(((uint32_t) a[3] << 24) |
                                             ((uint32_t) a[2] << 16) |
                                             ((uint32_t) a[1] << 8) |
                                              (uint32_t) a[0]);

                return 1;
        }

        r = dns_name_endswith(p, "ip6.arpa");
        if (r < 0)
                return r;
        if (r > 0) {
                struct in6_addr a;
                unsigned i;

                for (i = 0; i < ELEMENTSOF(a.s6_addr); i++) {
                        char label[DNS_LABEL_MAX+1];
                        int x, y;

                        r = dns_label_unescape(&p, label, sizeof(label));
                        if (r <= 0)
                                return r;
                        if (r != 1)
                                return -EINVAL;
                        x = unhexchar(label[0]);
                        if (x < 0)
                                return -EINVAL;

                        r = dns_label_unescape(&p, label, sizeof(label));
                        if (r <= 0)
                                return r;
                        if (r != 1)
                                return -EINVAL;
                        y = unhexchar(label[0]);
                        if (y < 0)
                                return -EINVAL;

                        a.s6_addr[ELEMENTSOF(a.s6_addr) - i - 1] = (uint8_t) y << 4 | (uint8_t) x;
                }

                r = dns_name_equal(p, "ip6.arpa");
                if (r <= 0)
                        return r;

                *family = AF_INET6;
                address->in6 = a;
                return 1;
        }

        return 0;
}

int dns_name_root(const char *name) {
        char label[DNS_LABEL_MAX+1];
        int r;

        assert(name);

        r = dns_label_unescape(&name, label, sizeof(label));
        if (r < 0)
                return r;

        return r == 0 && *name == 0;
}

int dns_name_single_label(const char *name) {
        char label[DNS_LABEL_MAX+1];
        int r;

        assert(name);

        r = dns_label_unescape(&name, label, sizeof(label));
        if (r < 0)
                return r;
        if (r == 0)
                return 0;

        r = dns_label_unescape(&name, label, sizeof(label));
        if (r < 0)
                return r;

        return r == 0 && *name == 0;
}
Commit	Line	Data
5eef597e MP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2014 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#ifdef HAVE_LIBIDN
	23	#include <idna.h>
	24	#include <stringprep.h>
	25	#endif
	26
86f210e9	27	#include "dns-domain.h"
5eef597e MP	28
	29	int dns_label_unescape(const char *name, char dest, size_t sz) {
	30	const char *n;
	31	char *d;
	32	int r = 0;
	33
	34	assert(name);
	35	assert(*name);
	36	assert(dest);
	37
	38	n = *name;
	39	d = dest;
	40
	41	for (;;) {
	42	if (*n == '.') {
	43	n++;
	44	break;
	45	}
	46
	47	if (*n == 0)
	48	break;
	49
	50	if (sz <= 0)
	51	return -ENOSPC;
	52
	53	if (r >= DNS_LABEL_MAX)
	54	return -EINVAL;
	55
	56	if (*n == '\\') {
	57	/* Escaped character */
	58
	59	n++;
	60
	61	if (*n == 0)
	62	/* Ending NUL */
	63	return -EINVAL;
	64
	65	else if (n == '\\' \|\| n == '.') {
	66	/* Escaped backslash or dot */
	67	(d++) = (n++);
	68	sz--;
	69	r++;
	70
	71	} else if (n[0] >= '0' && n[0] <= '9') {
	72	unsigned k;
	73
	74	/* Escaped literal ASCII character */
	75
	76	if (!(n[1] >= '0' && n[1] <= '9') \|\|
	77	!(n[2] >= '0' && n[2] <= '9'))
	78	return -EINVAL;
	79
	80	k = ((unsigned) (n[0] - '0') * 100) +
	81	((unsigned) (n[1] - '0') * 10) +
	82	((unsigned) (n[2] - '0'));
	83
	84	/* Don't allow CC characters or anything that doesn't fit in 8bit */
	85	if (k < ' ' \|\| k > 255 \|\| k == 127)
	86	return -EINVAL;
	87
	88	*(d++) = (char) k;
	89	sz--;
	90	r++;
	91
92	n += 3;
93	} else
94	return -EINVAL;
95
96	} else if ((uint8_t) n >= (uint8_t) ' ' && n != 127) {
97
98	/* Normal character */
99	(d++) = (n++);
100	sz--;
101	r++;
102	} else
103	return -EINVAL;
104	}
105
106	/* Empty label that is not at the end? */
107	if (r == 0 && *n)
108	return -EINVAL;
109
110	if (sz >= 1)
111	*d = 0;
112
113	*name = n;
114	return r;
115	}
116
7035cd9e MP	117	/* @label_terminal: terminal character of a label, updated to point to the terminal character of
	118	* the previous label (always skipping one dot) or to NULL if there are no more
	119	* labels. */
	120	int dns_label_unescape_suffix(const char name, const char label_terminal, char dest, size_t sz) {
	121	const char *terminal;
	122	int r;
	123
	124	assert(name);
	125	assert(label_terminal);
	126	assert(dest);
	127
	128	/* no more labels */
	129	if (!*label_terminal) {
	130	if (sz >= 1)
	131	*dest = 0;
	132
	133	return 0;
	134	}
	135
	136	assert(label_terminal == '.' \|\| label_terminal == 0);
	137
	138	/* skip current terminal character */
	139	terminal = *label_terminal - 1;
	140
	141	/* point name to the last label, and terminal to the preceding terminal symbol (or make it a NULL pointer) */
	142	for (;;) {
	143	if (terminal < name) {
	144	/* reached the first label, so indicate that there are no more */
	145	terminal = NULL;
	146	break;
	147	}
	148
	149	/* find the start of the last label */
	150	if (*terminal == '.') {
	151	const char *y;
	152	unsigned slashes = 0;
	153
	154	for (y = terminal - 1; y >= name && *y == '\\'; y--)
	155	slashes ++;
	156
	157	if (slashes % 2 == 0) {
	158	/* the '.' was not escaped */
	159	name = terminal + 1;
	160	break;
	161	} else {
	162	terminal = y;
	163	continue;
	164	}
	165	}
	166
	167	terminal --;
	168	}
	169
	170	r = dns_label_unescape(&name, dest, sz);
	171	if (r < 0)
	172	return r;
	173
	174	*label_terminal = terminal;
	175
	176	return r;
	177	}
	178
5eef597e MP	179	int dns_label_escape(const char p, size_t l, char *ret) {
	180	_cleanup_free_ char *s = NULL;
	181	char *q;
	182	int r;
	183
	184	assert(p);
	185	assert(ret);
	186
	187	if (l > DNS_LABEL_MAX)
	188	return -EINVAL;
	189
	190	s = malloc(l * 4 + 1);
	191	if (!s)
	192	return -ENOMEM;
	193
	194	q = s;
	195	while (l > 0) {
	196
	197	if (p == '.' \|\| p == '\\') {
	198
	199	/* Dot or backslash */
	200	*(q++) = '\\';
	201	(q++) = p;
	202
	203	} else if (*p == '_' \|\|
	204	*p == '-' \|\|
	205	(p >= '0' && p <= '9') \|\|
	206	(p >= 'a' && p <= 'z') \|\|
	207	(p >= 'A' && p <= 'Z')) {
	208
	209	/* Proper character */
	210	(q++) = p;
	211	} else if ((uint8_t) p >= (uint8_t) ' ' && p != 127) {
	212
	213	/* Everything else */
	214	*(q++) = '\\';
	215	(q++) = '0' + (char) ((uint8_t) p / 100);
	216	(q++) = '0' + (char) (((uint8_t) p / 10) % 10);
	217	(q++) = '0' + (char) ((uint8_t) p % 10);
	218
	219	} else
	220	return -EINVAL;
	221
	222	p++;
	223	l--;
	224	}
	225
	226	*q = 0;
	227	*ret = s;
	228	r = q - s;
	229	s = NULL;
	230
	231	return r;
	232	}
	233
	234	int dns_label_apply_idna(const char encoded, size_t encoded_size, char decoded, size_t decoded_max) {
	235	#ifdef HAVE_LIBIDN
	236	_cleanup_free_ uint32_t *input = NULL;
	237	size_t input_size;
	238	const char *p;
	239	bool contains_8bit = false;
	240
	241	assert(encoded);
	242	assert(decoded);
243	assert(decoded_max >= DNS_LABEL_MAX);
244
245	if (encoded_size <= 0)
246	return 0;
247
248	for (p = encoded; p < encoded + encoded_size; p++)
249	if ((uint8_t) *p > 127)
250	contains_8bit = true;
251
252	if (!contains_8bit)
253	return 0;
254
255	input = stringprep_utf8_to_ucs4(encoded, encoded_size, &input_size);
256	if (!input)
257	return -ENOMEM;
258
259	if (idna_to_ascii_4i(input, input_size, decoded, 0) != 0)
260	return -EINVAL;
261
262	return strlen(decoded);
263	#else
264	return 0;
265	#endif
266	}
267
268	int dns_label_undo_idna(const char encoded, size_t encoded_size, char decoded, size_t decoded_max) {
269	#ifdef HAVE_LIBIDN
270	size_t input_size, output_size;
271	_cleanup_free_ uint32_t *input = NULL;
272	_cleanup_free_ char *result = NULL;
273	uint32_t *output = NULL;
274	size_t w;
275
276	/* To be invoked after unescaping */
277
278	assert(encoded);
279	assert(decoded);
280
281	if (encoded_size < sizeof(IDNA_ACE_PREFIX)-1)
282	return 0;
283
284	if (memcmp(encoded, IDNA_ACE_PREFIX, sizeof(IDNA_ACE_PREFIX) -1) != 0)
285	return 0;
286
287	input = stringprep_utf8_to_ucs4(encoded, encoded_size, &input_size);
288	if (!input)
289	return -ENOMEM;
290
291	output_size = input_size;
292	output = newa(uint32_t, output_size);
293
294	idna_to_unicode_44i(input, input_size, output, &output_size, 0);
295
296	result = stringprep_ucs4_to_utf8(output, output_size, NULL, &w);
297	if (!result)
298	return -ENOMEM;
299	if (w <= 0)
300	return 0;
301	if (w+1 > decoded_max)
302	return -EINVAL;
303
304	memcpy(decoded, result, w+1);
305	return w;
306	#else
307	return 0;
308	#endif
309	}
310
311	int dns_name_normalize(const char s, char *_ret) {
312	_cleanup_free_ char *ret = NULL;
313	size_t n = 0, allocated = 0;
314	const char *p = s;
315	bool first = true;
316	int r;
317
318	assert(s);
319
320	for (;;) {
321	_cleanup_free_ char *t = NULL;
322	char label[DNS_LABEL_MAX];
323	int k;
324
325	r = dns_label_unescape(&p, label, sizeof(label));
326	if (r < 0)
327	return r;
328	if (r == 0) {
329	if (*p != 0)
330	return -EINVAL;
331	break;
332	}
333
334	k = dns_label_undo_idna(label, r, label, sizeof(label));
335	if (k < 0)
336	return k;
337	if (k > 0)
338	r = k;
339
340	r = dns_label_escape(label, r, &t);
341	if (r < 0)
342	return r;
343
344	if (!GREEDY_REALLOC(ret, allocated, n + !first + strlen(t) + 1))
345	return -ENOMEM;
346
347	if (!first)
348	ret[n++] = '.';
349	else
350	first = false;
351
352	memcpy(ret + n, t, r);
353	n += r;
354	}
355
356	if (n > DNS_NAME_MAX)
357	return -EINVAL;
358
359	if (!GREEDY_REALLOC(ret, allocated, n + 1))
360	return -ENOMEM;
361
362	ret[n] = 0;
363
364	if (_ret) {
365	*_ret = ret;
366	ret = NULL;
367	}
368
369	return 0;
370	}
371
372	unsigned long dns_name_hash_func(const void *s, const uint8_t hash_key[HASH_KEY_SIZE]) {
373	const char *p = s;
374	unsigned long ul = hash_key[0];
375	int r;
376
377	assert(p);
378
379	while (*p) {
380	char label[DNS_LABEL_MAX+1];
381	int k;
382
383	r = dns_label_unescape(&p, label, sizeof(label));
384	if (r < 0)
385	break;
386
387	k = dns_label_undo_idna(label, r, label, sizeof(label));
388	if (k < 0)
389	break;
390	if (k > 0)
391	r = k;
392
393	label[r] = 0;
394	ascii_strlower(label);
395
396	ul = ul * hash_key[1] + ul + string_hash_func(label, hash_key);
397	}
398
399	return ul;
400	}
401
402	int dns_name_compare_func(const void a, const void b) {
7035cd9e	403	const char x, y;
5eef597e MP	404	int r, q, k, w;
	405
	406	assert(a);
	407	assert(b);
	408
7035cd9e MP	409	x = (const char *) a + strlen(a);
	410	y = (const char *) b + strlen(b);
	411
5eef597e MP	412	for (;;) {
	413	char la[DNS_LABEL_MAX+1], lb[DNS_LABEL_MAX+1];
	414
7035cd9e	415	if (x == NULL && y == NULL)
5eef597e MP	416	return 0;
5eef597e MP	417
7035cd9e MP	418	r = dns_label_unescape_suffix(a, &x, la, sizeof(la));
7035cd9e MP	419	q = dns_label_unescape_suffix(b, &y, lb, sizeof(lb));
5eef597e MP	420	if (r < 0 \|\| q < 0)
	421	return r - q;
	422
	423	k = dns_label_undo_idna(la, r, la, sizeof(la));
	424	w = dns_label_undo_idna(lb, q, lb, sizeof(lb));
	425	if (k < 0 \|\| w < 0)
	426	return k - w;
	427	if (k > 0)
	428	r = k;
	429	if (w > 0)
	430	r = w;
	431
	432	la[r] = lb[q] = 0;
	433	r = strcasecmp(la, lb);
	434	if (r != 0)
	435	return r;
	436	}
	437	}
	438
	439	const struct hash_ops dns_name_hash_ops = {
	440	.hash = dns_name_hash_func,
	441	.compare = dns_name_compare_func
	442	};
	443
	444	int dns_name_equal(const char x, const char y) {
	445	int r, q, k, w;
	446
	447	assert(x);
	448	assert(y);
	449
	450	for (;;) {
	451	char la[DNS_LABEL_MAX+1], lb[DNS_LABEL_MAX+1];
	452
	453	if (x == 0 && y == 0)
	454	return true;
	455
	456	r = dns_label_unescape(&x, la, sizeof(la));
	457	if (r < 0)
	458	return r;
	459
	460	k = dns_label_undo_idna(la, r, la, sizeof(la));
	461	if (k < 0)
	462	return k;
	463	if (k > 0)
	464	r = k;
	465
	466	q = dns_label_unescape(&y, lb, sizeof(lb));
	467	if (q < 0)
	468	return q;
	469	w = dns_label_undo_idna(lb, q, lb, sizeof(lb));
	470	if (w < 0)
	471	return w;
	472	if (w > 0)
	473	q = w;
	474
	475	la[r] = lb[q] = 0;
	476	if (strcasecmp(la, lb))
	477	return false;
	478	}
	479	}
	480
	481	int dns_name_endswith(const char name, const char suffix) {
	482	const char n, s, *saved_n = NULL;
	483	int r, q, k, w;
484
485	assert(name);
486	assert(suffix);
487
488	n = name;
489	s = suffix;
490
491	for (;;) {
492	char ln[DNS_LABEL_MAX+1], ls[DNS_LABEL_MAX+1];
493
494	r = dns_label_unescape(&n, ln, sizeof(ln));
495	if (r < 0)
496	return r;
497	k = dns_label_undo_idna(ln, r, ln, sizeof(ln));
498	if (k < 0)
499	return k;
500	if (k > 0)
501	r = k;
502
503	if (!saved_n)
504	saved_n = n;
505
506	q = dns_label_unescape(&s, ls, sizeof(ls));
507	if (q < 0)
508	return q;
509	w = dns_label_undo_idna(ls, q, ls, sizeof(ls));
510	if (w < 0)
511	return w;
512	if (w > 0)
513	q = w;
514
515	if (r == 0 && q == 0)
516	return true;
517	if (r == 0 && saved_n == n)
518	return false;
519
520	ln[r] = ls[q] = 0;
521
522	if (r != q \|\| strcasecmp(ln, ls)) {
523
524	/* Not the same, let's jump back, and try with the next label again */
525	s = suffix;
526	n = saved_n;
527	saved_n = NULL;
528	}
529	}
530	}
531
7035cd9e MP	532	int dns_name_between(const char a, const char b, const char *c) {
	533	int n;
	534
	535	/* Determine if b is strictly greater than a and strictly smaller than c.
	536	We consider the order of names to be circular, so that if a is
	537	strictly greater than c, we consider b to be between them if it is
	538	either greater than a or smaller than c. This is how the canonical
	539	DNS name order used in NSEC records work. */
	540
	541	n = dns_name_compare_func(a, c);
	542	if (n == 0)
	543	return -EINVAL;
	544	else if (n < 0)
	545	/* a<---b--->c */
	546	return dns_name_compare_func(a, b) < 0 &&
	547	dns_name_compare_func(b, c) < 0;
	548	else
	549	/* <--b--c a--b--> */
	550	return dns_name_compare_func(b, c) < 0 \|\|
	551	dns_name_compare_func(a, b) < 0;
	552	}
	553
5eef597e MP	554	int dns_name_reverse(int family, const union in_addr_union a, char *ret) {
	555	const uint8_t *p;
	556	int r;
	557
	558	assert(a);
	559	assert(ret);
	560
	561	p = (const uint8_t*) a;
	562
	563	if (family == AF_INET)
	564	r = asprintf(ret, "%u.%u.%u.%u.in-addr.arpa", p[3], p[2], p[1], p[0]);
	565	else if (family == AF_INET6)
	566	r = asprintf(ret, "%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.%c.ip6.arpa",
	567	hexchar(p[15] & 0xF), hexchar(p[15] >> 4), hexchar(p[14] & 0xF), hexchar(p[14] >> 4),
	568	hexchar(p[13] & 0xF), hexchar(p[13] >> 4), hexchar(p[12] & 0xF), hexchar(p[12] >> 4),
	569	hexchar(p[11] & 0xF), hexchar(p[11] >> 4), hexchar(p[10] & 0xF), hexchar(p[10] >> 4),
	570	hexchar(p[ 9] & 0xF), hexchar(p[ 9] >> 4), hexchar(p[ 8] & 0xF), hexchar(p[ 8] >> 4),
	571	hexchar(p[ 7] & 0xF), hexchar(p[ 7] >> 4), hexchar(p[ 6] & 0xF), hexchar(p[ 6] >> 4),
	572	hexchar(p[ 5] & 0xF), hexchar(p[ 5] >> 4), hexchar(p[ 4] & 0xF), hexchar(p[ 4] >> 4),
	573	hexchar(p[ 3] & 0xF), hexchar(p[ 3] >> 4), hexchar(p[ 2] & 0xF), hexchar(p[ 2] >> 4),
	574	hexchar(p[ 1] & 0xF), hexchar(p[ 1] >> 4), hexchar(p[ 0] & 0xF), hexchar(p[ 0] >> 4));
	575	else
	576	return -EAFNOSUPPORT;
	577	if (r < 0)
	578	return -ENOMEM;
	579
	580	return 0;
	581	}
	582
	583	int dns_name_address(const char p, int family, union in_addr_union *address) {
	584	int r;
	585
	586	assert(p);
	587	assert(family);
	588	assert(address);
	589
	590	r = dns_name_endswith(p, "in-addr.arpa");
	591	if (r < 0)
	592	return r;
	593	if (r > 0) {
	594	uint8_t a[4];
	595	unsigned i;
	596
	597	for (i = 0; i < ELEMENTSOF(a); i++) {
	598	char label[DNS_LABEL_MAX+1];
	599
	600	r = dns_label_unescape(&p, label, sizeof(label));
	601	if (r < 0)
	602	return r;
	603	if (r == 0)
	604	return -EINVAL;
	605	if (r > 3)
	606	return -EINVAL;
	607
	608	r = safe_atou8(label, &a[i]);
	609	if (r < 0)
	610	return r;
	611	}
	612
	613	r = dns_name_equal(p, "in-addr.arpa");
	614	if (r <= 0)
	615	return r;
	616
	617	*family = AF_INET;
618	address->in.s_addr = htobe32(((uint32_t) a[3] << 24) \|
619	((uint32_t) a[2] << 16) \|
620	((uint32_t) a[1] << 8) \|
621	(uint32_t) a[0]);
622
623	return 1;
624	}
625
626	r = dns_name_endswith(p, "ip6.arpa");
627	if (r < 0)
628	return r;
629	if (r > 0) {
630	struct in6_addr a;
631	unsigned i;
632
633	for (i = 0; i < ELEMENTSOF(a.s6_addr); i++) {
634	char label[DNS_LABEL_MAX+1];
635	int x, y;
636
637	r = dns_label_unescape(&p, label, sizeof(label));
638	if (r <= 0)
639	return r;
640	if (r != 1)
641	return -EINVAL;
642	x = unhexchar(label[0]);
643	if (x < 0)
644	return -EINVAL;
645
646	r = dns_label_unescape(&p, label, sizeof(label));
647	if (r <= 0)
648	return r;
649	if (r != 1)
650	return -EINVAL;
651	y = unhexchar(label[0]);
652	if (y < 0)
653	return -EINVAL;
654
655	a.s6_addr[ELEMENTSOF(a.s6_addr) - i - 1] = (uint8_t) y << 4 \| (uint8_t) x;
656	}
657
658	r = dns_name_equal(p, "ip6.arpa");
659	if (r <= 0)
660	return r;
661
662	*family = AF_INET6;
663	address->in6 = a;
664	return 1;
665	}
666
667	return 0;
668	}
669
670	int dns_name_root(const char *name) {
671	char label[DNS_LABEL_MAX+1];
672	int r;
673
674	assert(name);
675
676	r = dns_label_unescape(&name, label, sizeof(label));
677	if (r < 0)
678	return r;
679
680	return r == 0 && *name == 0;
681	}
682
683	int dns_name_single_label(const char *name) {
684	char label[DNS_LABEL_MAX+1];
685	int r;
686
687	assert(name);
688
689	r = dns_label_unescape(&name, label, sizeof(label));
690	if (r < 0)
691	return r;
692	if (r == 0)
693	return 0;
694
695	r = dns_label_unescape(&name, label, sizeof(label));
696	if (r < 0)
697	return r;
698
699	return r == 0 && *name == 0;
700	}