HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/dns-packet.c

106,506 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: c27254297516167354363db6d609d0673060f634

Lines 3001–3202 of 3,202

                                if (!utf8_is_valid(msg)) {
                                        _cleanup_free_ char *msg_escaped = NULL;
 
                                        msg_escaped = cescape(msg);
                                        if (!msg_escaped)
                                                return log_oom_debug();
 
                                        *ret_ede_msg = TAKE_PTR(msg_escaped);
                                } else
                                        *ret_ede_msg = TAKE_PTR(msg);
                        }
 
                        if (ret_ede_rcode)
                                *ret_ede_rcode = unaligned_read_be16(d + 4);
 
                        return 0;
                }
 
                d += 4U + length;
                l -= 4U + length;
        }
 
        return -ENOENT;
}
 
bool dns_ede_rcode_is_dnssec(int ede_rcode) {
        return IN_SET(ede_rcode,
                        DNS_EDE_RCODE_UNSUPPORTED_DNSKEY_ALG,
                        DNS_EDE_RCODE_UNSUPPORTED_DS_DIGEST,
                        DNS_EDE_RCODE_DNSSEC_INDETERMINATE,
                        DNS_EDE_RCODE_DNSSEC_BOGUS,
                        DNS_EDE_RCODE_SIG_EXPIRED,
                        DNS_EDE_RCODE_SIG_NOT_YET_VALID,
                        DNS_EDE_RCODE_DNSKEY_MISSING,
                        DNS_EDE_RCODE_RRSIG_MISSING,
                        DNS_EDE_RCODE_NO_ZONE_KEY_BIT,
                        DNS_EDE_RCODE_NSEC_MISSING
                     );
}
 
int dns_packet_has_nsid_request(DnsPacket *p) {
        bool has_nsid = false;
        const uint8_t *d;
        size_t l;
 
        assert(p);
 
        if (!p->opt)
                return false;
 
        d = p->opt->opt.data;
        l = p->opt->opt.data_size;
 
        while (l > 0) {
                uint16_t code, length;
 
                if (l < 4U)
                        return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
                                               "EDNS0 variable part has invalid size.");
 
                code = unaligned_read_be16(d);
                length = unaligned_read_be16(d + 2);
 
                if (l < 4U + length)
                        return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
                                               "Truncated option in EDNS0 variable part.");
 
                if (code == DNS_EDNS_OPT_NSID) {
                        if (has_nsid)
                                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
                                                       "Duplicate NSID option in EDNS0 variable part.");
 
                        if (length != 0)
                                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
                                                       "Non-empty NSID option in DNS request.");
 
                        has_nsid = true;
                }
 
                d += 4U + length;
                l -= 4U + length;
        }
 
        return has_nsid;
}
 
size_t dns_packet_size_unfragmented(DnsPacket *p) {
        assert(p);
 
        if (p->fragsize == 0) /* Wasn't fragmented */
                return p->size;
 
        /* The fragment size (p->fragsize) covers the whole (fragmented) IP packet, while the regular packet
         * size (p->size) only covers the DNS part. Thus, subtract the UDP header from the largest fragment
         * size, in order to determine which size of DNS packet would have gone through without
         * fragmenting. */
 
        return LESS_BY(p->fragsize, udp_header_size(p->family));
}
 
static const char* const dns_svc_param_key_table[_DNS_SVC_PARAM_KEY_MAX_DEFINED] = {
        [DNS_SVC_PARAM_KEY_MANDATORY]       = "mandatory",
        [DNS_SVC_PARAM_KEY_ALPN]            = "alpn",
        [DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN] = "no-default-alpn",
        [DNS_SVC_PARAM_KEY_PORT]            = "port",
        [DNS_SVC_PARAM_KEY_IPV4HINT]        = "ipv4hint",
        [DNS_SVC_PARAM_KEY_ECH]             = "ech",
        [DNS_SVC_PARAM_KEY_IPV6HINT]        = "ipv6hint",
        [DNS_SVC_PARAM_KEY_DOHPATH]         = "dohpath",
        [DNS_SVC_PARAM_KEY_OHTTP]           = "ohttp",
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(dns_svc_param_key, int);
 
const char* format_dns_svc_param_key(uint16_t i, char buf[static DECIMAL_STR_MAX(uint16_t)+3]) {
        const char *p = dns_svc_param_key_to_string(i);
        if (p)
                return p;
 
        return snprintf_ok(buf, DECIMAL_STR_MAX(uint16_t)+3, "key%i", i);
}
 
static const char* const dns_rcode_table[_DNS_RCODE_MAX_DEFINED] = {
        [DNS_RCODE_SUCCESS]   = "SUCCESS",
        [DNS_RCODE_FORMERR]   = "FORMERR",
        [DNS_RCODE_SERVFAIL]  = "SERVFAIL",
        [DNS_RCODE_NXDOMAIN]  = "NXDOMAIN",
        [DNS_RCODE_NOTIMP]    = "NOTIMP",
        [DNS_RCODE_REFUSED]   = "REFUSED",
        [DNS_RCODE_YXDOMAIN]  = "YXDOMAIN",
        [DNS_RCODE_YXRRSET]   = "YRRSET",
        [DNS_RCODE_NXRRSET]   = "NXRRSET",
        [DNS_RCODE_NOTAUTH]   = "NOTAUTH",
        [DNS_RCODE_NOTZONE]   = "NOTZONE",
        [DNS_RCODE_DSOTYPENI] = "DSOTYPENI",
        [DNS_RCODE_BADVERS]   = "BADVERS",
        [DNS_RCODE_BADKEY]    = "BADKEY",
        [DNS_RCODE_BADTIME]   = "BADTIME",
        [DNS_RCODE_BADMODE]   = "BADMODE",
        [DNS_RCODE_BADNAME]   = "BADNAME",
        [DNS_RCODE_BADALG]    = "BADALG",
        [DNS_RCODE_BADTRUNC]  = "BADTRUNC",
        [DNS_RCODE_BADCOOKIE] = "BADCOOKIE",
};
DEFINE_STRING_TABLE_LOOKUP(dns_rcode, int);
 
const char* format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
        const char *p = dns_rcode_to_string(i);
        if (p)
                return p;
 
        return snprintf_ok(buf, DECIMAL_STR_MAX(int), "%i", i);
}
 
