HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/dns-domain.c

41,384 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: de8d261d0b02fcb1668b3f30d317e3443e5320b9

Lines 1001–1381 of 1,381

        if (!name)
                return dns_name_concat(type, domain, 0, ret);
 
        if (!dns_service_name_is_valid(name))
                return -EINVAL;
 
        r = dns_label_escape(name, strlen(name), escaped, sizeof(escaped));
        if (r < 0)
                return r;
 
        r = dns_name_concat(type, domain, 0, &n);
        if (r < 0)
                return r;
 
        return dns_name_concat(escaped, n, 0, ret);
}
 
static bool dns_service_name_label_is_valid(const char *label, size_t n) {
        char *s;
 
        assert(label);
 
        if (memchr(label, 0, n))
                return false;
 
        s = strndupa_safe(label, n);
        return dns_service_name_is_valid(s);
}
 
int dns_service_split(const char *joined, char **ret_name, char **ret_type, char **ret_domain) {
        _cleanup_free_ char *name = NULL, *type = NULL, *domain = NULL;
        const char *p = joined, *q = NULL, *d = joined;
        char a[DNS_LABEL_MAX+1], b[DNS_LABEL_MAX+1], c[DNS_LABEL_MAX+1];
        int an, bn, cn, r;
        unsigned x = 0;
 
        assert(joined);
 
        /* Get first label from the full name */
        an = dns_label_unescape(&p, a, sizeof(a), 0);
        if (an < 0)
                return an;
 
        if (an > 0) {
                x++;
 
                /* If there was a first label, try to get the second one */
                bn = dns_label_unescape(&p, b, sizeof(b), 0);
                if (bn < 0)
                        return bn;
 
                if (bn > 0) {
                        if (!srv_type_label_is_valid(b, bn))
                                goto finish;
 
                        x++;
 
                        /* If there was a second label, try to get the third one */
                        q = p;
                        cn = dns_label_unescape(&p, c, sizeof(c), 0);
                        if (cn < 0)
                                return cn;
 
                        if (cn > 0 && srv_type_label_is_valid(c, cn))
                                x++;
                }
        }
 
        switch (x) {
        case 2:
                if (!srv_type_label_is_valid(a, an))
                        break;
 
                /* OK, got <type> . <type2> . <domain> */
 
                name = NULL;
 
                type = strjoin(a, ".", b);
                if (!type)
                        return -ENOMEM;
 
                d = q;
                break;
 
        case 3:
                if (!dns_service_name_label_is_valid(a, an))
                        break;
 
                /* OK, got <name> . <type> . <type2> . <domain> */
 
                name = strndup(a, an);
                if (!name)
                        return -ENOMEM;
 
                type = strjoin(b, ".", c);
                if (!type)
                        return -ENOMEM;
 
                d = p;
                break;
        }
 
finish:
        r = dns_name_normalize(d, 0, &domain);
        if (r < 0)
                return r;
 
        if (ret_domain)
                *ret_domain = TAKE_PTR(domain);
 
        if (ret_type)
                *ret_type = TAKE_PTR(type);
 
        if (ret_name)
                *ret_name = TAKE_PTR(name);
 
        return 0;
}
 
static int dns_name_build_suffix_table(const char *name, const char *table[]) {
        const char *p = ASSERT_PTR(name);
        unsigned n = 0;
        int r;
 
        assert(table);
 
        for (;;) {
                if (n > DNS_N_LABELS_MAX)
                        return -EINVAL;
 
                table[n] = p;
                r = dns_name_parent(&p);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;
 
                n++;
        }
 
        return (int) n;
}
 
int dns_name_suffix(const char *name, unsigned n_labels, const char **ret) {
        const char* labels[DNS_N_LABELS_MAX+1];
        int n;
 
        assert(name);
        assert(ret);
 
        n = dns_name_build_suffix_table(name, labels);
        if (n < 0)
                return n;
 
        if ((unsigned) n < n_labels)
                return -EINVAL;
 
        *ret = labels[n - n_labels];
        return (int) (n - n_labels);
}
 
int dns_name_skip(const char *a, unsigned n_labels, const char **ret) {
        int r;
 
        assert(a);
        assert(ret);
 
        for (; n_labels > 0; n_labels--) {
                r = dns_name_parent(&a);
                if (r < 0)
                        return r;
                if (r == 0) {
                        *ret = "";
                        return 0;
                }
        }
 
        *ret = a;
        return 1;
}
 
int dns_name_count_labels(const char *name) {
        unsigned n = 0;
        int r;
 
        assert(name);
 
        for (const char *p = name;;) {
                r = dns_name_parent(&p);
                if (r < 0)
                        return r;
                if (r == 0)
                        break;
 
                if (n >= DNS_N_LABELS_MAX)
                        return -EINVAL;
 
                n++;
        }
 
        return n;
}
 
int dns_name_equal_skip(const char *a, unsigned n_labels, const char *b) {
        int r;
 
        assert(a);
        assert(b);
 
        r = dns_name_skip(a, n_labels, &a);
        if (r <= 0)
                return r;
 
        return dns_name_equal(a, b);
}
 
