HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/resolve/test-dns-packet-append.c
Git blob: 8a27fd3b9825f030e09a5b453a243da4229301f0
Lines 1–1000 of 1,783
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "dns-answer.h"
#include "dns-def.h"
#include "dns-packet.h"
#include "dns-question.h"
#include "dns-rr.h"
#include "dns-type.h"
#include "hashmap.h"
#include "list.h"
#include "log.h"
#include "stdio-util.h"
#include "tests.h"
#include "unaligned.h"
#define BIT_QR (1 << 7)
#define BIT_AA (1 << 2)
#define BIT_TC (1 << 1)
#define BIT_RD (1 << 0)
#define BIT_RA (1 << 7)
#define BIT_AD (1 << 5)
#define BIT_CD (1 << 4)
/* ================================================================
* dns_packet_set_flags()
* ================================================================ */
TEST(packet_set_flags_dns_checking_enabled) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ false, /* truncated= */ false);
ASSERT_EQ(DNS_PACKET_QR(packet), 0);
ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
ASSERT_EQ(DNS_PACKET_AA(packet), 0);
ASSERT_EQ(DNS_PACKET_TC(packet), 0);
ASSERT_EQ(DNS_PACKET_RD(packet), 1);
ASSERT_EQ(DNS_PACKET_RA(packet), 0);
ASSERT_EQ(DNS_PACKET_AD(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 0);
ASSERT_EQ(dns_packet_rcode(packet), 0);
}
TEST(packet_set_flags_dns_checking_disabled) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ false);
ASSERT_EQ(DNS_PACKET_QR(packet), 0);
ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
ASSERT_EQ(DNS_PACKET_AA(packet), 0);
ASSERT_EQ(DNS_PACKET_TC(packet), 0);
ASSERT_EQ(DNS_PACKET_RD(packet), 1);
ASSERT_EQ(DNS_PACKET_RA(packet), 0);
ASSERT_EQ(DNS_PACKET_AD(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 1);
ASSERT_EQ(dns_packet_rcode(packet), 0);
}
TEST(packet_set_flags_llmnr) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_LLMNR, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ false);
ASSERT_EQ(DNS_PACKET_QR(packet), 0);
ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
ASSERT_EQ(DNS_PACKET_AA(packet), 0);
ASSERT_EQ(DNS_PACKET_TC(packet), 0);
ASSERT_EQ(DNS_PACKET_RD(packet), 0);
ASSERT_EQ(DNS_PACKET_RA(packet), 0);
ASSERT_EQ(DNS_PACKET_AD(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 0);
ASSERT_EQ(dns_packet_rcode(packet), 0);
}
TEST(packet_set_flags_mdns_not_truncated) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ false);
ASSERT_EQ(DNS_PACKET_QR(packet), 0);
ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
ASSERT_EQ(DNS_PACKET_AA(packet), 0);
ASSERT_EQ(DNS_PACKET_TC(packet), 0);
ASSERT_EQ(DNS_PACKET_RD(packet), 0);
ASSERT_EQ(DNS_PACKET_RA(packet), 0);
ASSERT_EQ(DNS_PACKET_AD(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 0);
ASSERT_EQ(dns_packet_rcode(packet), 0);
}
TEST(packet_set_flags_mdns_truncated) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ true);
ASSERT_EQ(DNS_PACKET_QR(packet), 0);
ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
ASSERT_EQ(DNS_PACKET_AA(packet), 0);
ASSERT_EQ(DNS_PACKET_TC(packet), 1);
ASSERT_EQ(DNS_PACKET_RD(packet), 0);
ASSERT_EQ(DNS_PACKET_RA(packet), 0);
ASSERT_EQ(DNS_PACKET_AD(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 0);
ASSERT_EQ(dns_packet_rcode(packet), 0);
}
/* ================================================================
* dns_packet_new_query()
* ================================================================ */
TEST(packet_new_query_checking_enabled) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new_query(&packet, DNS_PROTOCOL_DNS, 0, false));
ASSERT_NOT_NULL(packet);
ASSERT_EQ(DNS_PACKET_TC(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 0);
}
TEST(packet_new_query_checking_disabled) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new_query(&packet, DNS_PROTOCOL_DNS, 0, true));
ASSERT_NOT_NULL(packet);
ASSERT_EQ(DNS_PACKET_TC(packet), 0);
ASSERT_EQ(DNS_PACKET_CD(packet), 1);
}
/* ================================================================
* dns_packet_append_key()
* ================================================================ */
TEST(packet_append_key_single_a) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
dns_resource_key_unref(key);
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x03, 'w', 'w', 'w',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_key_single_soa_any_class) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_ANY, DNS_TYPE_SOA, "www.example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
dns_resource_key_unref(key);
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x03, 'w', 'w', 'w',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SOA */ 0x00, 0x06,
/* ANY */ 0x00, 0xff
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_key_cache_flush_mdns) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 0, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.local");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, DNS_ANSWER_CACHE_FLUSH, NULL));
dns_resource_key_unref(key);
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x05, 'l', 'o', 'c', 'a', 'l',
0x00,
/* A */ 0x00, 0x01,
/* IN + cache-flush */
0x80, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* The cache-flush bit is defined for mDNS only. RRs taken from our mDNS zone carry
* DNS_ANSWER_CACHE_FLUSH, but when they are sent out via the DNS stub the bit must not end up in the
* CLASS field, where it would be parsed as class 32769. See RFC 6762, section 10.2. */
TEST(packet_append_key_cache_flush_dns) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 0, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.local");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, DNS_ANSWER_CACHE_FLUSH, NULL));
dns_resource_key_unref(key);
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x05, 'l', 'o', 'c', 'a', 'l',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* mDNS probes carry the proposed RRs from our mDNS zone in the Authority Section. Those items carry
* DNS_ANSWER_CACHE_FLUSH, but the cache-flush bit is only set in responses, never in queries. See RFC 6762,
* sections 8.2 and 10.2. */
TEST(packet_append_key_cache_flush_mdns_query) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 0, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->nscount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.local");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, DNS_ANSWER_CACHE_FLUSH, NULL));
dns_resource_key_unref(key);
const uint8_t data[] = {
0x00, 0x00, 0x00, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x05, 'l', 'o', 'c', 'a', 'l',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* ================================================================
* dns_packet_append_question()
* ================================================================ */
TEST(packet_append_question_compression) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
DnsResourceKey *key = NULL;
question = dns_question_new(3);
ASSERT_NOT_NULL(question);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_question_add(question, key, 0));
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_MX, "mail.example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_question_add(question, key, 0));
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_SOA, "host.mail.example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_question_add(question, key, 0));
dns_resource_key_unref(key);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->qdcount = htobe16(dns_question_size(question));
ASSERT_OK(dns_packet_append_question(packet, question));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x03, 'w', 'w', 'w',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* name */ 0x04, 'm', 'a', 'i', 'l',
0xc0, 0x10,
/* MX */ 0x00, 0x0f,
/* IN */ 0x00, 0x01,
/* name */ 0x04, 'h', 'o', 's', 't',
0xc0, 0x21,
/* SOA */ 0x00, 0x06,
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* ================================================================
* dns_packet_append_opt()
* ================================================================ */
TEST(packet_append_opt_basic) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x02, 0x00,
/* rcode */ 0x00,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_opt_change_max_udp) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_OK(dns_packet_append_opt(packet, 4100, false, false, NULL, 0, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x10, 0x04,
/* rcode */ 0x00,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_opt_dnssec_ok) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_OK(dns_packet_append_opt(packet, 512, true, false, NULL, 0, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x02, 0x00,
/* rcode */ 0x00,
/* version */ 0x00,
/* flags */ 0x80, 0x00,
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_opt_rcode) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0x97a, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x02, 0x00,
/* rcode */ 0x97,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_opt_nsid) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, "nsid.example.com", 0, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x02, 0x00,
/* rcode */ 0x00,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 0x00, 0x14,
0x00, 0x03,
0x00, 0x10,
'n', 's', 'i', 'd', '.', 'e', 'x', 'a',
'm', 'p', 'l', 'e', '.', 'c', 'o', 'm'
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_key_and_opt) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x02, 0x00,
/* rcode */ 0x00,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_truncate_opt) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
ASSERT_TRUE(dns_packet_truncate_opt(packet));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* ================================================================
* dns_packet_patch_max_udp_size()
* ================================================================ */
TEST(packet_patch_max_udp_size) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
ASSERT_TRUE(dns_packet_patch_max_udp_size(packet, 4097));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* root */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x10, 0x01,
/* rcode */ 0x00,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_patch_max_udp_size_no_opt) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
ASSERT_FALSE(dns_packet_patch_max_udp_size(packet, 4097));
const uint8_t data[] = {
0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* ================================================================
* dns_packet_dup()
* ================================================================ */
TEST(packet_dup) {
_cleanup_(dns_packet_unrefp) DnsPacket *p1 = NULL, *p2 = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&p1, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(p1);
DNS_PACKET_ID(p1) = htobe16(42);
DNS_PACKET_HEADER(p1)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(p1)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(p1, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x11,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
ASSERT_OK(dns_packet_dup(&p2, p1));
ASSERT_NOT_NULL(p2);
ASSERT_EQ(p2->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(p2), data, sizeof(data)), 0);
}
/* ================================================================
* dns_packet_append_answer()
* ================================================================ */
TEST(packet_append_answer_single_a) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x11,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_answer_single_ns) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NS, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->ns.name = strdup("ns1.example.com");
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* NS */ 0x00, 0x02,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x11,
/* rdata */ 0x00, 0x06,
/* name */ 0x03, 'n', 's', '1',
0xc0, 0x0c
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_answer_single_cname) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_CNAME, "www.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->cname.name = strdup("example.com");
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x03, 'w', 'w', 'w',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* CNAME */ 0x00, 0x05,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x11,
/* rdata */ 0x00, 0x02,
/* name */ 0xc0, 0x10
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_answer_single_hinfo) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_HINFO, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->hinfo.cpu = strdup("x64");
rr->hinfo.os = strdup("GNU/Linux");
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* HINFO */ 0x00, 0x0d,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x11,
/* rdata */ 0x00, 0x0e,
/* cpu */ 0x03, 'x', '6', '4',
/* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_answer_single_ptr) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_PTR, "127.1.168.192.in-addr.arpa");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->ptr.name = strdup("example.com");
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x03, '1', '2', '7',
0x01, '1',
0x03, '1', '6', '8',
0x03, '1', '9', '2',
0x07, 'i', 'n', '-', 'a', 'd', 'd', 'r',
0x04, 'a', 'r', 'p', 'a',
0x00,
/* PTR */ 0x00, 0x0c,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x11,
/* rdata */ 0x00, 0x0d,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
/* Reverse lookups for link-local addresses are answered from resolved's own mDNS zone, whose answer
* items carry DNS_ANSWER_CACHE_FLUSH. When such an RR is handed to a client of the DNS stub the
* cache-flush bit must be dropped, otherwise the client sees CLASS32769 instead of IN. */
TEST(packet_append_answer_single_ptr_ip6_cache_flush) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_PTR,
"1.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.8.e.f.ip6.arpa");
ASSERT_NOT_NULL(rr);
rr->ttl = 120;
rr->ptr.name = strdup("example.local");
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, DNS_ANSWER_CACHE_FLUSH, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x01, '1', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0',
0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0',
0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0',
0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '0', 0x01, '8', 0x01, 'e', 0x01, 'f',
0x03, 'i', 'p', '6',
0x04, 'a', 'r', 'p', 'a',
0x00,
/* PTR */ 0x00, 0x0c,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x00, 0x78,
/* rdata */ 0x00, 0x0f,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x05, 'l', 'o', 'c', 'a', 'l',
0x00
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(packet_append_answer_single_mx) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
_cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
DnsResourceRecord *rr = NULL;
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_MX, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3601;
rr->mx.priority = 9;
rr->mx.exchange = strdup("mail.example.com");
answer = dns_answer_new(1);
ASSERT_NOT_NULL(answer);
dns_answer_add(answer, rr, 1, 0, NULL);
dns_resource_record_unref(rr);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
DNS_PACKET_ID(packet) = htobe16(42);
DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));