static const char* const dns_ede_rcode_table[_DNS_EDE_RCODE_MAX_DEFINED] = {
        [DNS_EDE_RCODE_OTHER]                  = "Other",
        [DNS_EDE_RCODE_UNSUPPORTED_DNSKEY_ALG] = "Unsupported DNSKEY Algorithm",
        [DNS_EDE_RCODE_UNSUPPORTED_DS_DIGEST]  = "Unsupported DS Digest Type",
        [DNS_EDE_RCODE_STALE_ANSWER]           = "Stale Answer",
        [DNS_EDE_RCODE_FORGED_ANSWER]          = "Forged Answer",
        [DNS_EDE_RCODE_DNSSEC_INDETERMINATE]   = "DNSSEC Indeterminate",
        [DNS_EDE_RCODE_DNSSEC_BOGUS]           = "DNSSEC Bogus",
        [DNS_EDE_RCODE_SIG_EXPIRED]            = "Signature Expired",
        [DNS_EDE_RCODE_SIG_NOT_YET_VALID]      = "Signature Not Yet Valid",
        [DNS_EDE_RCODE_DNSKEY_MISSING]         = "DNSKEY Missing",
        [DNS_EDE_RCODE_RRSIG_MISSING]          = "RRSIG Missing",
        [DNS_EDE_RCODE_NO_ZONE_KEY_BIT]        = "No Zone Key Bit Set",
        [DNS_EDE_RCODE_NSEC_MISSING]           = "NSEC Missing",
        [DNS_EDE_RCODE_CACHED_ERROR]           = "Cached Error",
        [DNS_EDE_RCODE_NOT_READY]              = "Not Ready",
        [DNS_EDE_RCODE_BLOCKED]                = "Blocked",
        [DNS_EDE_RCODE_CENSORED]               = "Censored",
        [DNS_EDE_RCODE_FILTERED]               = "Filtered",
        [DNS_EDE_RCODE_PROHIBITED]             = "Prohibited",
        [DNS_EDE_RCODE_STALE_NXDOMAIN_ANSWER]  = "Stale NXDOMAIN Answer",
        [DNS_EDE_RCODE_NOT_AUTHORITATIVE]      = "Not Authoritative",
        [DNS_EDE_RCODE_NOT_SUPPORTED]          = "Not Supported",
        [DNS_EDE_RCODE_UNREACH_AUTHORITY]      = "No Reachable Authority",
        [DNS_EDE_RCODE_NET_ERROR]              = "Network Error",
        [DNS_EDE_RCODE_INVALID_DATA]           = "Invalid Data",
        [DNS_EDE_RCODE_SIG_NEVER]              = "Signature Never Valid",
        [DNS_EDE_RCODE_TOO_EARLY]              = "Too Early",
        [DNS_EDE_RCODE_UNSUPPORTED_NSEC3_ITER] = "Unsupported NSEC3 Iterations",
        [DNS_EDE_RCODE_TRANSPORT_POLICY]       = "Impossible Transport Policy",
        [DNS_EDE_RCODE_SYNTHESIZED]            = "Synthesized",
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(dns_ede_rcode, int);
 
const char* format_dns_ede_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
        const char *p = dns_ede_rcode_to_string(i);
        if (p)
                return p;
 
        return snprintf_ok(buf, DECIMAL_STR_MAX(int), "%i", i);
}
 
static const char* const dns_protocol_table[_DNS_PROTOCOL_MAX] = {
        [DNS_PROTOCOL_DNS]   = "dns",
        [DNS_PROTOCOL_MDNS]  = "mdns",
        [DNS_PROTOCOL_LLMNR] = "llmnr",
};
DEFINE_STRING_TABLE_LOOKUP(dns_protocol, DnsProtocol);