int dns_name_common_suffix(const char *a, const char *b, const char **ret) {
        const char *a_labels[DNS_N_LABELS_MAX+1], *b_labels[DNS_N_LABELS_MAX+1];
        int n = 0, m = 0, k = 0, r, q;
 
        assert(a);
        assert(b);
        assert(ret);
 
        /* Determines the common suffix of domain names a and b */
 
        n = dns_name_build_suffix_table(a, a_labels);
        if (n < 0)
                return n;
 
        m = dns_name_build_suffix_table(b, b_labels);
        if (m < 0)
                return m;
 
        for (;;) {
                char la[DNS_LABEL_MAX+1], lb[DNS_LABEL_MAX+1];
                const char *x, *y;
 
                if (k >= n || k >= m) {
                        *ret = a_labels[n - k];
                        return 0;
                }
 
                x = a_labels[n - 1 - k];
                r = dns_label_unescape(&x, la, sizeof la, 0);
                if (r < 0)
                        return r;
 
                y = b_labels[m - 1 - k];
                q = dns_label_unescape(&y, lb, sizeof lb, 0);
                if (q < 0)
                        return q;
 
                if (r != q || ascii_strcasecmp_n(la, lb, r) != 0) {
                        *ret = a_labels[n - k];
                        return 0;
                }
 
                k++;
        }
}
 
int dns_name_apply_idna(const char *name, char **ret) {
 
        /* Return negative on error, 0 if not implemented, positive on success. */
 
#if HAVE_LIBIDN2
        int r;
 
        r = dlopen_idn(LOG_DEBUG);
        if (r == -EOPNOTSUPP) {
                *ret = NULL;
                return 0;
        }
        if (r < 0)
                return r;
 
        _cleanup_free_ char *t = NULL;
 
        assert(name);
        assert(ret);
 
        /* First, try non-transitional mode (i.e. IDN2008 rules) */
        r = sym_idn2_lookup_u8((uint8_t*) name, (uint8_t**) &t,
                               IDN2_NFC_INPUT | IDN2_NONTRANSITIONAL);
        if (r == IDN2_DISALLOWED) /* If that failed, because of disallowed characters, try transitional mode.
                                   * (i.e. IDN2003 rules which supports some unicode chars IDN2008 doesn't allow). */
                r = sym_idn2_lookup_u8((uint8_t*) name, (uint8_t**) &t,
                                       IDN2_NFC_INPUT | IDN2_TRANSITIONAL);
 
        log_debug("idn2_lookup_u8: %s %s %s", name, glyph(GLYPH_ARROW_RIGHT), t);
        if (r == IDN2_OK) {
                if (!startswith(name, "xn--")) {
                        _cleanup_free_ char *s = NULL;
 
                        r = sym_idn2_to_unicode_8z8z(t, &s, 0);
                        if (r != IDN2_OK) {
                                log_debug("idn2_to_unicode_8z8z(\"%s\") failed: %d/%s",
                                          t, r, sym_idn2_strerror(r));
                                *ret = NULL;
                                return 0;
                        }
 
                        if (!streq_ptr(name, s)) {
                                log_debug("idn2 roundtrip failed: \"%s\" %s \"%s\" %s \"%s\", ignoring.",
                                          name, glyph(GLYPH_ARROW_RIGHT), t,
                                          glyph(GLYPH_ARROW_RIGHT), s);
                                *ret = NULL;
                                return 0;
                        }
                }
 
                *ret = TAKE_PTR(t);
                return 1; /* *ret has been written */
        }
 
        log_debug("idn2_lookup_u8(\"%s\") failed: %d/%s", name, r, sym_idn2_strerror(r));
        if (r == IDN2_2HYPHEN)
                /* The name has two hyphens — forbidden by IDNA2008 in some cases */
                return 0;
        if (IN_SET(r, IDN2_TOO_BIG_DOMAIN, IDN2_TOO_BIG_LABEL))
                return -ENOSPC;
 
        return -EINVAL;
#else
        *ret = NULL;
        return 0;
#endif
}
 
int dns_name_is_valid_or_address(const char *name) {
        /* Returns > 0 if the specified name is either a valid IP address formatted as string or a valid DNS name */
 
        if (isempty(name))
                return 0;
 
        if (in_addr_from_string_auto(name, NULL, NULL) >= 0)
                return 1;
 
        return dns_name_is_valid(name);
}
 
int dns_name_dot_suffixed(const char *name) {
        const char *p = name;
        int r;
 
        for (;;) {
                if (streq(p, "."))
                        return true;
 
                r = dns_label_unescape(&p, NULL, DNS_LABEL_MAX, DNS_LABEL_LEAVE_TRAILING_DOT);
                if (r < 0)
                        return r;
                if (r == 0)
                        return false;
        }
}
 
bool dns_name_dont_resolve(const char *name) {
 
        /* Never respond to some of the domains listed in RFC6303 */
        if (dns_name_endswith(name, "0.in-addr.arpa") > 0 ||
            dns_name_equal(name, "255.255.255.255.in-addr.arpa") > 0 ||
            dns_name_equal(name, "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa") > 0)
                return true;
 
        /* Never respond to some of the domains listed in RFC6761 */
        if (dns_name_endswith(name, "invalid") > 0)
                return true;
 
        /* Never respond to the domains listed in RFC7686 */
        if (dns_name_endswith(name, "onion") > 0)
                return true;
 
        /* Never respond to some of the domains listed in RFC9476 */
        if (dns_name_endswith(name, "alt") > 0)
                return true;
 
        return false;
}