Debian Codegraph @

src/resolve/test-dns-packet-append.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "dns-answer.h"
4 #include "dns-packet.h"
5 #include "dns-question.h"
6 #include "dns-rr.h"
7 #include "dns-type.h"
8 #include "list.h"
9 #include "log.h"
10 #include "tests.h"
11
12 #define BIT_QR (1 << 7)
13 #define BIT_AA (1 << 2)
14 #define BIT_TC (1 << 1)
15 #define BIT_RD (1 << 0)
16
17 #define BIT_RA (1 << 7)
18 #define BIT_AD (1 << 5)
19 #define BIT_CD (1 << 4)
20
21 /* ================================================================
22 * dns_packet_set_flags()
23 * ================================================================ */
24
25 TEST(packet_set_flags_dns_checking_enabled) {
26 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
27
28 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
29 ASSERT_NOT_NULL(packet);
30 dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ false, /* truncated= */ false);
31
32 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
33 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
34 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
35 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
36 ASSERT_EQ(DNS_PACKET_RD(packet), 1);
37
38 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
39 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
40 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
41 ASSERT_EQ(dns_packet_rcode(packet), 0);
42 }
43
44 TEST(packet_set_flags_dns_checking_disabled) {
45 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
46
47 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
48 ASSERT_NOT_NULL(packet);
49 dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ false);
50
51 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
52 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
53 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
54 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
55 ASSERT_EQ(DNS_PACKET_RD(packet), 1);
56
57 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
58 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
59 ASSERT_EQ(DNS_PACKET_CD(packet), 1);
60 ASSERT_EQ(dns_packet_rcode(packet), 0);
61 }
62
63 TEST(packet_set_flags_llmnr) {
64 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
65
66 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_LLMNR, 0, DNS_PACKET_SIZE_MAX));
67 ASSERT_NOT_NULL(packet);
68 dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ false);
69
70 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
71 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
72 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
73 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
74 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
75
76 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
77 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
78 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
79 ASSERT_EQ(dns_packet_rcode(packet), 0);
80 }
81
82 TEST(packet_set_flags_mdns_not_truncated) {
83 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
84
85 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
86 ASSERT_NOT_NULL(packet);
87 dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ false);
88
89 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
90 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
91 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
92 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
93 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
94
95 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
96 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
97 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
98 ASSERT_EQ(dns_packet_rcode(packet), 0);
99 }
100
101 TEST(packet_set_flags_mdns_truncated) {
102 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
103
104 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_MDNS, 0, DNS_PACKET_SIZE_MAX));
105 ASSERT_NOT_NULL(packet);
106 dns_packet_set_flags(packet, /* dnssec_checking_disabled= */ true, /* truncated= */ true);
107
108 ASSERT_EQ(DNS_PACKET_QR(packet), 0);
109 ASSERT_EQ(DNS_PACKET_OPCODE(packet), 0);
110 ASSERT_EQ(DNS_PACKET_AA(packet), 0);
111 ASSERT_EQ(DNS_PACKET_TC(packet), 1);
112 ASSERT_EQ(DNS_PACKET_RD(packet), 0);
113
114 ASSERT_EQ(DNS_PACKET_RA(packet), 0);
115 ASSERT_EQ(DNS_PACKET_AD(packet), 0);
116 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
117 ASSERT_EQ(dns_packet_rcode(packet), 0);
118 }
119
120 /* ================================================================
121 * dns_packet_new_query()
122 * ================================================================ */
123
124 TEST(packet_new_query_checking_enabled) {
125 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
126
127 ASSERT_OK(dns_packet_new_query(&packet, DNS_PROTOCOL_DNS, 0, false));
128 ASSERT_NOT_NULL(packet);
129
130 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
131 ASSERT_EQ(DNS_PACKET_CD(packet), 0);
132 }
133
134 TEST(packet_new_query_checking_disabled) {
135 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
136
137 ASSERT_OK(dns_packet_new_query(&packet, DNS_PROTOCOL_DNS, 0, true));
138 ASSERT_NOT_NULL(packet);
139
140 ASSERT_EQ(DNS_PACKET_TC(packet), 0);
141 ASSERT_EQ(DNS_PACKET_CD(packet), 1);
142 }
143
144 /* ================================================================
145 * dns_packet_append_key()
146 * ================================================================ */
147
148 TEST(packet_append_key_single_a) {
149 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
150 DnsResourceKey *key = NULL;
151
152 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
153 ASSERT_NOT_NULL(packet);
154
155 DNS_PACKET_ID(packet) = htobe16(42);
156 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
157 DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
158
159 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
160 ASSERT_NOT_NULL(key);
161 ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
162 dns_resource_key_unref(key);
163
164 const uint8_t data[] = {
165 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
166 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
167
168 /* name */ 0x03, 'w', 'w', 'w',
169 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
170 0x03, 'c', 'o', 'm',
171 0x00,
172 /* A */ 0x00, 0x01,
173 /* IN */ 0x00, 0x01
174 };
175
176 ASSERT_EQ(packet->size, sizeof(data));
177 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
178 }
179
180 TEST(packet_append_key_single_soa_any_class) {
181 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
182 DnsResourceKey *key = NULL;
183
184 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
185 ASSERT_NOT_NULL(packet);
186
187 DNS_PACKET_ID(packet) = htobe16(42);
188 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
189 DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
190
191 key = dns_resource_key_new(DNS_CLASS_ANY, DNS_TYPE_SOA, "www.example.com");
192 ASSERT_NOT_NULL(key);
193 ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
194 dns_resource_key_unref(key);
195
196 const uint8_t data[] = {
197 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
198 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
199
200 /* name */ 0x03, 'w', 'w', 'w',
201 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
202 0x03, 'c', 'o', 'm',
203 0x00,
204 /* SOA */ 0x00, 0x06,
205 /* ANY */ 0x00, 0xff
206 };
207
208 ASSERT_EQ(packet->size, sizeof(data));
209 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
210 }
211
212 /* ================================================================
213 * dns_packet_append_question()
214 * ================================================================ */
215
216 TEST(packet_append_question_compression) {
217 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
218 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
219 DnsResourceKey *key = NULL;
220
221 question = dns_question_new(3);
222 ASSERT_NOT_NULL(question);
223
224 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
225 ASSERT_NOT_NULL(key);
226 ASSERT_OK(dns_question_add(question, key, 0));
227 dns_resource_key_unref(key);
228
229 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_MX, "mail.example.com");
230 ASSERT_NOT_NULL(key);
231 ASSERT_OK(dns_question_add(question, key, 0));
232 dns_resource_key_unref(key);
233
234 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_SOA, "host.mail.example.com");
235 ASSERT_NOT_NULL(key);
236 ASSERT_OK(dns_question_add(question, key, 0));
237 dns_resource_key_unref(key);
238
239 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
240 ASSERT_NOT_NULL(packet);
241
242 DNS_PACKET_ID(packet) = htobe16(42);
243 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
244 DNS_PACKET_HEADER(packet)->qdcount = htobe16(dns_question_size(question));
245
246 ASSERT_OK(dns_packet_append_question(packet, question));
247
248 const uint8_t data[] = {
249 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
250 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
251
252 /* name */ 0x03, 'w', 'w', 'w',
253 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
254 0x03, 'c', 'o', 'm',
255 0x00,
256 /* A */ 0x00, 0x01,
257 /* IN */ 0x00, 0x01,
258
259 /* name */ 0x04, 'm', 'a', 'i', 'l',
260 0xc0, 0x10,
261 /* MX */ 0x00, 0x0f,
262 /* IN */ 0x00, 0x01,
263
264 /* name */ 0x04, 'h', 'o', 's', 't',
265 0xc0, 0x21,
266 /* SOA */ 0x00, 0x06,
267 /* IN */ 0x00, 0x01
268 };
269
270 ASSERT_EQ(packet->size, sizeof(data));
271 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
272 }
273
274 /* ================================================================
275 * dns_packet_append_opt()
276 * ================================================================ */
277
278 TEST(packet_append_opt_basic) {
279 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
280
281 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
282 ASSERT_NOT_NULL(packet);
283
284 DNS_PACKET_ID(packet) = htobe16(42);
285 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
286
287 ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
288
289 const uint8_t data[] = {
290 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
291 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
292
293 /* root */ 0x00,
294 /* OPT */ 0x00, 0x29,
295 /* udp max */ 0x02, 0x00,
296 /* rcode */ 0x00,
297 /* version */ 0x00,
298 /* flags */ 0x00, 0x00,
299 /* rdata */ 0x00, 0x00
300 };
301
302 ASSERT_EQ(packet->size, sizeof(data));
303 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
304 }
305
306 TEST(packet_append_opt_change_max_udp) {
307 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
308
309 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
310 ASSERT_NOT_NULL(packet);
311
312 DNS_PACKET_ID(packet) = htobe16(42);
313 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
314
315 ASSERT_OK(dns_packet_append_opt(packet, 4100, false, false, NULL, 0, NULL));
316
317 const uint8_t data[] = {
318 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
319 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
320
321 /* root */ 0x00,
322 /* OPT */ 0x00, 0x29,
323 /* udp max */ 0x10, 0x04,
324 /* rcode */ 0x00,
325 /* version */ 0x00,
326 /* flags */ 0x00, 0x00,
327 /* rdata */ 0x00, 0x00
328 };
329
330 ASSERT_EQ(packet->size, sizeof(data));
331 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
332 }
333
334 TEST(packet_append_opt_dnssec_ok) {
335 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
336
337 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
338 ASSERT_NOT_NULL(packet);
339
340 DNS_PACKET_ID(packet) = htobe16(42);
341 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
342
343 ASSERT_OK(dns_packet_append_opt(packet, 512, true, false, NULL, 0, NULL));
344
345 const uint8_t data[] = {
346 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
347 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
348
349 /* root */ 0x00,
350 /* OPT */ 0x00, 0x29,
351 /* udp max */ 0x02, 0x00,
352 /* rcode */ 0x00,
353 /* version */ 0x00,
354 /* flags */ 0x80, 0x00,
355 /* rdata */ 0x00, 0x00
356 };
357
358 ASSERT_EQ(packet->size, sizeof(data));
359 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
360 }
361
362 TEST(packet_append_opt_rcode) {
363 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
364
365 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
366 ASSERT_NOT_NULL(packet);
367
368 DNS_PACKET_ID(packet) = htobe16(42);
369 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
370
371 ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0x97a, NULL));
372
373 const uint8_t data[] = {
374 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
375 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
376
377 /* root */ 0x00,
378 /* OPT */ 0x00, 0x29,
379 /* udp max */ 0x02, 0x00,
380 /* rcode */ 0x97,
381 /* version */ 0x00,
382 /* flags */ 0x00, 0x00,
383 /* rdata */ 0x00, 0x00
384 };
385
386 ASSERT_EQ(packet->size, sizeof(data));
387 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
388 }
389
390 TEST(packet_append_opt_nsid) {
391 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
392
393 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
394 ASSERT_NOT_NULL(packet);
395
396 DNS_PACKET_ID(packet) = htobe16(42);
397 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
398
399 ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, "nsid.example.com", 0, NULL));
400
401 const uint8_t data[] = {
402 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
403 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
404
405 /* root */ 0x00,
406 /* OPT */ 0x00, 0x29,
407 /* udp max */ 0x02, 0x00,
408 /* rcode */ 0x00,
409 /* version */ 0x00,
410 /* flags */ 0x00, 0x00,
411 /* rdata */ 0x00, 0x14,
412 0x00, 0x03,
413 0x00, 0x10,
414 'n', 's', 'i', 'd', '.', 'e', 'x', 'a',
415 'm', 'p', 'l', 'e', '.', 'c', 'o', 'm'
416 };
417
418 ASSERT_EQ(packet->size, sizeof(data));
419 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
420 }
421
422 TEST(packet_append_key_and_opt) {
423 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
424 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
425
426 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
427 ASSERT_NOT_NULL(packet);
428
429 DNS_PACKET_ID(packet) = htobe16(42);
430 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
431 DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
432
433 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
434 ASSERT_NOT_NULL(key);
435 ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
436
437 ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
438
439 const uint8_t data[] = {
440 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
441 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
442
443 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
444 0x03, 'c', 'o', 'm',
445 0x00,
446 /* A */ 0x00, 0x01,
447 /* IN */ 0x00, 0x01,
448
449 /* root */ 0x00,
450 /* OPT */ 0x00, 0x29,
451 /* udp max */ 0x02, 0x00,
452 /* rcode */ 0x00,
453 /* version */ 0x00,
454 /* flags */ 0x00, 0x00,
455 /* rdata */ 0x00, 0x00
456 };
457
458 ASSERT_EQ(packet->size, sizeof(data));
459 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
460 }
461
462 TEST(packet_truncate_opt) {
463 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
464 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
465
466 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
467 ASSERT_NOT_NULL(packet);
468
469 DNS_PACKET_ID(packet) = htobe16(42);
470 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
471 DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
472
473 key = dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
474 ASSERT_NOT_NULL(key);
475 ASSERT_OK(dns_packet_append_key(packet, key, 0, NULL));
476
477 ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
478
479 ASSERT_TRUE(dns_packet_truncate_opt(packet));
480
481 const uint8_t data[] = {
482 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
483 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
484
485 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
486 0x03, 'c', 'o', 'm',
487 0x00,
488 /* A */ 0x00, 0x01,
489 /* IN */ 0x00, 0x01
490 };
491
492 ASSERT_EQ(packet->size, sizeof(data));
493 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
494 }
495
496 /* ================================================================
497 * dns_packet_patch_max_udp_size()
498 * ================================================================ */
499
500 TEST(packet_patch_max_udp_size) {
501 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
502
503 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
504 ASSERT_NOT_NULL(packet);
505
506 DNS_PACKET_ID(packet) = htobe16(42);
507 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
508
509 ASSERT_OK(dns_packet_append_opt(packet, 512, false, false, NULL, 0, NULL));
510
511 ASSERT_TRUE(dns_packet_patch_max_udp_size(packet, 4097));
512
513 const uint8_t data[] = {
514 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
515 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
516
517 /* root */ 0x00,
518 /* OPT */ 0x00, 0x29,
519 /* udp max */ 0x10, 0x01,
520 /* rcode */ 0x00,
521 /* version */ 0x00,
522 /* flags */ 0x00, 0x00,
523 /* rdata */ 0x00, 0x00
524 };
525
526 ASSERT_EQ(packet->size, sizeof(data));
527 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
528 }
529
530 TEST(packet_patch_max_udp_size_no_opt) {
531 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
532
533 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
534 ASSERT_NOT_NULL(packet);
535
536 DNS_PACKET_ID(packet) = htobe16(42);
537 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, DNS_RCODE_SUCCESS));
538
539 ASSERT_FALSE(dns_packet_patch_max_udp_size(packet, 4097));
540
541 const uint8_t data[] = {
542 0x00, 0x2a, BIT_RD, DNS_RCODE_SUCCESS,
543 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
544 };
545
546 ASSERT_EQ(packet->size, sizeof(data));
547 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
548 }
549
550 /* ================================================================
551 * dns_packet_dup()
552 * ================================================================ */
553
554 TEST(packet_dup) {
555 _cleanup_(dns_packet_unrefp) DnsPacket *p1 = NULL, *p2 = NULL;
556 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
557 DnsResourceRecord *rr = NULL;
558
559 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
560 ASSERT_NOT_NULL(rr);
561 rr->ttl = 3601;
562 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
563
564 answer = dns_answer_new(1);
565 ASSERT_NOT_NULL(answer);
566 dns_answer_add(answer, rr, 1, 0, NULL);
567 dns_resource_record_unref(rr);
568
569 ASSERT_OK(dns_packet_new(&p1, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
570 ASSERT_NOT_NULL(p1);
571
572 DNS_PACKET_ID(p1) = htobe16(42);
573 DNS_PACKET_HEADER(p1)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
574 DNS_PACKET_HEADER(p1)->ancount = htobe16(dns_answer_size(answer));
575
576 ASSERT_OK(dns_packet_append_answer(p1, answer, NULL));
577
578 const uint8_t data[] = {
579 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
580 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
581
582 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
583 0x03, 'c', 'o', 'm',
584 0x00,
585 /* A */ 0x00, 0x01,
586 /* IN */ 0x00, 0x01,
587 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
588 /* rdata */ 0x00, 0x04,
589 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
590 };
591
592 ASSERT_OK(dns_packet_dup(&p2, p1));
593 ASSERT_NOT_NULL(p2);
594
595 ASSERT_EQ(p2->size, sizeof(data));
596 ASSERT_EQ(memcmp(DNS_PACKET_DATA(p2), data, sizeof(data)), 0);
597 }
598
599 /* ================================================================
600 * dns_packet_append_answer()
601 * ================================================================ */
602
603 TEST(packet_append_answer_single_a) {
604 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
605 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
606 DnsResourceRecord *rr = NULL;
607
608 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "example.com");
609 ASSERT_NOT_NULL(rr);
610 rr->ttl = 3601;
611 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
612
613 answer = dns_answer_new(1);
614 ASSERT_NOT_NULL(answer);
615 dns_answer_add(answer, rr, 1, 0, NULL);
616 dns_resource_record_unref(rr);
617
618 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
619 ASSERT_NOT_NULL(packet);
620
621 DNS_PACKET_ID(packet) = htobe16(42);
622 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
623 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
624
625 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
626
627 const uint8_t data[] = {
628 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
629 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
630
631 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
632 0x03, 'c', 'o', 'm',
633 0x00,
634 /* A */ 0x00, 0x01,
635 /* IN */ 0x00, 0x01,
636 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
637 /* rdata */ 0x00, 0x04,
638 /* ip */ 0xc0, 0xa8, 0x01, 0x7f
639 };
640
641 ASSERT_EQ(packet->size, sizeof(data));
642 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
643 }
644
645 TEST(packet_append_answer_single_ns) {
646 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
647 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
648 DnsResourceRecord *rr = NULL;
649
650 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_NS, "example.com");
651 ASSERT_NOT_NULL(rr);
652 rr->ttl = 3601;
653 rr->ns.name = strdup("ns1.example.com");
654
655 answer = dns_answer_new(1);
656 ASSERT_NOT_NULL(answer);
657 dns_answer_add(answer, rr, 1, 0, NULL);
658 dns_resource_record_unref(rr);
659
660 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
661 ASSERT_NOT_NULL(packet);
662
663 DNS_PACKET_ID(packet) = htobe16(42);
664 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
665 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
666
667 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
668
669 const uint8_t data[] = {
670 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
671 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
672
673 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
674 0x03, 'c', 'o', 'm',
675 0x00,
676 /* NS */ 0x00, 0x02,
677 /* IN */ 0x00, 0x01,
678 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
679 /* rdata */ 0x00, 0x06,
680 /* name */ 0x03, 'n', 's', '1',
681 0xc0, 0x0c
682 };
683
684 ASSERT_EQ(packet->size, sizeof(data));
685 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
686 }
687
688 TEST(packet_append_answer_single_cname) {
689 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
690 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
691 DnsResourceRecord *rr = NULL;
692
693 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_CNAME, "www.example.com");
694 ASSERT_NOT_NULL(rr);
695 rr->ttl = 3601;
696 rr->cname.name = strdup("example.com");
697
698 answer = dns_answer_new(1);
699 ASSERT_NOT_NULL(answer);
700 dns_answer_add(answer, rr, 1, 0, NULL);
701 dns_resource_record_unref(rr);
702
703 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
704 ASSERT_NOT_NULL(packet);
705
706 DNS_PACKET_ID(packet) = htobe16(42);
707 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
708 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
709
710 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
711
712 const uint8_t data[] = {
713 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
714 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
715
716 /* name */ 0x03, 'w', 'w', 'w',
717 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
718 0x03, 'c', 'o', 'm',
719 0x00,
720 /* CNAME */ 0x00, 0x05,
721 /* IN */ 0x00, 0x01,
722 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
723 /* rdata */ 0x00, 0x02,
724 /* name */ 0xc0, 0x10
725 };
726
727 ASSERT_EQ(packet->size, sizeof(data));
728 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
729 }
730
731 TEST(packet_append_answer_single_hinfo) {
732 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
733 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
734 DnsResourceRecord *rr = NULL;
735
736 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_HINFO, "example.com");
737 ASSERT_NOT_NULL(rr);
738 rr->ttl = 3601;
739 rr->hinfo.cpu = strdup("x64");
740 rr->hinfo.os = strdup("GNU/Linux");
741
742 answer = dns_answer_new(1);
743 ASSERT_NOT_NULL(answer);
744 dns_answer_add(answer, rr, 1, 0, NULL);
745 dns_resource_record_unref(rr);
746
747 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
748 ASSERT_NOT_NULL(packet);
749
750 DNS_PACKET_ID(packet) = htobe16(42);
751 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
752 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
753
754 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
755
756 const uint8_t data[] = {
757 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
758 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
759
760 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
761 0x03, 'c', 'o', 'm',
762 0x00,
763 /* HINFO */ 0x00, 0x0d,
764 /* IN */ 0x00, 0x01,
765 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
766 /* rdata */ 0x00, 0x0e,
767 /* cpu */ 0x03, 'x', '6', '4',
768 /* os */ 0x09, 'G', 'N', 'U', '/', 'L', 'i', 'n', 'u', 'x'
769 };
770
771 ASSERT_EQ(packet->size, sizeof(data));
772 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
773 }
774
775 TEST(packet_append_answer_single_ptr) {
776 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
777 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
778 DnsResourceRecord *rr = NULL;
779
780 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_PTR, "127.1.168.192.in-addr.arpa");
781 ASSERT_NOT_NULL(rr);
782 rr->ttl = 3601;
783 rr->ptr.name = strdup("example.com");
784
785 answer = dns_answer_new(1);
786 ASSERT_NOT_NULL(answer);
787 dns_answer_add(answer, rr, 1, 0, NULL);
788 dns_resource_record_unref(rr);
789
790 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
791 ASSERT_NOT_NULL(packet);
792
793 DNS_PACKET_ID(packet) = htobe16(42);
794 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
795 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
796
797 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
798
799 const uint8_t data[] = {
800 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
801 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
802
803 /* name */ 0x03, '1', '2', '7',
804 0x01, '1',
805 0x03, '1', '6', '8',
806 0x03, '1', '9', '2',
807 0x07, 'i', 'n', '-', 'a', 'd', 'd', 'r',
808 0x04, 'a', 'r', 'p', 'a',
809 0x00,
810 /* PTR */ 0x00, 0x0c,
811 /* IN */ 0x00, 0x01,
812 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
813 /* rdata */ 0x00, 0x0d,
814 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
815 0x03, 'c', 'o', 'm',
816 0x00
817 };
818
819 ASSERT_EQ(packet->size, sizeof(data));
820 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
821 }
822
823 TEST(packet_append_answer_single_mx) {
824 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
825 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
826 DnsResourceRecord *rr = NULL;
827
828 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_MX, "example.com");
829 ASSERT_NOT_NULL(rr);
830 rr->ttl = 3601;
831 rr->mx.priority = 9;
832 rr->mx.exchange = strdup("mail.example.com");
833
834 answer = dns_answer_new(1);
835 ASSERT_NOT_NULL(answer);
836 dns_answer_add(answer, rr, 1, 0, NULL);
837 dns_resource_record_unref(rr);
838
839 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
840 ASSERT_NOT_NULL(packet);
841
842 DNS_PACKET_ID(packet) = htobe16(42);
843 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
844 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
845
846 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
847
848 const uint8_t data[] = {
849 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
850 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
851
852 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
853 0x03, 'c', 'o', 'm',
854 0x00,
855 /* MX */ 0x00, 0x0f,
856 /* IN */ 0x00, 0x01,
857 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
858 /* rdata */ 0x00, 0x09,
859 /* priority */ 0x00, 0x09,
860 /* name */ 0x04, 'm', 'a', 'i', 'l',
861 0xc0, 0x0c
862 };
863
864 ASSERT_EQ(packet->size, sizeof(data));
865 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
866 }
867
868 TEST(packet_append_answer_single_txt) {
869 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
870 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
871 DnsResourceRecord *rr = NULL;
872 DnsTxtItem *item = NULL;
873
874 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_TXT, "example.com");
875 ASSERT_NOT_NULL(rr);
876 rr->ttl = 3601;
877
878 item = calloc(1, offsetof(DnsTxtItem, data) + 3);
879 ASSERT_NOT_NULL(item);
880 item->length = 2;
881 memcpy(item->data, "hi", 3);
882 LIST_APPEND(items, rr->txt.items, item);
883
884 item = calloc(1, offsetof(DnsTxtItem, data) + 6);
885 ASSERT_NOT_NULL(item);
886 item->length = 5;
887 memcpy(item->data, "world", 6);
888 LIST_APPEND(items, rr->txt.items, item);
889
890 answer = dns_answer_new(1);
891 ASSERT_NOT_NULL(answer);
892 dns_answer_add(answer, rr, 1, 0, NULL);
893 dns_resource_record_unref(rr);
894
895 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
896 ASSERT_NOT_NULL(packet);
897
898 DNS_PACKET_ID(packet) = htobe16(42);
899 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
900 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
901
902 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
903
904 const uint8_t data[] = {
905 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
906 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
907
908 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
909 0x03, 'c', 'o', 'm',
910 0x00,
911 /* TXT */ 0x00, 0x10,
912 /* IN */ 0x00, 0x01,
913 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
914 /* rdata */ 0x00, 0x09,
915 0x02, 'h', 'i',
916 0x05, 'w', 'o', 'r', 'l', 'd'
917 };
918
919 ASSERT_EQ(packet->size, sizeof(data));
920 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
921 }
922
923 TEST(packet_append_answer_single_loc) {
924 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
925 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
926 DnsResourceRecord *rr = NULL;
927
928 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_LOC, "example.com");
929 ASSERT_NOT_NULL(rr);
930 rr->ttl = 3601;
931 rr->loc.version = 0;
932 rr->loc.size = 0x29;
933 rr->loc.horiz_pre = 0x34;
934 rr->loc.vert_pre = 0x53;
935 rr->loc.latitude = 2332887285;
936 rr->loc.longitude = 2146974024;
937 rr->loc.altitude = 10000000;
938
939 answer = dns_answer_new(1);
940 ASSERT_NOT_NULL(answer);
941 dns_answer_add(answer, rr, 1, 0, NULL);
942 dns_resource_record_unref(rr);
943
944 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
945 ASSERT_NOT_NULL(packet);
946
947 DNS_PACKET_ID(packet) = htobe16(42);
948 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
949 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
950
951 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
952
953 const uint8_t data[] = {
954 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
955 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
956
957 /* name */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
958 0x03, 'c', 'o', 'm',
959 0x00,
960 /* LOC */ 0x00, 0x1d,
961 /* IN */ 0x00, 0x01,
962 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
963 /* rdata */ 0x00, 0x10,
964 /* version */ 0x00,
965 /* size */ 0x29,
966 /* horiz pre */ 0x34,
967 /* vert pre */ 0x53,
968 /* latitude */ 0x8b, 0x0d, 0x08, 0xf5,
969 /* longitude */ 0x7f, 0xf8, 0x39, 0x48,
970 /* altitude */ 0x00, 0x98, 0x96, 0x80
971 };
972
973 ASSERT_EQ(packet->size, sizeof(data));
974 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
975 }
976
977 TEST(packet_append_answer_single_srv) {
978 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
979 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
980 DnsResourceRecord *rr = NULL;
981
982 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SRV, "_ldap._tcp.example.com");
983 ASSERT_NOT_NULL(rr);
984 rr->ttl = 3601;
985 rr->srv.priority = 17185;
986 rr->srv.weight = 25976;
987 rr->srv.port = 389;
988 rr->srv.name = strdup("cloud.example.com");
989
990 answer = dns_answer_new(1);
991 ASSERT_NOT_NULL(answer);
992 dns_answer_add(answer, rr, 1, 0, NULL);
993 dns_resource_record_unref(rr);
994
995 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
996 ASSERT_NOT_NULL(packet);
997
998 DNS_PACKET_ID(packet) = htobe16(42);
999 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
1000 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
1001
1002 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
1003
1004 const uint8_t data[] = {
1005 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
1006 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1007
1008 /* name */ 0x05, '_', 'l', 'd', 'a', 'p',
1009 0x04, '_', 't', 'c', 'p',
1010 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1011 0x03, 'c', 'o', 'm',
1012 0x00,
1013 /* SRV */ 0x00, 0x21,
1014 /* IN */ 0x00, 0x01,
1015 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
1016 /* rdata */ 0x00, 0x19,
1017 /* priority */ 0x43, 0x21,
1018 /* weight */ 0x65, 0x78,
1019 /* port */ 0x01, 0x85,
1020 /* name */ 0x05, 'c', 'l', 'o', 'u', 'd',
1021 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1022 0x03, 'c', 'o', 'm',
1023 0x00
1024 };
1025
1026 ASSERT_EQ(packet->size, sizeof(data));
1027 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
1028 }
1029
1030 TEST(packet_append_answer_single_naptr) {
1031 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1032 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
1033 DnsResourceRecord *rr = NULL;
1034
1035 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");
1036 ASSERT_NOT_NULL(rr);
1037 rr->ttl = 3601;
1038 rr->naptr.order = 102;
1039 rr->naptr.preference = 10;
1040 rr->naptr.flags = strdup("U");
1041 rr->naptr.services = strdup("E2U+sip");
1042 rr->naptr.regexp = strdup("!^.*$!sip:[email protected]!");
1043 rr->naptr.replacement = strdup("_sip._udp.example.com");
1044
1045 answer = dns_answer_new(1);
1046 ASSERT_NOT_NULL(answer);
1047 dns_answer_add(answer, rr, 1, 0, NULL);
1048 dns_resource_record_unref(rr);
1049
1050 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1051 ASSERT_NOT_NULL(packet);
1052
1053 DNS_PACKET_ID(packet) = htobe16(42);
1054 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
1055 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
1056
1057 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
1058
1059 const uint8_t data[] = {
1060 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
1061 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1062
1063 /* name */ 0x01, '4', 0x01, '3', 0x01, '2', 0x01, '1',
1064 0x01, '5', 0x01, '5', 0x01, '5',
1065 0x01, '0', 0x01, '0', 0x01, '8', 0x01, '1',
1066 0x04, 'e', '1', '6', '4',
1067 0x04, 'a', 'r', 'p', 'a',
1068 0x00,
1069 /* NAPTR */ 0x00, 0x23,
1070 /* IN */ 0x00, 0x01,
1071 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
1072 /* rdata */ 0x00, 0x4d,
1073 /* order */ 0x00, 0x66,
1074 /* pref */ 0x00, 0x0a,
1075 /* flags */ 0x01, 'U',
1076 /* services */ 0x07, 'E', '2', 'U', '+', 's', 'i', 'p',
1077 /* regexp */ 0x27,
1078 '!', '^', '.', '*', '$', '!', 's', 'i',
1079 'p', ':', 'c', 'u', 's', 't', 'o', 'm',
1080 'e', 'r', '-', 's', 'e', 'r', 'v', 'i',
1081 'c', 'e', '@', 'e', 'x', 'a', 'm', 'p',
1082 'l', 'e', '.', 'c', 'o', 'm', '!',
1083 /* replace */ 0x04, '_', 's', 'i', 'p',
1084 0x04, '_', 'u', 'd', 'p',
1085 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1086 0x03, 'c', 'o', 'm',
1087 0x00
1088 };
1089
1090 ASSERT_EQ(packet->size, sizeof(data));
1091 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
1092 }
1093
1094 TEST(packet_append_answer_rrsig_with_a) {
1095 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1096 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
1097 DnsResourceRecord *rr = NULL;
1098
1099 answer = dns_answer_new(2);
1100 ASSERT_NOT_NULL(answer);
1101
1102 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, "www.example.com");
1103 ASSERT_NOT_NULL(rr);
1104 rr->ttl = 3601;
1105 rr->a.in_addr.s_addr = htobe32(0xc0a8017f);
1106
1107 dns_answer_add(answer, rr, 1, 0, NULL);
1108 dns_resource_record_unref(rr);
1109
1110 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_RRSIG, "www.example.com");
1111 ASSERT_NOT_NULL(rr);
1112 rr->ttl = 3601;
1113 rr->rrsig.type_covered = DNS_TYPE_A;
1114 rr->rrsig.algorithm = DNSSEC_ALGORITHM_ECC;
1115 rr->rrsig.labels = 3;
1116 rr->rrsig.original_ttl = 3600;
1117 rr->rrsig.expiration = 1720361303;
1118 rr->rrsig.inception = 1717769303;
1119 rr->rrsig.key_tag = 0x1234;
1120 rr->rrsig.signer = strdup("example.com");
1121
1122 const uint8_t signature[] = {
1123 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
1124 };
1125 rr->rrsig.signature_size = sizeof(signature);
1126 rr->rrsig.signature = memdup(signature, rr->rrsig.signature_size);
1127
1128 dns_answer_add(answer, rr, 1, 0, NULL);
1129 dns_resource_record_unref(rr);
1130
1131 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1132 ASSERT_NOT_NULL(packet);
1133
1134 DNS_PACKET_ID(packet) = htobe16(42);
1135 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
1136 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
1137
1138 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
1139
1140 const uint8_t data[] = {
1141 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
1142 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
1143
1144 /* name */ 0x03, 'w', 'w', 'w',
1145 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1146 0x03, 'c', 'o', 'm',
1147 0x00,
1148 /* A */ 0x00, 0x01,
1149 /* IN */ 0x00, 0x01,
1150 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
1151 /* rdata */ 0x00, 0x04,
1152 /* ip */ 0xc0, 0xa8, 0x01, 0x7f,
1153
1154 /* name */ 0xc0, 0x0c,
1155 /* RRSIG */ 0x00, 0x2e,
1156 /* IN */ 0x00, 0x01,
1157 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
1158 /* rdata */ 0x00, 0x27,
1159 /* type */ 0x00, 0x01,
1160 /* algo */ 0x04,
1161 /* labels */ 0x03,
1162 /* orig ttl */ 0x00, 0x00, 0x0e, 0x10,
1163 /* expiry */ 0x66, 0x8a, 0xa1, 0x57,
1164 /* inception */ 0x66, 0x63, 0x14, 0x57,
1165 /* key tag */ 0x12, 0x34,
1166 /* signer */ 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1167 0x03, 'c', 'o', 'm',
1168 0x00,
1169 /* signature */ 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
1170 };
1171
1172 ASSERT_EQ(packet->size, sizeof(data));
1173 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
1174 }
1175
1176 static DnsSvcParam* add_svcb_param(DnsResourceRecord *rr, uint16_t key, const char *value, size_t len) {
1177 DnsSvcParam *param = calloc(1, offsetof(DnsSvcParam, value) + len);
1178 ASSERT_NOT_NULL(param);
1179
1180 param->key = key;
1181 param->length = len;
1182
1183 if (value)
1184 memcpy(param->value, value, len);
1185
1186 LIST_APPEND(params, rr->svcb.params, param);
1187 return param;
1188 }
1189
1190 TEST(packet_append_answer_single_svcb) {
1191 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1192 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
1193 DnsResourceRecord *rr = NULL;
1194 DnsSvcParam *param = NULL;
1195
1196 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_SVCB, "_443._wss.example.com");
1197 ASSERT_NOT_NULL(rr);
1198 rr->ttl = 3601;
1199 rr->svcb.priority = 9;
1200 rr->svcb.target_name = strdup("sock.example.com");
1201
1202 add_svcb_param(rr, DNS_SVC_PARAM_KEY_MANDATORY, "\x00\x01\x00\x03", 4);
1203 add_svcb_param(rr, DNS_SVC_PARAM_KEY_ALPN, "\x09websocket", 10);
1204 add_svcb_param(rr, DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN, NULL, 0);
1205 add_svcb_param(rr, DNS_SVC_PARAM_KEY_PORT, "\x01\xbb", 2);
1206
1207 param = add_svcb_param(rr, DNS_SVC_PARAM_KEY_IPV4HINT, NULL, 2 * sizeof(struct in_addr));
1208 param->value_in_addr[0].s_addr = htobe32(0x7284fd3a);
1209 param->value_in_addr[1].s_addr = htobe32(0x48bcc7c0);
1210
1211 param = add_svcb_param(rr, DNS_SVC_PARAM_KEY_IPV6HINT, NULL, sizeof(struct in6_addr));
1212 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 } };
1213
1214 answer = dns_answer_new(1);
1215 ASSERT_NOT_NULL(answer);
1216 dns_answer_add(answer, rr, 1, 0, NULL);
1217 dns_resource_record_unref(rr);
1218
1219 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1220 ASSERT_NOT_NULL(packet);
1221
1222 DNS_PACKET_ID(packet) = htobe16(42);
1223 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(1, 0, 1, 0, 1, 1, 0, 0, DNS_RCODE_SUCCESS));
1224 DNS_PACKET_HEADER(packet)->ancount = htobe16(dns_answer_size(answer));
1225
1226 ASSERT_OK(dns_packet_append_answer(packet, answer, NULL));
1227
1228 const uint8_t data[] = {
1229 0x00, 0x2a, BIT_QR | BIT_AA | BIT_RD, BIT_RA | DNS_RCODE_SUCCESS,
1230 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
1231
1232 /* name */ 0x04, '_', '4', '4', '3',
1233 0x04, '_', 'w', 's', 's',
1234 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1235 0x03, 'c', 'o', 'm',
1236 0x00,
1237 /* SVCB */ 0x00, 0x40,
1238 /* IN */ 0x00, 0x01,
1239 /* ttl */ 0x00, 0x00, 0x0e, 0x11,
1240 /* rdata */ 0x00, 0x54,
1241 /* priority */ 0x00, 0x09,
1242 /* target */ 0x04, 's', 'o', 'c', 'k',
1243 0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e',
1244 0x03, 'c', 'o', 'm',
1245 0x00,
1246 /* mandatory */ 0x00, 0x00,
1247 0x00, 0x04,
1248 0x00, 0x01, 0x00, 0x03,
1249 /* alpn */ 0x00, 0x01,
1250 0x00, 0x0a,
1251 0x09, 'w', 'e', 'b', 's', 'o', 'c', 'k', 'e', 't',
1252 /* no-deflt */ 0x00, 0x02,
1253 0x00, 0x00,
1254 /* port */ 0x00, 0x03,
1255 0x00, 0x02,
1256 0x01, 0xbb,
1257 /* ipv4hint */ 0x00, 0x04,
1258 0x00, 0x08,
1259 0x72, 0x84, 0xfd, 0x3a,
1260 0x48, 0xbc, 0xc7, 0xc0,
1261 /* ipv6hint */ 0x00, 0x06,
1262 0x00, 0x10,
1263 0xf2, 0x34, 0x32, 0x2e, 0xb8, 0x25, 0x38, 0x35,
1264 0x2f, 0xd7, 0xdb, 0x7b, 0x28, 0x7e, 0x60, 0xbb
1265 };
1266
1267 ASSERT_EQ(packet->size, sizeof(data));
1268 ASSERT_EQ(memcmp(DNS_PACKET_DATA(packet), data, sizeof(data)), 0);
1269 }
1270
1271 static void dump_packet_data(DnsPacket *packet) {
1272 assert(packet);
1273 fprintf(stderr, "packet bytes:");
1274 for (size_t i = 0; i < packet->size; i++)
1275 fprintf(stderr, " %x", DNS_PACKET_DATA(packet)[i]);
1276 fprintf(stderr, "\n");
1277 }
1278
1279 TEST(packet_append_key_name_too_long) {
1280 _cleanup_(dns_packet_unrefp) DnsPacket *packet = NULL;
1281 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1282 int r;
1283
1284 ASSERT_OK(dns_packet_new(&packet, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX));
1285
1286 DNS_PACKET_ID(packet) = htobe16(42);
1287 DNS_PACKET_HEADER(packet)->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, 0));
1288 DNS_PACKET_HEADER(packet)->qdcount = htobe16(1);
1289
1290 key = ASSERT_PTR(dns_resource_key_new(DNS_CLASS_IN, DNS_TYPE_A, "www.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com"));
1291 r = dns_packet_append_key(packet, key, 0, NULL);
1292
1293 log_debug("r = %d, size = %zu", r, packet->size);
1294 log_debug("key name = <%s>", dns_resource_key_name(key));
1295 dump_packet_data(packet);
1296
1297 ASSERT_EQ(r, -EINVAL);
1298 ASSERT_EQ(packet->size, 12U);
1299 }
1300
1301 DEFINE_TEST_MAIN(LOG_DEBUG)