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 1001–2000 of 3,202

         * root label, rather than a compression pointer to a root label elsewhere: after the move, such a
         * pointer might point into the RR itself or into the part that is cut off. opt_min_size also counts
         * the name as one byte. */
        if (reserve_opt && p->opt_start != SIZE_MAX && DNS_PACKET_DATA(p)[p->opt_start] == 0) {
                if (end + p->opt_size <= max_size)
                        opt_move_size = p->opt_size;
                else if (end + opt_min_size <= max_size)
                        /* No room for the options? Then keep only the fixed part, which carries the UDP
                         * payload size, extended RCODE and flags. */
                        opt_move_size = opt_min_size;
        }
 
        for (unsigned i = 0; i < DNS_PACKET_RRCOUNT(p) && p->rindex < p->size; i++) {
                size_t start;
                bool is_opt;
 
                r = dns_packet_read_rr(p, /* ret= */ NULL, /* ret_cache_flush= */ NULL, &start);
                if (r < 0)
                        return r;
 
                is_opt = start == p->opt_start;
 
                if (p->rindex + (!opt_kept && !is_opt ? opt_move_size : 0) > max_size)
                        break;
 
                opt_kept = opt_kept || is_opt;
                end = p->rindex;
                n_rr++;
        }
 
        n_an = MIN(n_rr, DNS_PACKET_ANCOUNT(p));
        n_ns = MIN(n_rr - n_an, DNS_PACKET_NSCOUNT(p));
        n_ar = n_rr - n_an - n_ns;
 
        if (!opt_kept && opt_move_size > 0) {
                assert(end + opt_move_size <= max_size);
 
                memmove(DNS_PACKET_DATA(p) + end, DNS_PACKET_DATA(p) + p->opt_start, opt_move_size);
                if (opt_move_size < p->opt_size)
                        /* RDLENGTH */
                        unaligned_write_be16(DNS_PACKET_DATA(p) + end + opt_min_size - sizeof(uint16_t), 0);
 
                p->opt_start = end;
                p->opt_size = opt_move_size;
                end += opt_move_size;
                n_ar++;
        } else if (!opt_kept) {
                p->opt = dns_resource_record_unref(p->opt);
                p->opt_start = p->opt_size = SIZE_MAX;
        }
 
        dns_packet_truncate(p, end);
        dns_packet_rewind(p, DNS_PACKET_HEADER_SIZE);
 
        DNS_PACKET_HEADER(p)->ancount = htobe16(n_an);
        DNS_PACKET_HEADER(p)->nscount = htobe16(n_ns);
        DNS_PACKET_HEADER(p)->arcount = htobe16(n_ar);
 
        return 0;
}
 
