HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/resolve/test-dns-packet-extract.c
Git blob: 2c053c299f792d2a2ea4822d20b93e55764e9d0b
Lines 4001–4963 of 4,963
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x14,
/* priority */ 0x00, 0x00,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_OK(dns_packet_extract(packet));
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 1u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "sock.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->svcb.priority = 0;
rr->svcb.target_name = strdup("sock.example.com");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
dns_resource_record_unref(rr);
}
/* RFC 9460 says that recipients MUST ignore any params presented in alias mode RRs. We parse them out of the
* message and their handling is down to further business logic, rather than rejecting such RRs in the
* parser. */
TEST(packet_reply_svcb_alias_mode_with_param) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceRecord *rr = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x18,
/* priority */ 0x00, 0x00,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* no-deflt */ 0x00, 0x02,
0x00, 0x00,
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_OK(dns_packet_extract(packet));
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 1u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "_443._wss.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->svcb.priority = 0;
rr->svcb.target_name = strdup("sock.example.com");
add_svcb_param(rr, DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN, NULL, 0);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
dns_resource_record_unref(rr);
}
TEST(packet_reply_svcb_service_mode) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceRecord *rr = NULL;
DnsSvcParam *param = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x54,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* mandatory */ 0x00, 0x00,
0x00, 0x04,
0x00, 0x01, 0x00, 0x03,
/* alpn */ 0x00, 0x01,
0x00, 0x0a,
0x09, 'w', 'e', 'b', 's', 'o', 'c', 'k', 'e', 't',
/* no-deflt */ 0x00, 0x02,
0x00, 0x00,
/* port */ 0x00, 0x03,
0x00, 0x02,
0x01, 0xbb,
/* ipv4hint */ 0x00, 0x04,
0x00, 0x08,
0x72, 0x84, 0xfd, 0x3a,
0x48, 0xbc, 0xc7, 0xc0,
/* ipv6hint */ 0x00, 0x06,
0x00, 0x10,
0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35,
0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_OK(dns_packet_extract(packet));
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 1u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "_443._wss.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->svcb.priority = 2;
rr->svcb.target_name = strdup("sock.example.com");
add_svcb_param(rr, DNS_SVC_PARAM_KEY_MANDATORY, "\x00\x01\x00\x03", 4);
add_svcb_param(rr, DNS_SVC_PARAM_KEY_ALPN, "\x09websocket", 10);
add_svcb_param(rr, DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN, "", 0);
add_svcb_param(rr, DNS_SVC_PARAM_KEY_PORT, "\x01\xbb", 2);
param = add_svcb_param(rr, DNS_SVC_PARAM_KEY_IPV4HINT, NULL, 2 * sizeof(struct in_addr));
param->value_in_addr[0].s_addr = htobe32(0x7284fd3a);
param->value_in_addr[1].s_addr = htobe32(0x48bcc7c0);
param = add_svcb_param(rr, DNS_SVC_PARAM_KEY_IPV6HINT, NULL, sizeof(struct in6_addr));
param->value_in6_addr[0] = (struct in6_addr) { .s6_addr = { 0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35, 0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb } };
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
dns_resource_record_unref(rr);
}
/* RFC 9460 says that clients MUST ignore any param keys that they do not recognise. We allow such keys to be
* parsed; handling of them is down to later business logic. */
TEST(packet_reply_svcb_service_mode_unknown_param) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceRecord *rr = NULL;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* HTTPS */ 0x00, 0x41,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x18,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* unknown */ 0x00, 0x99,
0x00, 0x00
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_OK(dns_packet_extract(packet));
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 1u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_HTTPS, "_443._wss.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->svcb.priority = 2;
rr->svcb.target_name = strdup("sock.example.com");
add_svcb_param(rr, 153, NULL, 0);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
dns_resource_record_unref(rr);
}
TEST(packet_reply_svcb_service_mode_duplicate_key) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x20,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* port */ 0x00, 0x03,
0x00, 0x02,
0x01, 0xbb,
/* port */ 0x00, 0x03,
0x00, 0x02,
0x01, 0xbc,
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_key_bad_order) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x1e,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* port */ 0x00, 0x03,
0x00, 0x02,
0x01, 0xbb,
/* no-deflt */ 0x00, 0x02,
0x00, 0x00
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_alpn_too_long) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x20,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* alpn */ 0x00, 0x01,
0x00, 0x07,
0x04, 'h', 't', 't', 'p',
0x02, 'w', 's'
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_alpn_too_short) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x20,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* alpn */ 0x00, 0x01,
0x00, 0x09,
0x04, 'h', 't', 't', 'p',
0x02, 'w', 's'
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EMSGSIZE);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_valid_alpn_overflows_rdata) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x1f,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* alpn */ 0x00, 0x01,
0x00, 0x08,
0x04, 'h', 't', 't', 'p',
0x02, 'w', 's'
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_valid_alpn_and_port_overflows_rdata) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x25,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* alpn */ 0x00, 0x01,
0x00, 0x08,
0x04, 'h', 't', 't', 'p',
0x02, 'w', 's',
/* port */ 0x00, 0x03,
0x00, 0x02,
0x01, 0xbb
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_bad_no_default_alpn) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x19,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* no-deflt */ 0x00, 0x02,
0x00, 0x01,
0x0a
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_port_too_long) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x1b,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* port */ 0x00, 0x03,
0x00, 0x03,
0x01, 0xbb, 0xff
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_port_too_short) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x19,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* port */ 0x00, 0x03,
0x00, 0x01,
0xbb
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_bad_ipv4hint) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x1b,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* ipv4hint */ 0x00, 0x04,
0x00, 0x03,
0x2f, 0x47, 0x34
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
TEST(packet_reply_svcb_service_mode_bad_ipv6hint) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x04, '_', '4', '4', '3',
0x04, '_', 'w', 's', 's',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SVCB */ 0x00, 0x40,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x27,
/* priority */ 0x00, 0x02,
/* target */ 0x04, 's', 'o', 'c', 'k',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* ipv6hint */ 0x00, 0x06,
0x00, 0x0f,
0x09, 0x36, 0xba, 0x5d, 0x17, 0x42, 0x47, 0xa2,
0x14, 0xcc, 0x77, 0x67, 0x51, 0x68, 0xef
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
ASSERT_EQ(dns_question_size(packet->question), 0u);
ASSERT_EQ(dns_answer_size(packet->answer), 0u);
}
/* ================================================================
* dns_packet_equal()
* ================================================================ */
TEST(packet_equal_match) {
_cleanup_(dns_packet_unrefp) DnsPacket *p1 = NULL, *p2 = NULL;
ASSERT_OK(dns_packet_new(&p1, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(p1);
dns_packet_truncate(p1, 0);
ASSERT_OK(dns_packet_new(&p2, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(p2);
dns_packet_truncate(p2, 0);
const uint8_t data[] = {
0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
};
ASSERT_OK(dns_packet_append_blob(p1, data, sizeof(data), NULL));
ASSERT_OK(dns_packet_append_blob(p2, data, sizeof(data), NULL));
ASSERT_TRUE(dns_packet_equal(p1, p2));
}
TEST(packet_equal_no_match) {
_cleanup_(dns_packet_unrefp) DnsPacket *p1 = NULL, *p2 = NULL;
ASSERT_OK(dns_packet_new(&p1, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(p1);
dns_packet_truncate(p1, 0);
const uint8_t data1[] = {
0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
};
ASSERT_OK(dns_packet_append_blob(p1, data1, sizeof(data1), NULL));
ASSERT_OK(dns_packet_new(&p2, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(p2);
dns_packet_truncate(p2, 0);
const uint8_t data2[] = {
0x00, 0x2a, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01
};
ASSERT_OK(dns_packet_append_blob(p2, data2, sizeof(data2), NULL));
ASSERT_FALSE(dns_packet_equal(p1, p2));
}
/* ================================================================
* dns_ede_rcode_is_dnssec()
* ================================================================ */
TEST(dns_ede_rcode_is_dnssec) {
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_UNSUPPORTED_DNSKEY_ALG));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_UNSUPPORTED_DS_DIGEST));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_DNSSEC_INDETERMINATE));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_DNSSEC_BOGUS));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_SIG_EXPIRED));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_SIG_NOT_YET_VALID));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_DNSKEY_MISSING));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_RRSIG_MISSING));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_NO_ZONE_KEY_BIT));
ASSERT_TRUE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_NSEC_MISSING));
ASSERT_FALSE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_BLOCKED));
ASSERT_FALSE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_CENSORED));
ASSERT_FALSE(dns_ede_rcode_is_dnssec(DNS_EDE_RCODE_OTHER));
}
/* ================================================================
* format_dns_rcode()
* ================================================================ */
TEST(format_dns_rcode) {
const char *str;
str = FORMAT_DNS_RCODE(DNS_RCODE_SUCCESS);
ASSERT_STREQ(str, "SUCCESS");
str = FORMAT_DNS_RCODE(DNS_RCODE_NXDOMAIN);
ASSERT_STREQ(str, "NXDOMAIN");
str = FORMAT_DNS_RCODE(DNS_RCODE_SERVFAIL);
ASSERT_STREQ(str, "SERVFAIL");
str = FORMAT_DNS_RCODE(DNS_RCODE_REFUSED);
ASSERT_STREQ(str, "REFUSED");
str = FORMAT_DNS_RCODE(DNS_RCODE_BADTIME);
ASSERT_STREQ(str, "BADTIME");
}
/* ================================================================
* format_dns_ede_rcode()
* ================================================================ */
TEST(format_dns_ede_rcode) {
const char *str;
str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_DNSSEC_BOGUS);
ASSERT_STREQ(str, "DNSSEC Bogus");
str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_SIG_EXPIRED);
ASSERT_STREQ(str, "Signature Expired");
str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_CENSORED);
ASSERT_STREQ(str, "Censored");
str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_OTHER);
ASSERT_STREQ(str, "Other");
str = FORMAT_DNS_EDE_RCODE(DNS_EDE_RCODE_STALE_NXDOMAIN_ANSWER);
ASSERT_STREQ(str, "Stale NXDOMAIN Answer");
}
/* ================================================================
* format_dns_svc_param_key()
* ================================================================ */
TEST(format_dns_svc_param_key) {
const char *str;
str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_ALPN);
ASSERT_STREQ(str, "alpn");
str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN);
ASSERT_STREQ(str, "no-default-alpn");
str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_PORT);
ASSERT_STREQ(str, "port");
str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_IPV4HINT);
ASSERT_STREQ(str, "ipv4hint");
str = FORMAT_DNS_SVC_PARAM_KEY(DNS_SVC_PARAM_KEY_OHTTP);
ASSERT_STREQ(str, "ohttp");
}
TEST(overlong_domain) {
_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_truncate(packet, 0);
const uint8_t data[] = {
0x00, 0x42, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
0x00,
0x00, DNS_TYPE_A,
0x00, DNS_CLASS_IN,
};
ASSERT_OK(dns_packet_append_blob(packet, data, sizeof(data), NULL));
ASSERT_OK(dns_packet_validate_query(packet));
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
ASSERT_ERROR(dns_packet_read_key(packet, &key, NULL, NULL), EBADMSG);
const uint8_t data2[] = {
0x00, 0x42, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
62, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1',
0x00,
0x00, DNS_TYPE_A,
0x00, DNS_CLASS_IN,
};
packet = dns_packet_unref(packet);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_truncate(packet, 0);
ASSERT_OK(dns_packet_append_blob(packet, data2, sizeof(data2), NULL));
ASSERT_OK(dns_packet_validate_query(packet));
ASSERT_ERROR(dns_packet_read_key(packet, &key, NULL, NULL), EBADMSG);
const uint8_t data3[] = {
0x00, 0x42, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
63, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2',
61, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
0x00,
0x00, DNS_TYPE_A,
0x00, DNS_CLASS_IN,
};
packet = dns_packet_unref(packet);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
dns_packet_truncate(packet, 0);
ASSERT_OK(dns_packet_append_blob(packet, data3, sizeof(data3), NULL));
ASSERT_OK(dns_packet_validate_query(packet));
ASSERT_OK(dns_packet_read_key(packet, &key, NULL, NULL));
ASSERT_STREQ(dns_resource_key_name(key),
"012345678901234567890123456789012345678901234567890123456789012."
"012345678901234567890123456789012345678901234567890123456789012."
"012345678901234567890123456789012345678901234567890123456789012."
"0123456789012345678901234567890123456789012345678901234567890");
}
/* ================================================================
* compression-pointer decompression limits
* ================================================================ */
/* Build a response whose first record stores a staircase of strictly descending compression pointers
* as opaque RDATA, and whose remaining records each own a name that points at the head of that
* staircase */
static size_t append_pointer_staircase(DnsPacket *packet, size_t staircase_pointers, size_t names) {
_cleanup_free_ uint8_t *buf = NULL;
size_t rdata_base, rdlength, head = 0, ancount, total, off;
assert(packet);
assert(!packet->extracted);
assert(staircase_pointers > 0);
/* Absolute offset where record 1's RDATA begins:
* header(12) + name(1, root) + type(2) + class(2) + ttl(4) + rdlength(2) */
rdata_base = DNS_PACKET_HEADER_SIZE + 1 + 10;
ASSERT_LE(rdata_base + 2 * staircase_pointers, (size_t) DNS_COMPRESSION_OFFSET_MAX);
/* RDATA holds a root-label terminator, a pad byte, then the pointer staircase */
rdlength = 2 + 2 * staircase_pointers;
ancount = 1 + names;
total = rdata_base + rdlength + names * (2 + 10);
ASSERT_LE(total, (size_t) DNS_PACKET_SIZE_MAX);
ASSERT_NOT_NULL(buf = malloc0(total));
/* Header: response, QDCOUNT=0, ANCOUNT=ancount. */
buf[2] = BIT_QR | BIT_RD;
buf[3] = BIT_RA | DNS_RCODE_SUCCESS;
buf[6] = (uint8_t) (ancount >> 8);
buf[7] = (uint8_t) ancount;
off = DNS_PACKET_HEADER_SIZE;
buf[off++] = 0x00; /* record 1 name = root */
buf[off++] = 0xff; buf[off++] = 0x00; /* type = 65280 (private use, opaque RDATA) */
buf[off++] = 0x00; buf[off++] = 0x01; /* class = IN */
off += 4; /* ttl = 0 */
buf[off++] = (uint8_t) (rdlength >> 8);
buf[off++] = (uint8_t) rdlength;
/* Build a pointer staircase with a chain of pointers that all reference each other all the
* way back to the root-label terminator */
ASSERT_EQ(off, rdata_base);
buf[off] = 0x00; /* rdata[0]: root-label chain terminator */
for (size_t cursor = 2; cursor + 1 < rdlength; cursor += 2) {
size_t target = rdata_base + cursor - 2; /* previous slot in the staircase */
buf[off + cursor] = (uint8_t) (0xc0 | (target >> 8));
buf[off + cursor + 1] = (uint8_t) (target & 0xff);
head = rdata_base + cursor; /* highest (last) pointer is the chain head */
}
off += rdlength;
/* Add a bunch of names that all point to the pointer staircase we just created */
for (size_t i = 0; i < names; i++) {
buf[off++] = (uint8_t) (0xc0 | (head >> 8)); /* name = pointer to staircase head */
buf[off++] = (uint8_t) (head & 0xff);
buf[off++] = 0xff; buf[off++] = 0x00; /* type = 65280 */
buf[off++] = 0x00; buf[off++] = 0x01; /* class = IN */
off += 4; /* ttl = 0 */
off += 2; /* rdlength = 0 */
}
ASSERT_EQ(off, total);
/* dns_packet_new() bumps the returned packet's internal size to DNS_PACKET_HEADER_SIZE on
* initialization, but here we try to append a complete packet (with our own header) to it, so let's
* truncate it to 0 before doing so, so our new header is at the start of the packet */
dns_packet_truncate(packet, 0);
ASSERT_OK(dns_packet_append_blob(packet, buf, total, NULL));
ASSERT_EQ(packet->size, total);
return total;
}
/* A single name that walks the pointer staircase past the DNS_COMPRESSION_JUMPS_MAX limit */
TEST(compression_pointer_chain_exceeds_per_name_cap) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
size_t total;
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
total = append_pointer_staircase(packet, DNS_COMPRESSION_JUMPS_MAX + 50, 1);
ASSERT_GE(total, DNS_COMPRESSION_JUMPS_MAX + 1);
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
}
/* A chain exactly at the per-name limit is fine; a chain one pointer longer should be rejected */
TEST(compression_pointer_chain_per_name_cap_boundary) {
_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);
/* Exactly at the per-name limit */
append_pointer_staircase(packet, DNS_COMPRESSION_JUMPS_MAX - 1, 1);
ASSERT_OK(dns_packet_extract(packet));
ASSERT_EQ(dns_answer_size(packet->answer), 2u);
ASSERT_OK(dns_packet_patch_ttls(packet, now(CLOCK_BOOTTIME)));
packet = dns_packet_unref(packet);
ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
ASSERT_NOT_NULL(packet);
/* One pointer past the per-name limit */
append_pointer_staircase(packet, DNS_COMPRESSION_JUMPS_MAX, 1);
ASSERT_ERROR(dns_packet_extract(packet), EBADMSG);
}
DEFINE_TEST_MAIN(LOG_DEBUG)