HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/resolve/test-dns-packet-extract.c
Git blob: 2c053c299f792d2a2ea4822d20b93e55764e9d0b
Lines 2001–3000 of 4,963
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_cname_uncompressed) {
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x02, 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 */ 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, 0x10,
/* rdata */ 0x00, 0x0d,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
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, 0x10,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
check_cname_reply_compression(data, sizeof(data));
}
TEST(packet_reply_cname_partial_compression) {
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x02, 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 */ 0x03, 'w', 'w', 'w',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0xc0, 0x18,
/* CNAME */ 0x00, 0x05,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x02,
/* name */ 0xc0, 0x25,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0xc0, 0x2d,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
check_cname_reply_compression(data, sizeof(data));
}
TEST(packet_reply_cname_full_compression) {
const uint8_t data[] = {
0x00, 0x42, BIT_QR | BIT_AA, DNS_RCODE_SUCCESS,
0x00, 0x01, 0x00, 0x02, 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 */ 0xc0, 0x0c,
/* CNAME */ 0x00, 0x05,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x02,
/* name */ 0xc0, 0x10,
/* name */ 0xc0, 0x10,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
check_cname_reply_compression(data, sizeof(data));
}
/* ================================================================
* reply: SOA
* ================================================================ */
TEST(packet_reply_soa_basic) {
_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_NXDOMAIN,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SOA */ 0x00, 0x06,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x27,
/* mname */ 0x03, 'n', 's', '0',
0xc0, 0x0c,
/* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
0xc0, 0x0c,
/* serial */ 0x78, 0x85, 0x75, 0x2e,
/* refresh */ 0x00, 0x02, 0xa3, 0x00,
/* retry */ 0x00, 0x00, 0x00, 0xb4,
/* expire */ 0x00, 0x24, 0xea, 0x00,
/* minimum */ 0x00, 0x00, 0x00, 0x3c
};
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_SOA, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->soa.mname = strdup("ns0.example.com");
rr->soa.rname = strdup("hostmaster.example.com");
rr->soa.serial = 2022012206;
rr->soa.refresh = 172800;
rr->soa.retry = 180;
rr->soa.expire = 2419200;
rr->soa.minimum = 60;
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_AUTHORITY);
dns_resource_record_unref(rr);
}
TEST(packet_reply_soa_rdata_overflow) {
_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_NXDOMAIN,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SOA */ 0x00, 0x06,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x26,
/* mname */ 0x03, 'n', 's', '0',
0xc0, 0x0c,
/* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
0xc0, 0x0c,
/* serial */ 0x78, 0x85, 0x75, 0x2e,
/* refresh */ 0x00, 0x02, 0xa3, 0x00,
/* retry */ 0x00, 0x00, 0x00, 0xb4,
/* expire */ 0x00, 0x24, 0xea, 0x00,
/* minimum */ 0x00, 0x00, 0x00, 0x3c
};
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_soa_rdata_underminated_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, BIT_QR | BIT_AA, DNS_RCODE_NXDOMAIN,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SOA */ 0x00, 0x06,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x31,
/* mname */ 0x03, 'n', 's', '0',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
/* missing 0x00 */
/* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
0xc0, 0x0c,
/* serial */ 0x78, 0x85, 0x75, 0x2e,
/* refresh */ 0x00, 0x02, 0xa3, 0x00,
/* retry */ 0x00, 0x00, 0x00, 0xb4,
/* expire */ 0x00, 0x24, 0xea, 0x00,
/* minimum */ 0x00, 0x00, 0x00, 0x3c
};
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_soa_rdata_missing_field) {
_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_NXDOMAIN,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SOA */ 0x00, 0x06,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x23,
/* mname */ 0x03, 'n', 's', '0',
0xc0, 0x0c,
/* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
0xc0, 0x0c,
/* serial */ 0x78, 0x85, 0x75, 0x2e,
/* refresh */ 0x00, 0x02, 0xa3, 0x00,
/* retry */ 0x00, 0x00, 0x00, 0xb4,
/* expire */ 0x00, 0x24, 0xea, 0x00
/* minimum (missing) */
};
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_soa_rdata_partial_final_field) {
_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_NXDOMAIN,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SOA */ 0x00, 0x06,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x26,
/* mname */ 0x03, 'n', 's', '0',
0xc0, 0x0c,
/* rname */ 0x0a, 'h', 'o', 's', 't', 'm', 'a', 's', 't', 'e', 'r',
0xc0, 0x0c,
/* serial */ 0x78, 0x85, 0x75, 0x2e,
/* refresh */ 0x00, 0x02, 0xa3, 0x00,
/* retry */ 0x00, 0x00, 0x00, 0xb4,
/* expire */ 0x00, 0x24, 0xea, 0x00,
/* minimum */ 0x00, 0x00, 0x00
};
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);
}
/* ================================================================
* reply: HINFO
* ================================================================ */
TEST(packet_reply_hinfo_basic) {
_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, 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, 0x10,
/* rdata */ 0x00, 0x14,
/* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
/* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
};
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_HINFO, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->hinfo.cpu = strdup("Intel x64");
rr->hinfo.os = strdup("GNU/Linux");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_hinfo_overflow) {
_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, 0x01, 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, 0x10,
/* rdata */ 0x00, 0x13,
/* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
/* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
};
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_hinfo_valid_utf8) {
_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, 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, 0x10,
/* rdata */ 0x00, 0x17,
/* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
/* os */ 0x0c, 'G', 'N', 0xf0, 0x9d, 0x95, 0x8c, '/', 'L', 'i', 'n', 'u', 'x'
};
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_HINFO, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->hinfo.cpu = strdup("Intel x64");
rr->hinfo.os = strdup("GN𝕌/Linux");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_hinfo_invalid_utf8) {
_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, 0x01, 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, 0x10,
/* rdata */ 0x00, 0x16,
/* cpu */ 0x09, 'I', 'n', 't', 'e', 'l', ' ', 'x', '6', '4',
/* os */ 0x0b, 'G', 'N', 0xf0, 0x9d, 0x95, '/', 'L', 'i', 'n', 'u', 'x'
};
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);
}
/* ================================================================
* reply: TXT
* ================================================================ */
TEST(packet_reply_txt) {
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceRecord *rr = NULL;
DnsTxtItem *item = 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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* TXT */ 0x00, 0x10,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x09,
0x02, 'h', 'i',
0x05, 'w', 'o', 'r', 'l', 'd'
};
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_TXT, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
item = calloc(1, offsetof(DnsTxtItem, data) + 3);
ASSERT_NOT_NULL(item);
item->length = 2;
memcpy(item->data, "hi", 3);
LIST_APPEND(items, rr->txt.items, item);
item = calloc(1, offsetof(DnsTxtItem, data) + 6);
ASSERT_NOT_NULL(item);
item->length = 5;
memcpy(item->data, "world", 6);
LIST_APPEND(items, rr->txt.items, item);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_txt_empty) {
_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* TXT */ 0x00, 0x10,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 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_TXT, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
dns_txt_item_new_empty(&rr->txt.items);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_txt_overflow_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* TXT */ 0x00, 0x10,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x08,
0x02, 'h', 'i',
0x05, 'w', 'o', 'r', 'l', 'd'
};
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);
}
/* ================================================================
* reply: LOC
* ================================================================ */
TEST(packet_reply_loc_basic) {
_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* LOC */ 0x00, 0x1d,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x10,
/* version */ 0x00,
/* size */ 0x29,
/* horiz pre */ 0x34,
/* vert pre */ 0x53,
/* latitude */ 0x8b, 0x0d, 0x08, 0xf5,
/* longitude */ 0x7f, 0xf8, 0x39, 0x48,
/* altitude */ 0x00, 0x98, 0x96, 0x80
};
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_LOC, "example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->loc.version = 0;
rr->loc.size = 0x29;
rr->loc.horiz_pre = 0x34;
rr->loc.vert_pre = 0x53;
rr->loc.latitude = 2332887285;
rr->loc.longitude = 2146974024;
rr->loc.altitude = 10000000;
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_loc_bad_version) {
_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* LOC */ 0x00, 0x1d,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x10,
/* version */ 0x01,
/* size */ 0x29,
/* horiz pre */ 0x34,
/* vert pre */ 0x53,
/* latitude */ 0x8b, 0x0d, 0x08, 0xf5,
/* longitude */ 0x7f, 0xf8, 0x39, 0x48,
/* altitude */ 0x00, 0x98, 0x96, 0x80
};
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_LOC, "example.com");
ASSERT_NOT_NULL(rr);
rr->unparsable = true;
rr->generic.data_size = 16;
rr->generic.data = calloc(rr->generic.data_size, sizeof(uint8_t));
ASSERT_NOT_NULL(rr->generic.data);
memcpy(rr->generic.data, data + 35, rr->generic.data_size);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
/* ================================================================
* reply: SRV
* ================================================================ */
TEST(packet_reply_srv_with_a) {
_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, 0x01, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x05, '_', 'l', 'd', 'a', 'p',
0x04, '_', 't', 'c', 'p',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SRV */ 0x00, 0x21,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x19,
/* priority */ 0x43, 0x21,
/* weight */ 0x65, 0x78,
/* port */ 0x01, 0x85,
/* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* name */ 0xc0, 0x34,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
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), 2u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SRV, "_ldap._tcp.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->srv.priority = 17185;
rr->srv.weight = 25976;
rr->srv.port = 389;
rr->srv.name = strdup("cloud.example.com");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "cloud.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
dns_resource_record_unref(rr);
}
/* we allow compression of the SRV target field even though RFC 2782 advises against it */
TEST(packet_reply_srv_compression) {
_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, 0x01, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x05, '_', 'l', 'd', 'a', 'p',
0x04, '_', 't', 'c', 'p',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SRV */ 0x00, 0x21,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x0e,
/* priority */ 0x00, 0x0a,
/* weight */ 0x00, 0x05,
/* port */ 0x01, 0x85,
/* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
0xc0, 0x17,
/* name */ 0xc0, 0x34,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x04,
/* ip */ 0xc0, 0xa8, 0x01, 0x7f
};
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), 2u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SRV, "_ldap._tcp.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->srv.priority = 10;
rr->srv.weight = 5;
rr->srv.port = 389;
rr->srv.name = strdup("cloud.example.com");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "cloud.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ADDITIONAL);
dns_resource_record_unref(rr);
}
TEST(packet_reply_srv_allow_non_srv_names) {
_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x03, 'w', 'w', 'w',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* SRV */ 0x00, 0x21,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x0e,
/* priority */ 0x00, 0x0a,
/* weight */ 0x00, 0x05,
/* port */ 0x01, 0x85,
/* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
0xc0, 0x10
};
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_SRV, "www.example.com");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->srv.priority = 10;
rr->srv.weight = 5;
rr->srv.port = 389;
rr->srv.name = strdup("cloud.example.com");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
/* ================================================================
* reply: NAPTR
* ================================================================ */
TEST(packet_reply_naptr_basic) {
_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x01, '4', 0x01, '3', 0x01, '2', 0x01, '1',
0x01, '5', 0x01, '5', 0x01, '5',
0x01, '0', 0x01, '0', 0x01, '8', 0x01, '1',
0x04, 'e', '1', '6', '4',
0x04, 'a', 'r', 'p', 'a',
0x00,
/* NAPTR */ 0x00, 0x23,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x4d,
/* order */ 0x00, 0x66,
/* pref */ 0x00, 0x0a,
/* flags */ 0x01, 'U',
/* services */ 0x07, 'E', '2', 'U', '+', 's', 'i', 'p',
/* regexp */ 0x27,
'!', '^', '.', '*', '$', '!', 's', 'i',
'p', ':', 'c', 'u', 's', 't', 'o', 'm',
'e', 'r', '-', 's', 'e', 'r', 'v', 'i',
'c', 'e', '@', 'e', 'x', 'a', 'm', 'p',
'l', 'e', '.', 'c', 'o', 'm', '!',
/* replace */ 0x04, '_', 's', 'i', 'p',
0x04, '_', 'u', 'd', 'p',
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_NAPTR, "4.3.2.1.5.5.5.0.0.8.1.e164.arpa");
ASSERT_NOT_NULL(rr);
rr->ttl = 3600;
rr->naptr.order = 102;
rr->naptr.preference = 10;
rr->naptr.flags = strdup("U");
rr->naptr.services = strdup("E2U+sip");
rr->naptr.regexp = strdup("!^.*$!sip:customer-service@example.com!");
rr->naptr.replacement = strdup("_sip._udp.example.com");
check_answer_contains(packet, rr, DNS_ANSWER_SECTION_ANSWER | DNS_ANSWER_CACHEABLE);
dns_resource_record_unref(rr);
}
TEST(packet_reply_naptr_compressed_replace) {
_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, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x01, '4', 0x01, '3', 0x01, '2', 0x01, '1',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* NAPTR */ 0x00, 0x23,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x0e, 0x10,
/* rdata */ 0x00, 0x4d,
/* order */ 0x00, 0x66,
/* pref */ 0x00, 0x0a,
/* flags */ 0x01, 'U',
/* services */ 0x07, 'E', '2', 'U', '+', 's', 'i', 'p',
/* regexp */ 0x27,
'!', '^', '.', '*', '$', '!', 's', 'i',
'p', ':', 'c', 'u', 's', 't', 'o', 'm',
'e', 'r', '-', 's', 'e', 'r', 'v', 'i',
'c', 'e', '@', 'e', 'x', 'a', 'm', 'p',
'l', 'e', '.', 'c', 'o', 'm', '!',
/* replace */ 0x04, '_', 's', 'i', 'p',
0x04, '_', 'u', 'd', 'p',
0xc0, 0x14
};
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);
}
/* ================================================================
* reply: OPT
* ================================================================ */
TEST(packet_reply_opt_no_do_empty) {
_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_NXDOMAIN,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* name */ 0x00,
/* OPT */ 0x00, 0x29,
/* udp max */ 0x02, 0x01,
/* rcode */ 0x9a,
/* version */ 0x00,
/* flags */ 0x00, 0x00,
/* rdata */ 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), 0u);
rr = dns_resource_record_new_full(513, DNS_TYPE_OPT, "");
ASSERT_NOT_NULL(rr);
rr->ttl = 2046820352;
ASSERT_TRUE(dns_resource_record_equal(packet->opt, rr));
dns_resource_record_unref(rr);
ASSERT_EQ(dns_packet_payload_size_max(packet), 513u);
ASSERT_EQ(dns_packet_rcode(packet), 2467u);
ASSERT_EQ(dns_packet_do(packet), 0u);
}
TEST(packet_reply_opt_multiple) {
_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,