int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, const DnsAnswerFlags flags, size_t *start, size_t *rdata_start) {
 
        size_t saved_size, rdlength_offset, end, rdlength, rds;
        uint32_t ttl;
        int r;
 
        assert(p);
        assert(rr);
 
        saved_size = p->size;
 
        r = dns_packet_append_key(p, rr->key, flags, NULL);
        if (r < 0)
                goto fail;
 
        ttl = flags & DNS_ANSWER_GOODBYE ? 0 : rr->ttl;
        r = dns_packet_append_uint32(p, ttl, NULL);
        if (r < 0)
                goto fail;
 
        /* Initially we write 0 here */
        r = dns_packet_append_uint16(p, 0, &rdlength_offset);
        if (r < 0)
                goto fail;
 
        rds = p->size - saved_size;
 
        switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
 
        case DNS_TYPE_SRV:
                r = dns_packet_append_uint16(p, rr->srv.priority, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint16(p, rr->srv.weight, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint16(p, rr->srv.port, NULL);
                if (r < 0)
                        goto fail;
 
                /* RFC 2782 states "Unless and until permitted by future standards action, name compression
                 * is not to be used for this field." Hence we turn off compression here. */
                r = dns_packet_append_name(p, rr->srv.name, /* allow_compression= */ false, /* canonical_candidate= */ true, NULL);
                break;
 
        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
        case DNS_TYPE_DNAME:
                r = dns_packet_append_name(p, rr->ptr.name, true, true, NULL);
                break;
 
        case DNS_TYPE_HINFO:
                r = dns_packet_append_string(p, rr->hinfo.cpu, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_string(p, rr->hinfo.os, NULL);
                break;
 
        case DNS_TYPE_SPF: /* exactly the same as TXT */
        case DNS_TYPE_TXT:
 
                if (!rr->txt.items) {
                        /* RFC 6763, section 6.1 suggests to generate
                         * single empty string for an empty array. */
 
                        r = dns_packet_append_raw_string(p, NULL, 0, NULL);
                        if (r < 0)
                                goto fail;
                } else
                        LIST_FOREACH(items, i, rr->txt.items) {
                                r = dns_packet_append_raw_string(p, i->data, i->length, NULL);
                                if (r < 0)
                                        goto fail;
                        }
 
                r = 0;
                break;
 
        case DNS_TYPE_A:
                r = dns_packet_append_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
                break;
 
        case DNS_TYPE_AAAA:
                r = dns_packet_append_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
                break;
 
        case DNS_TYPE_SOA:
                r = dns_packet_append_name(p, rr->soa.mname, true, true, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_name(p, rr->soa.rname, true, true, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->soa.serial, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->soa.refresh, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->soa.retry, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->soa.expire, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->soa.minimum, NULL);
                break;
 
        case DNS_TYPE_MX:
                r = dns_packet_append_uint16(p, rr->mx.priority, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_name(p, rr->mx.exchange, true, true, NULL);
                break;
 
        case DNS_TYPE_LOC:
                r = dns_packet_append_uint8(p, rr->loc.version, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->loc.size, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->loc.horiz_pre, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->loc.vert_pre, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->loc.latitude, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->loc.longitude, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->loc.altitude, NULL);
                break;
 
        case DNS_TYPE_DS:
                r = dns_packet_append_uint16(p, rr->ds.key_tag, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->ds.algorithm, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->ds.digest_type, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->ds.digest, rr->ds.digest_size, NULL);
                break;
 
        case DNS_TYPE_SSHFP:
                r = dns_packet_append_uint8(p, rr->sshfp.algorithm, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->sshfp.fptype, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->sshfp.fingerprint, rr->sshfp.fingerprint_size, NULL);
                break;
 
        case DNS_TYPE_DNSKEY:
                r = dns_packet_append_uint16(p, rr->dnskey.flags, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->dnskey.protocol, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->dnskey.algorithm, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->dnskey.key, rr->dnskey.key_size, NULL);
                break;
 
        case DNS_TYPE_RRSIG:
                r = dns_packet_append_uint16(p, rr->rrsig.type_covered, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->rrsig.algorithm, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->rrsig.labels, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->rrsig.original_ttl, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->rrsig.expiration, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint32(p, rr->rrsig.inception, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint16(p, rr->rrsig.key_tag, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_name(p, rr->rrsig.signer, false, true, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->rrsig.signature, rr->rrsig.signature_size, NULL);
                break;
 
        case DNS_TYPE_NSEC:
                r = dns_packet_append_name(p, rr->nsec.next_domain_name, false, false, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_types(p, rr->nsec.types, NULL);
                if (r < 0)
                        goto fail;
 
                break;
 
        case DNS_TYPE_NSEC3:
                r = dns_packet_append_uint8(p, rr->nsec3.algorithm, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->nsec3.flags, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint16(p, rr->nsec3.iterations, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->nsec3.salt_size, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->nsec3.salt, rr->nsec3.salt_size, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->nsec3.next_hashed_name_size, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_types(p, rr->nsec3.types, NULL);
                if (r < 0)
                        goto fail;
 
                break;
 
        case DNS_TYPE_TLSA:
                r = dns_packet_append_uint8(p, rr->tlsa.cert_usage, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->tlsa.selector, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint8(p, rr->tlsa.matching_type, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->tlsa.data, rr->tlsa.data_size, NULL);
                break;
 
        case DNS_TYPE_SVCB:
        case DNS_TYPE_HTTPS:
                r = dns_packet_append_uint16(p, rr->svcb.priority, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_name(p, rr->svcb.target_name, false, false, NULL);
                if (r < 0)
                        goto fail;
 
                LIST_FOREACH(params, i, rr->svcb.params) {
                        r = dns_packet_append_uint16(p, i->key, NULL);
                        if (r < 0)
                                goto fail;
 
                        r = dns_packet_append_uint16(p, i->length, NULL);
                        if (r < 0)
                                goto fail;
 
                        r = dns_packet_append_blob(p, i->value, i->length, NULL);
                        if (r < 0)
                                goto fail;
                }
                break;
 
        case DNS_TYPE_CAA:
                r = dns_packet_append_uint8(p, rr->caa.flags, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_string(p, rr->caa.tag, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_blob(p, rr->caa.value, rr->caa.value_size, NULL);
                break;
 
        case DNS_TYPE_NAPTR:
                r = dns_packet_append_uint16(p, rr->naptr.order, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_uint16(p, rr->naptr.preference, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_string(p, rr->naptr.flags, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_string(p, rr->naptr.services, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_string(p, rr->naptr.regexp, NULL);
                if (r < 0)
                        goto fail;
 
                r = dns_packet_append_name(p, rr->naptr.replacement, /* allow_compression= */ false, /* canonical_candidate= */ true, NULL);
                break;
 
        case DNS_TYPE_OPT:
        case DNS_TYPE_OPENPGPKEY:
        case _DNS_TYPE_INVALID: /* unparsable */
        default:
                r = dns_packet_append_blob(p, rr->generic.data, rr->generic.data_size, NULL);
        }
        if (r < 0)
                goto fail;
 
        /* Let's calculate the actual data size and update the field */
        rdlength = p->size - rdlength_offset - sizeof(uint16_t);
        if (rdlength > 0xFFFF) {
                r = -ENOSPC;
                goto fail;
        }
 
        end = p->size;
        p->size = rdlength_offset;
        r = dns_packet_append_uint16(p, rdlength, NULL);
        if (r < 0)
                goto fail;
        p->size = end;
 
        if (start)
                *start = saved_size;
 
        if (rdata_start)
                *rdata_start = rds;
 
        return 0;
 
fail:
        dns_packet_truncate(p, saved_size);
        return r;
}
 
int dns_packet_append_question(DnsPacket *p, DnsQuestion *q) {
        DnsResourceKey *key;
        int r;
 
        assert(p);
 
        DNS_QUESTION_FOREACH(key, q) {
                r = dns_packet_append_key(p, key, 0, NULL);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
int dns_packet_append_answer(DnsPacket *p, DnsAnswer *a, unsigned *completed) {
        DnsResourceRecord *rr;
        DnsAnswerFlags flags;
        int r;
 
        assert(p);
 
        DNS_ANSWER_FOREACH_FLAGS(rr, flags, a) {
                r = dns_packet_append_rr(p, rr, flags, NULL, NULL);
                if (r < 0)
                        return r;
 
                if (completed)
                        (*completed)++;
        }
 
        return 0;
}
 
int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, size_t *start) {
        assert(p);
        assert(p->rindex <= p->size);
 
        if (sz > p->size - p->rindex)
                return -EMSGSIZE;
 
        if (ret)
                *ret = DNS_PACKET_DATA(p) + p->rindex;
 
        if (start)
                *start = p->rindex;
 
        p->rindex += sz;
        return 0;
}
 
void dns_packet_rewind(DnsPacket *p, size_t idx) {
        assert(p);
        assert(idx <= p->size);
        assert(idx >= DNS_PACKET_HEADER_SIZE);
 
        p->rindex = idx;
}
 
int dns_packet_read_blob(DnsPacket *p, void *d, size_t sz, size_t *start) {
        const void *q;
        int r;
 
        assert(p);
        assert(d);
 
        r = dns_packet_read(p, sz, &q, start);
        if (r < 0)
                return r;
 
        memcpy(d, q, sz);
        return 0;
}
 
static int dns_packet_read_memdup(
                DnsPacket *p, size_t size,
                void **ret, size_t *ret_size,
                size_t *ret_start) {
 
        const void *src;
        size_t start;
        int r;
 
        assert(p);
        assert(ret);
 
        r = dns_packet_read(p, size, &src, &start);
        if (r < 0)
                return r;
 
        if (size <= 0)
                *ret = NULL;
        else {
                void *copy;
 
                copy = memdup(src, size);
                if (!copy)
                        return -ENOMEM;
 
                *ret = copy;
        }
 
        if (ret_size)
                *ret_size = size;
        if (ret_start)
                *ret_start = start;
 
        return 0;
}
 
int dns_packet_read_uint8(DnsPacket *p, uint8_t *ret, size_t *start) {
        const void *d;
        int r;
 
        assert(p);
 
        r = dns_packet_read(p, sizeof(uint8_t), &d, start);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = ((uint8_t*) d)[0];
 
        return 0;
}
 
int dns_packet_read_uint16(DnsPacket *p, uint16_t *ret, size_t *start) {
        const void *d;
        int r;
 
        assert(p);
 
        r = dns_packet_read(p, sizeof(uint16_t), &d, start);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = unaligned_read_be16(d);
 
        return 0;
}
 
int dns_packet_read_uint32(DnsPacket *p, uint32_t *ret, size_t *start) {
        const void *d;
        int r;
 
        assert(p);
 
        r = dns_packet_read(p, sizeof(uint32_t), &d, start);
        if (r < 0)
                return r;
 
        if (ret)
                *ret = unaligned_read_be32(d);
 
        return 0;
}
 
int dns_packet_read_string(DnsPacket *p, char **ret, size_t *start) {
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        _cleanup_free_ char *t = NULL;
        const void *d;
        uint8_t c;
        int r;
 
        assert(p);
        assert(ret);
 
        r = dns_packet_read_uint8(p, &c, NULL);
        if (r < 0)
                return r;
 
        r = dns_packet_read(p, c, &d, NULL);
        if (r < 0)
                return r;
 
        r = make_cstring(d, c, MAKE_CSTRING_REFUSE_TRAILING_NUL, &t);
        if (r < 0)
                return r;
 
        if (!utf8_is_valid(t))
                return -EBADMSG;
 
        *ret = TAKE_PTR(t);
 
        if (start)
                *start = rewinder.saved_rindex;
        CANCEL_REWINDER(rewinder);
 
        return 0;
}
 
int dns_packet_read_raw_string(DnsPacket *p, const void **ret, size_t *size, size_t *start) {
        assert(p);
 
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        uint8_t c;
        int r;
 
        r = dns_packet_read_uint8(p, &c, NULL);
        if (r < 0)
                return r;
 
        r = dns_packet_read(p, c, ret, NULL);
        if (r < 0)
                return r;
 
        if (size)
                *size = c;
        if (start)
                *start = rewinder.saved_rindex;
        CANCEL_REWINDER(rewinder);
 
        return 0;
}
 
int dns_packet_read_name(
                DnsPacket *p,
                char **ret,
                bool allow_compression,
                size_t *ret_start) {
 
        assert(p);
 
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        size_t after_rindex = 0, jump_barrier = p->rindex, jumps = 0;
        _cleanup_free_ char *name = NULL;
        bool first = true;
        size_t n = 0, m = 0;
        int r;
 
        if (p->refuse_compression)
                allow_compression = false;
 
        for (;;) {
                uint8_t c, d;
 
                r = dns_packet_read_uint8(p, &c, NULL);
                if (r < 0)
                        return r;
 
                if (c == 0)
                        /* End of name */
                        break;
                else if (c <= 63) {
                        const char *label;
 
                        /* Literal label */
                        r = dns_packet_read(p, c, (const void**) &label, NULL);
                        if (r < 0)
                                return r;
 
                        if (!GREEDY_REALLOC(name, n + !first + DNS_LABEL_ESCAPED_MAX))
                                return -ENOMEM;
 
                        if (first)
                                first = false;
                        else {
                                name[n++] = '.';
                                m++;
                        }
 
                        r = dns_label_escape(label, c, name + n, DNS_LABEL_ESCAPED_MAX);
                        if (r < 0)
                                return r;
 
                        n += r;
                        m += c;
 
                        if (m > DNS_HOSTNAME_MAX)
                                return -EBADMSG;
 
                        continue;
                } else if (allow_compression && FLAGS_SET(c, DNS_COMPRESSION_POINTER_FLAG >> 8)) {
                        uint16_t ptr;
 
                        /* Pointer */
                        r = dns_packet_read_uint8(p, &d, NULL);
                        if (r < 0)
                                return r;
 
                        ptr = (uint16_t) (c & ~(DNS_COMPRESSION_POINTER_FLAG >> 8)) << 8 | (uint16_t) d;
                        if (ptr < DNS_PACKET_HEADER_SIZE || ptr >= jump_barrier)
                                return -EBADMSG;
 
                        if (jumps++ >= DNS_COMPRESSION_JUMPS_MAX)
                                return -EBADMSG;
 
                        if (after_rindex == 0)
                                after_rindex = p->rindex;
 
                        /* Jumps are limited to a "prior occurrence" (RFC-1035 4.1.4) */
                        jump_barrier = ptr;
                        p->rindex = ptr;
                } else
                        return -EBADMSG;
        }
 
        if (!GREEDY_REALLOC(name, n + 1))
                return -ENOMEM;
 
        name[n] = 0;
 
        if (after_rindex != 0)
                p->rindex= after_rindex;
 
        if (ret)
                *ret = TAKE_PTR(name);
        if (ret_start)
                *ret_start = rewinder.saved_rindex;
 
        CANCEL_REWINDER(rewinder);
 
        return 0;
}
 
static int dns_packet_read_type_window(DnsPacket *p, Bitmap **types, size_t *start) {
        assert(p);
        assert(types);
 
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        uint8_t window, length;
        const uint8_t *bitmap;
        uint8_t bit = 0;
        bool found = false;
        int r;
 
        r = bitmap_ensure_allocated(types);
        if (r < 0)
                return r;
 
        r = dns_packet_read_uint8(p, &window, NULL);
        if (r < 0)
                return r;
 
        r = dns_packet_read_uint8(p, &length, NULL);
        if (r < 0)
                return r;
 
        if (length == 0 || length > 32)
                return -EBADMSG;
 
        r = dns_packet_read(p, length, (const void **)&bitmap, NULL);
        if (r < 0)
                return r;
 
        for (uint8_t i = 0; i < length; i++) {
                uint8_t bitmask = 1 << 7;
 
                if (!bitmap[i]) {
                        found = false;
                        bit += 8;
                        continue;
                }
 
                found = true;
 
                for (; bitmask; bit++, bitmask >>= 1)
                        if (bitmap[i] & bitmask) {
                                uint16_t n;
 
                                n = (uint16_t) window << 8 | (uint16_t) bit;
 
                                /* Ignore pseudo-types. see RFC4034 section 4.1.2 */
                                if (dns_type_is_pseudo(n))
                                        continue;
 
                                r = bitmap_set(*types, n);
                                if (r < 0)
                                        return r;
                        }
        }
 
        if (!found)
                return -EBADMSG;
 
        if (start)
                *start = rewinder.saved_rindex;
        CANCEL_REWINDER(rewinder);
 
        return 0;
}
 
static int dns_packet_read_type_windows(DnsPacket *p, Bitmap **types, size_t size, size_t *start) {
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        int r;
 
        while (p->rindex - rewinder.saved_rindex < size) {
                r = dns_packet_read_type_window(p, types, NULL);
                if (r < 0)
                        return r;
 
                assert(p->rindex >= rewinder.saved_rindex);
 
                /* don't read past end of current RR */
                if (p->rindex - rewinder.saved_rindex > size)
                        return -EBADMSG;
        }
 
        if (p->rindex - rewinder.saved_rindex != size)
                return -EBADMSG;
 
        if (start)
                *start = rewinder.saved_rindex;
        CANCEL_REWINDER(rewinder);
 
        return 0;
}
 
int dns_packet_read_key(
                DnsPacket *p,
                DnsResourceKey **ret,
                bool *ret_cache_flush_or_qu,
                size_t *ret_start) {
 
        assert(p);
 
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        _cleanup_free_ char *name = NULL;
        bool cache_flush_or_qu = false;
        uint16_t class, type;
        int r;
 
        r = dns_packet_read_name(p, &name, true, NULL);
        if (r < 0)
                return r;
 
        r = dns_packet_read_uint16(p, &type, NULL);
        if (r < 0)
                return r;
 
        r = dns_packet_read_uint16(p, &class, NULL);
        if (r < 0)
                return r;
 
        if (p->protocol == DNS_PROTOCOL_MDNS) {
                /* See RFC6762, sections 5.4 and 10.2 */
 
                if (type != DNS_TYPE_OPT && (class & MDNS_RR_CACHE_FLUSH_OR_QU)) {
                        class &= ~MDNS_RR_CACHE_FLUSH_OR_QU;
                        cache_flush_or_qu = true;
                }
        }
 
        if (ret) {
                DnsResourceKey *key;
 
                key = dns_resource_key_new_consume(class, type, name);
                if (!key)
                        return -ENOMEM;
 
                TAKE_PTR(name);
                *ret = key;
        }
 
        if (ret_cache_flush_or_qu)
                *ret_cache_flush_or_qu = cache_flush_or_qu;
        if (ret_start)
                *ret_start = rewinder.saved_rindex;
 
        CANCEL_REWINDER(rewinder);
        return 0;
}
 
static bool loc_size_ok(uint8_t size) {
        uint8_t m = size >> 4, e = size & 0xF;
 
        return m <= 9 && e <= 9 && (m > 0 || e == 0);
}
 
static bool dns_svc_param_is_valid(DnsSvcParam *i) {
        if (!i)
                return false;
 
        switch (i->key) {
        /* RFC 9460, section 7.1.1: alpn-ids must exactly fill SvcParamValue */
        case DNS_SVC_PARAM_KEY_ALPN: {
                size_t sz = 0;
                if (i->length <= 0)
                        return false;
                while (sz < i->length)
                        sz += 1 + i->value[sz]; /* N.B. will not overflow */
                return sz == i->length;
        }
 
        /* RFC 9460, section 7.1.1: value must be empty */
        case DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN:
                return i->length == 0;
 
        /* RFC 9460, section 7.2 */
        case DNS_SVC_PARAM_KEY_PORT:
                return i->length == 2;
 
        /* RFC 9460, section 7.3: addrs must exactly fill SvcParamValue */
        case DNS_SVC_PARAM_KEY_IPV4HINT:
                return i->length > 0 && i->length % (sizeof (struct in_addr)) == 0;
        case DNS_SVC_PARAM_KEY_IPV6HINT:
                return i->length > 0 && i->length % (sizeof (struct in6_addr)) == 0;
 
        /* Otherwise, permit any value */
        default:
                return true;
        }
}
 
int dns_packet_read_rr(
                DnsPacket *p,
                DnsResourceRecord **ret,
                bool *ret_cache_flush,
                size_t *ret_start) {
 
        assert(p);
 
        _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        size_t offset;
        uint16_t rdlength;
        bool cache_flush;
        int r;
 
        r = dns_packet_read_key(p, &key, &cache_flush, NULL);
        if (r < 0)
                return r;
 
        if (!dns_class_is_valid_rr(key->class) || !dns_type_is_valid_rr(key->type))
                return -EBADMSG;
 
        rr = dns_resource_record_new(key);
        if (!rr)
                return -ENOMEM;
 
        r = dns_packet_read_uint32(p, &rr->ttl, NULL);
        if (r < 0)
                return r;
 
        /* RFC 2181, Section 8, suggests to treat a TTL with the MSB set as a zero TTL. We avoid doing this
         * for OPT records so that all 8 bits of the extended RCODE may be used. */
        if (key->type != DNS_TYPE_OPT && rr->ttl & UINT32_C(0x80000000))
                rr->ttl = 0;
 
        r = dns_packet_read_uint16(p, &rdlength, NULL);
        if (r < 0)
                return r;
 
        if (rdlength > p->size - p->rindex)