HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/resolve/test-dns-cache.c
Git blob: 1b73a10a5ffbdfa5dfd25bd41f7e581464308c55
Lines 1001–1567 of 1,567
args1.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&args1, key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
ASSERT_OK(cache_put(&cache, &args1));
dns_resource_key_unref(key);
args2.protocol = DNS_PROTOCOL_MDNS;
args2.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&args2, key, 0x7f01a8cc, 3600, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
ASSERT_OK(cache_put(&cache, &args2));
dns_resource_key_unref(key);
ASSERT_FALSE(dns_cache_is_empty(&cache));
ASSERT_EQ(dns_cache_size(&cache), 1u);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
query_flags = 0;
ASSERT_OK_POSITIVE(dns_cache_lookup(&cache, key, query_flags, &ret_rcode, &ret_answer, &ret_full_packet, &ret_query_flags, NULL));
dns_resource_key_unref(key);
ASSERT_EQ(cache.n_hit, 1u);
ASSERT_EQ(cache.n_miss, 0u);
ASSERT_EQ(ret_rcode, DNS_RCODE_SUCCESS);
ASSERT_EQ(ret_query_flags, SD_RESOLVED_CONFIDENTIAL);
ASSERT_EQ(dns_answer_size(ret_answer), 2u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
ASSERT_TRUE(dns_answer_contains(ret_answer, rr));
dns_resource_record_unref(rr);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->a.in_addr.s_addr = htobe32(0x7f01a8cc);
ASSERT_TRUE(dns_answer_contains(ret_answer, rr));
dns_resource_record_unref(rr);
}
TEST(dns_cache_lookup_mdns_multiple_unshared_responses_are_not_cached) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs args1 = mk_put_args(), args2 = mk_put_args();
_cleanup_(dns_answer_unrefp) DnsAnswer *ret_answer = NULL;
_cleanup_(dns_packet_unrefp) DnsPacket *ret_full_packet = NULL;
DnsResourceKey *key = NULL;
DnsResourceRecord *rr = NULL;
int query_flags, ret_rcode;
uint64_t ret_query_flags;
args1.protocol = DNS_PROTOCOL_MDNS;
args1.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&args1, key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
ASSERT_OK(cache_put(&cache, &args1));
dns_resource_key_unref(key);
args2.protocol = DNS_PROTOCOL_MDNS;
args2.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&args2, key, 0x7f01a8cc, 3600, DNS_ANSWER_CACHEABLE);
ASSERT_OK(cache_put(&cache, &args2));
dns_resource_key_unref(key);
ASSERT_FALSE(dns_cache_is_empty(&cache));
ASSERT_EQ(dns_cache_size(&cache), 1u);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
query_flags = 0;
ASSERT_OK_POSITIVE(dns_cache_lookup(&cache, key, query_flags, &ret_rcode, &ret_answer, &ret_full_packet, &ret_query_flags, NULL));
dns_resource_key_unref(key);
ASSERT_EQ(cache.n_hit, 1u);
ASSERT_EQ(cache.n_miss, 0u);
ASSERT_EQ(ret_rcode, DNS_RCODE_SUCCESS);
ASSERT_EQ(ret_query_flags, SD_RESOLVED_CONFIDENTIAL);
ASSERT_EQ(dns_answer_size(ret_answer), 1u);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
ASSERT_FALSE(dns_answer_contains(ret_answer, rr));
dns_resource_record_unref(rr);
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(rr);
rr->a.in_addr.s_addr = htobe32(0x7f01a8cc);
ASSERT_TRUE(dns_answer_contains(ret_answer, rr));
dns_resource_record_unref(rr);
}
/* ================================================================
* dns_cache_prune(), dns_cache_expiry_in_one_second()
* ================================================================ */
TEST(dns_cache_prune) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
DnsResourceKey *key = NULL;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0xc0a8017f, 1, DNS_ANSWER_CACHEABLE);
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns2.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0x7f01a8cc, 3, DNS_ANSWER_CACHEABLE);
dns_resource_key_unref(key);
cache_put(&cache, &put_args);
dns_cache_prune(&cache);
ASSERT_EQ(dns_cache_size(&cache), 2u);
ASSERT_TRUE(dns_cache_expiry_in_one_second(&cache, now(CLOCK_BOOTTIME)));
sleep(2);
dns_cache_prune(&cache);
ASSERT_EQ(dns_cache_size(&cache), 1u);
ASSERT_TRUE(dns_cache_expiry_in_one_second(&cache, now(CLOCK_BOOTTIME)));
sleep(2);
dns_cache_prune(&cache);
ASSERT_TRUE(dns_cache_is_empty(&cache));
ASSERT_FALSE(dns_cache_expiry_in_one_second(&cache, now(CLOCK_BOOTTIME)));
}
/* The tests below pin where an entry's expiry lands by probing dns_cache_expiry_in_one_second() with
* reference times sampled around the put, rather than by sleeping until it comes due: the expiry is
* computed from the put's own timestamp, so it is bounded by the clock readings taken before and after. */
TEST(dns_cache_stale_retention_honored_for_unicast) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
usec_t t;
put_args.stale_retention_usec = USEC_PER_HOUR;
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(put_args.key);
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 1, DNS_ANSWER_CACHEABLE);
t = now(CLOCK_BOOTTIME);
ASSERT_OK(cache_put(&cache, &put_args));
ASSERT_EQ(dns_cache_size(&cache), 1u);
/* The entry expires a retention window after its TTL, not at its TTL: it is not due within a
* second of an hour from now, but it is an hour and a second out. */
ASSERT_FALSE(dns_cache_expiry_in_one_second(&cache, usec_add(t, USEC_PER_HOUR - USEC_PER_SEC)));
ASSERT_TRUE(dns_cache_expiry_in_one_second(&cache, usec_add(now(CLOCK_BOOTTIME), USEC_PER_HOUR)));
}
TEST(dns_cache_stale_retention_ignored_for_mdns) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
usec_t t;
put_args.protocol = DNS_PROTOCOL_MDNS;
put_args.stale_retention_usec = USEC_PER_HOUR;
/* A TTL of 1 would be taken for a goodbye and not cached at all, so use 2. */
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.local");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0xc0a8017f, 2, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
t = now(CLOCK_BOOTTIME);
ASSERT_OK(cache_put(&cache, &put_args));
ASSERT_EQ(dns_cache_size(&cache), 1u);
/* Expiry must be scheduled by the TTL, not by the retention window: the record is not due
* within a second, but a second from now it is within a second of expiring. */
ASSERT_FALSE(dns_cache_expiry_in_one_second(&cache, t));
ASSERT_TRUE(dns_cache_expiry_in_one_second(&cache, usec_add(now(CLOCK_BOOTTIME), USEC_PER_SEC)));
}
TEST(dns_cache_stale_retention_ignored_for_mdns_goodbye) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs args1 = mk_put_args(), args2 = mk_put_args();
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.local");
ASSERT_NOT_NULL(key);
args1.protocol = DNS_PROTOCOL_MDNS;
args1.stale_retention_usec = USEC_PER_HOUR;
answer_add_a(&args1, key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
ASSERT_OK(cache_put(&cache, &args1));
ASSERT_EQ(dns_cache_size(&cache), 1u);
ASSERT_FALSE(dns_cache_expiry_in_one_second(&cache, now(CLOCK_BOOTTIME)));
/* A goodbye (RFC 6762 § 10.1) rewrites the existing entry with TTL=1. Its expiry must then land
* a second out, not a retention window out, or the one-second goodbye prune would never drop it. */
args2.protocol = DNS_PROTOCOL_MDNS;
args2.stale_retention_usec = USEC_PER_HOUR;
answer_add_a(&args2, key, 0xc0a8017f, 1, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
ASSERT_OK(cache_put(&cache, &args2));
ASSERT_EQ(dns_cache_size(&cache), 1u);
ASSERT_TRUE(dns_cache_expiry_in_one_second(&cache, now(CLOCK_BOOTTIME)));
}
TEST(dns_cache_stale_retention_ignored_for_llmnr) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
usec_t t;
put_args.protocol = DNS_PROTOCOL_LLMNR;
put_args.stale_retention_usec = USEC_PER_HOUR;
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.local");
ASSERT_NOT_NULL(put_args.key);
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 2, DNS_ANSWER_CACHEABLE);
t = now(CLOCK_BOOTTIME);
ASSERT_OK(cache_put(&cache, &put_args));
ASSERT_EQ(dns_cache_size(&cache), 1u);
/* Like mDNS, LLMNR peers are link-local hosts that come and go, so the entry must expire with
* its TTL rather than at the end of the retention window. */
ASSERT_FALSE(dns_cache_expiry_in_one_second(&cache, t));
ASSERT_TRUE(dns_cache_expiry_in_one_second(&cache, usec_add(now(CLOCK_BOOTTIME), USEC_PER_SEC)));
}
/* ================================================================
* dns_cache_check_conflicts()
* ================================================================ */
TEST(dns_cache_check_conflicts_same_key_and_owner) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(put_args.key);
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &put_args);
union in_addr_union owner_addr = { .in.s_addr = htobe32(0x01020304) };
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(rr);
ASSERT_FALSE(dns_cache_check_conflicts(&cache, rr, AF_INET, &owner_addr));
}
TEST(dns_cache_check_conflicts_same_key_different_owner) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(put_args.key);
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &put_args);
union in_addr_union owner_addr = { .in.s_addr = htobe32(0x01020305) };
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(rr);
ASSERT_TRUE(dns_cache_check_conflicts(&cache, rr, AF_INET, &owner_addr));
}
TEST(dns_cache_check_conflicts_different_key) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "ns2.example.com");
ASSERT_NOT_NULL(put_args.key);
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &put_args);
union in_addr_union owner_addr = { .in.s_addr = htobe32(0x01020305) };
rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "ns1.example.com");
ASSERT_NOT_NULL(rr);
ASSERT_FALSE(dns_cache_check_conflicts(&cache, rr, AF_INET, &owner_addr));
}
/* ================================================================
* dns_cache_export_shared_to_packet()
* ================================================================ */
TEST(dns_cache_export_shared_to_packet) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs args1 = mk_put_args(), args2 = mk_put_args();
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
args1.protocol = DNS_PROTOCOL_MDNS;
args1.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "shared.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&args1, key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "unshared.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&args1, key, 0xa87f01c0, 2400, DNS_ANSWER_CACHEABLE);
dns_resource_key_unref(key);
cache_put(&cache, &args1);
args2.protocol = DNS_PROTOCOL_DNS;
args2.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "dns.example.com");
ASSERT_NOT_NULL(args2.key);
args2.rcode = DNS_RCODE_SUCCESS;
answer_add_a(&args2, args2.key, 0xa9fe0100, 2400, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &args2);
dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX);
ASSERT_NOT_NULL(packet);
ASSERT_OK(dns_cache_export_shared_to_packet(&cache, packet, 0, 50));
const uint8_t data[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x06, 's', 'h', 'a', 'r', 'e', 'd',
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
};
ASSERT_EQ(packet->size, sizeof(data));
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
}
TEST(dns_cache_export_shared_to_packet_multi) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
DnsResourceKey *key = NULL;
put_args.protocol = DNS_PROTOCOL_MDNS;
put_args.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "shared1.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "unshared.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0xa87f01c0, 2400, DNS_ANSWER_CACHEABLE);
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "shared2.example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0x7f01a8cc, 1800, DNS_ANSWER_CACHEABLE | DNS_ANSWER_SHARED_OWNER);
dns_resource_key_unref(key);
cache_put(&cache, &put_args);
dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX);
ASSERT_NOT_NULL(packet);
ASSERT_OK(dns_cache_export_shared_to_packet(&cache, packet, 0, 1));
const uint8_t data1[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 's', 'h', 'a', 'r', 'e', 'd', '1',
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
};
const uint8_t data2[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
/* name */ 0x07, 's', 'h', 'a', 'r', 'e', 'd', '2',
0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
0x03, 'c', 'o', 'm',
0x00,
/* A */ 0x00, 0x01,
/* IN */ 0x00, 0x01,
/* ttl */ 0x00, 0x00, 0x07, 0x08,
/* rdata */ 0x00, 0x04,
/* ip */ 0x7f, 0x01, 0xa8, 0xcc
};
size_t size1 = sizeof(data1), size2 = sizeof(data2);
/* cache key order is not deterministic; the packets could come out in either order */
if (memcmp(DNS_PACKET_DATA(packet), data1, size1) == 0) {
ASSERT_EQ(packet->size, size1);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data1, size1), 0);
ASSERT_EQ(packet->more->size, size2);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet->more), data2, size2), 0);
} else {
ASSERT_EQ(packet->size, size2);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data2, size2), 0);
ASSERT_EQ(packet->more->size, size1);
ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet->more), data1, size1), 0);
}
ASSERT_NULL(packet->more->more);
}
/* ================================================================
* dns_cache_dump()
* ================================================================ */
static int cmpstring(const void *a, const void *b) {
ASSERT_NOT_NULL(a);
ASSERT_NOT_NULL(b);
return strcmp(*(const char **)a, *(const char **)b);
}
static void check_dump_contents(FILE *f, const char **expected, size_t n) {
char *actual[n];
rewind(f);
for (size_t i = 0; i < n; i++) {
size_t length = read_line(f, 1024, &actual[i]);
ASSERT_GT(length, 0u);
}
qsort(actual, n, sizeof(char *), cmpstring);
for (size_t i = 0; i < n; i++)
ASSERT_STREQ(actual[i], expected[i]);
for (size_t i = 0; i < n; i++)
free(actual[i]);
}
TEST(dns_cache_dump_single_a) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
ASSERT_NOT_NULL(put_args.key);
put_args.rcode = DNS_RCODE_SUCCESS;
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &put_args);
ASSERT_EQ(dns_cache_size(&cache), 1u);
_cleanup_(unlink_tempfilep) char p[] = "/tmp/dns-cache-dump-single-a-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
fmkostemp_safe(p, "r+", &f);
dns_cache_dump(&cache, f);
const char *expected[] = {
"\twww.example.com IN A 192.168.1.127"
};
check_dump_contents(f, expected, 1);
}
TEST(dns_cache_dump_a_with_cname) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
ASSERT_NOT_NULL(put_args.key);
put_args.rcode = DNS_RCODE_SUCCESS;
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_CNAME, "www.example.com");
ASSERT_NOT_NULL(key);
answer_add_cname(&put_args, key, "example.com", 3600, DNS_ANSWER_CACHEABLE);
dns_resource_key_unref(key);
key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
ASSERT_NOT_NULL(key);
answer_add_a(&put_args, key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &put_args);
ASSERT_EQ(dns_cache_size(&cache), 2u);
_cleanup_(unlink_tempfilep) char p[] = "/tmp/dns-cache-dump-a-with-cname-XXXXXX";
_cleanup_fclose_ FILE *f = NULL;
fmkostemp_safe(p, "r+", &f);
dns_cache_dump(&cache, f);
const char *expected[] = {
"\texample.com IN A 192.168.1.127",
"\twww.example.com IN CNAME example.com"
};
check_dump_contents(f, expected, 2);
}
/* ================================================================
* dns_cache_dump_to_json()
* ================================================================ */
TEST(dns_cache_dump_json_basic) {
_cleanup_(dns_cache_unrefp) DnsCache cache = new_cache();
_cleanup_(put_args_unrefp) PutArgs put_args = mk_put_args();
_cleanup_(sd_json_variant_unrefp) sd_json_variant *json = NULL, *expected = NULL;
sd_json_variant *item = NULL, *rr = NULL;
_cleanup_free_ char *str = calloc(256, sizeof(char));
ASSERT_NOT_NULL(str);
put_args.key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
ASSERT_NOT_NULL(put_args.key);
put_args.rcode = DNS_RCODE_SUCCESS;
answer_add_a(&put_args, put_args.key, 0xc0a8017f, 3600, DNS_ANSWER_CACHEABLE);
cache_put(&cache, &put_args);
ASSERT_EQ(dns_cache_size(&cache), 1u);
ASSERT_OK(dns_cache_dump_to_json(&cache, &json));
ASSERT_NOT_NULL(json);
ASSERT_TRUE(sd_json_variant_is_array(json));
ASSERT_EQ(sd_json_variant_elements(json), 1u);
item = BY_IDX(json, 0);
ASSERT_NOT_NULL(item);
sprintf(str, "{ \"class\": %d, \"type\": %d, \"name\": \"www.example.com\" }", DNS_CLASS_IN, DNS_TYPE_A);
ASSERT_OK(sd_json_parse(str, 0, &expected, NULL, NULL));
ASSERT_TRUE(sd_json_variant_equal(BY_KEY(item, "key"), expected));
ASSERT_TRUE(sd_json_variant_is_array(BY_KEY(item, "rrs")));
ASSERT_EQ(sd_json_variant_elements(BY_KEY(item, "rrs")), 1u);
rr = BY_KEY(BY_IDX(BY_KEY(item, "rrs"), 0), "rr");
ASSERT_NOT_NULL(rr);
ASSERT_TRUE(sd_json_variant_equal(BY_KEY(rr, "key"), expected));
sd_json_variant_unref(expected);
sprintf(str, "[192, 168, 1, 127]");
ASSERT_OK(sd_json_parse(str, 0, &expected, NULL, NULL));
ASSERT_TRUE(sd_json_variant_equal(BY_KEY(rr, "address"), expected));
ASSERT_TRUE(sd_json_variant_is_string(BY_KEY(BY_IDX(BY_KEY(item, "rrs"), 0), "raw")));
ASSERT_TRUE(sd_json_variant_is_integer(BY_KEY(item, "until")));
}
DEFINE_TEST_MAIN(LOG_DEBUG);