[infiniband] Retrieve GID flag from cached path entries
[ipxe.git] / src / tests / dns_test.c
1 /*
2 * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 /** @file
27 *
28 * DNS self-tests
29 *
30 */
31
32 /* Forcibly enable assertions */
33 #undef NDEBUG
34
35 #include <string.h>
36 #include <assert.h>
37 #include <ipxe/dns.h>
38 #include <ipxe/test.h>
39
40 /** Define inline data */
41 #define DATA(...) { __VA_ARGS__ }
42
43 /** A DNS encoding test */
44 struct dns_encode_test {
45 /** String */
46 const char *string;
47 /** Encoded string */
48 const void *data;
49 /** Length of encoded string */
50 int len;
51 };
52
53 /**
54 * Define a DNS encoding test
55 *
56 * @v _name Test name
57 * @v _string Test string
58 * @v _data Expected encoded data
59 * @ret test DNS encoding test
60 */
61 #define DNS_ENCODE( _name, _string, _data ) \
62 static const uint8_t _name ## __data[] = _data; \
63 static struct dns_encode_test _name = { \
64 .string = _string, \
65 .data = _name ## __data, \
66 .len = sizeof ( _name ## __data ), \
67 }
68
69 /**
70 * Report DNS encoding test result
71 *
72 * @v test DNS encoding test
73 * @v file Test code file
74 * @v line Test code line
75 */
76 static void dns_encode_okx ( struct dns_encode_test *test, const char *file,
77 unsigned int line ) {
78 uint8_t data[ test->len ];
79 struct dns_name name;
80 int len;
81
82 /* Check ability to determine length with no buffer */
83 memset ( &name, 0, sizeof ( name ) );
84 len = dns_encode ( test->string, &name );
85 okx ( len >= 0, file, line );
86 okx ( len == test->len, file, line );
87
88 /* Check encoded name */
89 name.data = data;
90 name.len = sizeof ( data );
91 len = dns_encode ( test->string, &name );
92 okx ( len >= 0, file, line );
93 if ( len >= 0 ) {
94 okx ( len == test->len, file, line );
95 okx ( memcmp ( data, test->data, test->len ) == 0, file, line );
96 DBGC ( test, "DNS encoded \"%s\" to:\n", test->string );
97 DBGC_HDA ( test, 0, data, len );
98 }
99 }
100 #define dns_encode_ok( test ) dns_encode_okx ( test, __FILE__, __LINE__ )
101
102 /**
103 * Report DNS encoding failure test result
104 *
105 * @v test DNS encoding test
106 * @v file Test code file
107 * @v line Test code line
108 */
109 static void dns_encode_fail_okx ( struct dns_encode_test *test,
110 const char *file, unsigned int line ) {
111 struct dns_name name = { .data = NULL, .len = 0 };
112 int len;
113
114 len = dns_encode ( test->string, &name );
115 okx ( len < 0, file, line );
116 }
117 #define dns_encode_fail_ok( test ) \
118 dns_encode_fail_okx ( test, __FILE__, __LINE__ )
119
120 /** A DNS decoding test */
121 struct dns_decode_test {
122 /** Name */
123 struct dns_name name;
124 /** Expected string */
125 const char *string;
126 };
127
128 /**
129 * Define a DNS decoding test
130 *
131 * @v _name Test name
132 * @v _data RFC1035-encoded data
133 * @v _offset Starting offset within encoded data
134 * @v _string Expected decoded string
135 * @ret test DNS decoding test
136 */
137 #define DNS_DECODE( _name, _data, _offset, _string ) \
138 static uint8_t _name ## __data[] = _data; \
139 static struct dns_decode_test _name = { \
140 .name = { \
141 .data = _name ## __data, \
142 .offset = _offset, \
143 .len = sizeof ( _name ## __data ), \
144 }, \
145 .string = _string, \
146 }
147
148 /**
149 * Report DNS decoding test result
150 *
151 * @v test DNS decoding test
152 * @v file Test code file
153 * @v line Test code line
154 */
155 static void dns_decode_okx ( struct dns_decode_test *test, const char *file,
156 unsigned int line ) {
157 char string[ strlen ( test->string ) + 1 /* NUL */ ];
158 int len;
159
160 /* Check ability to determine length with no buffer */
161 len = dns_decode ( &test->name, NULL, 0 );
162 okx ( len >= 0, file, line );
163 okx ( len == ( ( int ) strlen ( test->string ) ), file, line );
164
165 /* Check decoded string */
166 len = dns_decode ( &test->name, string, sizeof ( string ) );
167 okx ( len >= 0, file, line );
168 if ( len >= 0 ) {
169 okx ( strcmp ( string, test->string ) == 0, file, line );
170 DBGC ( test, "DNS decoded \"%s\" from offset %#zx in:\n",
171 string, test->name.offset );
172 DBGC_HDA ( test, 0, test->name.data, test->name.len );
173 }
174 }
175 #define dns_decode_ok( test ) dns_decode_okx ( test, __FILE__, __LINE__ )
176
177 /**
178 * Report DNS decoding failure test result
179 *
180 * @v test DNS decoding test
181 * @v file Test code file
182 * @v line Test code line
183 */
184 static void dns_decode_fail_okx ( struct dns_decode_test *test,
185 const char *file, unsigned int line ) {
186 int len;
187
188 len = dns_decode ( &test->name, NULL, 0 );
189 okx ( len < 0, file, line );
190 }
191 #define dns_decode_fail_ok( test ) \
192 dns_decode_fail_okx ( test, __FILE__, __LINE__ )
193
194 /** A DNS comparison test */
195 struct dns_compare_test {
196 /** First name */
197 struct dns_name first;
198 /** Second name */
199 struct dns_name second;
200 };
201
202 /**
203 * Define a DNS comparison test
204 *
205 * @v _name Test name
206 * @v _first_data First RFC1035-encoded data
207 * @v _first_offset Starting offset within first encoded data
208 * @v _second_data Second RFC1035-encoded data
209 * @v _second_offset Starting offset within second encoded data
210 * @ret test DNS comparison test
211 */
212 #define DNS_COMPARE( _name, _first_data, _first_offset, _second_data, \
213 _second_offset ) \
214 static uint8_t _name ## __first_data[] = _first_data; \
215 static uint8_t _name ## __second_data[] = _second_data; \
216 static struct dns_compare_test _name = { \
217 .first = { \
218 .data = _name ## __first_data, \
219 .offset = _first_offset, \
220 .len = sizeof ( _name ## __first_data ), \
221 }, \
222 .second = { \
223 .data = _name ## __second_data, \
224 .offset = _second_offset, \
225 .len = sizeof ( _name ## __second_data ), \
226 }, \
227 }
228
229 /**
230 * Report DNS comparison test result
231 *
232 * @v test DNS comparison test
233 * @v file Test code file
234 * @v line Test code line
235 */
236 static void dns_compare_okx ( struct dns_compare_test *test, const char *file,
237 unsigned int line ) {
238
239 okx ( dns_compare ( &test->first, &test->second ) == 0, file, line );
240 }
241 #define dns_compare_ok( test ) dns_compare_okx ( test, __FILE__, __LINE__ )
242
243 /**
244 * Report DNS comparison test failure result
245 *
246 * @v test DNS comparison test
247 * @v file Test code file
248 * @v line Test code line
249 */
250 static void dns_compare_fail_okx ( struct dns_compare_test *test,
251 const char *file, unsigned int line ) {
252
253 okx ( dns_compare ( &test->first, &test->second ) != 0, file, line );
254 }
255 #define dns_compare_fail_ok( test ) \
256 dns_compare_fail_okx ( test, __FILE__, __LINE__ )
257
258 /** A DNS copying test */
259 struct dns_copy_test {
260 /** Source name */
261 struct dns_name src;
262 /** Expected copied name */
263 struct dns_name dst;
264 };
265
266 /**
267 * Define a DNS copying test
268 *
269 * @v _name Test name
270 * @v _src_data Source RFC1035-encoded data
271 * @v _src_offset Starting offset within source encoded data
272 * @v _dst_data Expected copied RFC1035-encoded data
273 * @v _dst_offset Starting offset withint copied encoded data
274 * @ret test DNS copying test
275 */
276 #define DNS_COPY( _name, _src_data, _src_offset, _dst_data, \
277 _dst_offset ) \
278 static uint8_t _name ## __src_data[] = _src_data; \
279 static uint8_t _name ## __dst_data[] = _dst_data; \
280 static struct dns_copy_test _name = { \
281 .src = { \
282 .data = _name ## __src_data, \
283 .offset = _src_offset, \
284 .len = sizeof ( _name ## __src_data ), \
285 }, \
286 .dst = { \
287 .data = _name ## __dst_data, \
288 .offset = _dst_offset, \
289 .len = sizeof ( _name ## __dst_data ), \
290 }, \
291 }
292
293 /**
294 * Report a DNS copying test result
295 *
296 * @v test DNS copying test
297 * @v file Test code file
298 * @v line Test code line
299 */
300 static void dns_copy_okx ( struct dns_copy_test *test,
301 const char *file, unsigned int line ) {
302 uint8_t data[ test->dst.len ];
303 struct dns_name dst;
304 int len;
305
306 /* Check ability to determine length with no buffer */
307 memset ( &dst, 0, sizeof ( dst ) );
308 len = dns_copy ( &test->src, &dst );
309 okx ( len >= 0, file, line );
310 okx ( len == ( ( int ) ( test->dst.len - test->dst.offset ) ),
311 file, line );
312
313 /* Check copied name */
314 dst.data = data;
315 dst.offset = test->dst.offset;
316 dst.len = sizeof ( data );
317 memcpy ( dst.data, test->dst.data, test->dst.offset );
318 len = dns_copy ( &test->src, &dst );
319 okx ( len >= 0, file, line );
320 okx ( len == ( ( int ) ( test->dst.len - test->dst.offset ) ),
321 file, line );
322 okx ( memcmp ( data, test->dst.data, sizeof ( data ) ) == 0,
323 file, line );
324 DBGC ( test, "DNS copied:\n" );
325 DBGC_HDA ( test, 0, test->src.data, test->src.len );
326 DBGC_HDA ( test, 0, data, ( test->dst.offset + len ) );
327 }
328 #define dns_copy_ok( test ) dns_copy_okx ( test, __FILE__, __LINE__ )
329
330 /**
331 * Report a DNS copying failure test result
332 *
333 * @v test DNS copying test
334 * @v file Test code file
335 * @v line Test code line
336 */
337 static void dns_copy_fail_okx ( struct dns_copy_test *test,
338 const char *file, unsigned int line ) {
339 struct dns_name dst;
340 int len;
341
342 memset ( &dst, 0, sizeof ( dst ) );
343 len = dns_copy ( &test->src, &dst );
344 okx ( len < 0, file, line );
345 }
346 #define dns_copy_fail_ok( test ) dns_copy_fail_okx ( test, __FILE__, __LINE__ )
347
348 /** A DNS search list test */
349 struct dns_list_test {
350 /** Search list */
351 struct dns_name list;
352 /** Expected decoded search list */
353 const char **strings;
354 /** Number of expected decoded string */
355 unsigned int count;
356 };
357
358 /**
359 * Define a DNS search list test
360 *
361 * @v _name Test name
362 * @v _list RFC1035-encoded data
363 * @v _strings Expected decoded strings
364 * @ret test DNS search list test
365 */
366 #define DNS_LIST( _name, _list, _strings ) \
367 static uint8_t _name ## __list[] = _list; \
368 static const char * _name ## __strings[] = _strings; \
369 static struct dns_list_test _name = { \
370 .list = { \
371 .data = _name ## __list, \
372 .offset = 0, \
373 .len = sizeof ( _name ## __list ), \
374 }, \
375 .strings = _name ## __strings, \
376 .count = ( sizeof ( _name ## __strings ) / \
377 sizeof ( _name ## __strings[0] ) ), \
378 }
379
380 /**
381 * Report DNS search list test result
382 *
383 * @v test DNS search list test
384 * @v file Test code file
385 * @v line Test code line
386 */
387 static void dns_list_okx ( struct dns_list_test *test, const char *file,
388 unsigned int line ) {
389 struct dns_name name;
390 unsigned int i;
391
392 DBGC ( test, "DNS search list:\n" );
393 DBGC_HDA ( test, 0, test->list.data, test->list.len );
394 memcpy ( &name, &test->list, sizeof ( name ) );
395 for ( i = 0 ; i < test->count ; i++ ) {
396 char buf[ strlen ( test->strings[i] ) + 1 /* NUL */ ];
397 int len;
398 int offset;
399
400 /* Decode this name */
401 len = dns_decode ( &name, buf, sizeof ( buf ) );
402 okx ( len >= 0, file, line );
403 if ( len >= 0 ) {
404 okx ( len == ( ( int ) strlen ( test->strings[i] ) ),
405 file, line );
406 okx ( strcmp ( buf, test->strings[i] ) == 0,
407 file, line );
408 DBGC ( test, "DNS search list found \"%s\" at offset "
409 "%#zx\n", buf, name.offset );
410 }
411
412 /* Skip to next name */
413 offset = dns_skip ( &name );
414 okx ( offset >= 0, file, line );
415 name.offset = offset;
416 }
417
418 /* Check that we have consumed the whole search list */
419 okx ( name.offset == name.len, file, line );
420 }
421 #define dns_list_ok( test ) dns_list_okx ( test, __FILE__, __LINE__ )
422
423 /* Simple encoding test */
424 DNS_ENCODE ( encode_simple, "ipxe.org",
425 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ) );
426
427 /* Single-word encoding test */
428 DNS_ENCODE ( encode_single, "foo", DATA ( 3, 'f', 'o', 'o', 0 ) );
429
430 /* Absolute encoding test */
431 DNS_ENCODE ( encode_absolute, "git.ipxe.org.",
432 DATA ( 3, 'g', 'i', 't', 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g',
433 0 ) );
434
435 /* Empty string encoding test */
436 DNS_ENCODE ( encode_empty, "", DATA ( 0 ) );
437
438 /* Root domain encoding test */
439 DNS_ENCODE ( encode_root, ".", DATA ( 0 ) );
440
441 /* Invalid initial dot encoding test */
442 DNS_ENCODE ( encode_initial_dot, ".foo", DATA() );
443
444 /* Invalid double dot encoding test */
445 DNS_ENCODE ( encode_double_dot, "ipxe..org", DATA() );
446
447 /* Invalid solo double dot encoding test */
448 DNS_ENCODE ( encode_solo_double_dot, "..", DATA() );
449
450 /* Invalid trailing double dot encoding test */
451 DNS_ENCODE ( encode_trailing_double_dot, "ipxe.org..", DATA() );
452
453 /* Invalid overlength label encoding test */
454 DNS_ENCODE ( encode_overlength,
455 "this-label-is-maliciously-long-in-an-attempt-to-overflow-the-"
456 "length-field-and-generate-a-length-which-looks-like-a-"
457 "compression-pointer", DATA() );
458
459 /* Simple decoding test */
460 DNS_DECODE ( decode_simple,
461 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
462 "ipxe.org" );
463
464 /* Compression pointer decoding test */
465 DNS_DECODE ( decode_ptr,
466 DATA ( 3, 'o', 'r', 'g', 0, 3, 'g', 'i', 't', 4, 'i', 'p', 'x',
467 'e', 0xc0, 0x00 ), 5,
468 "git.ipxe.org" );
469
470 /* Root decoding test */
471 DNS_DECODE ( decode_root,
472 DATA ( 0 ), 0, "" );
473
474 /* Incomplete name decoding test */
475 DNS_DECODE ( decode_incomplete_name,
476 DATA ( 4, 'i', 'p', 'x', 'e' ), 0, NULL );
477
478 /* Incomplete label decoding test */
479 DNS_DECODE ( decode_incomplete_label,
480 DATA ( 4, 'i', 'p', 'x' ), 0, NULL );
481
482 /* Incomplete compression pointer decoding test */
483 DNS_DECODE ( decode_incomplete_ptr,
484 DATA ( 3, 'o', 'r', 'g', 0, 4, 'i', 'p', 'x', 'e', 0xc0 ), 5,
485 NULL );
486
487 /* Forward reference decoding test */
488 DNS_DECODE ( decode_forward,
489 DATA ( 0xc0, 0x02, 3, 'f', 'o', 'o', 0 ), 0, NULL );
490
491 /* Infinite loop decoding test */
492 DNS_DECODE ( decode_infinite,
493 DATA ( 4, 'i', 'p', 'x', 'e', 0xc0, 0x00 ), 0, NULL );
494
495 /* Empty decoding test */
496 DNS_DECODE ( decode_empty,
497 DATA (), 0, NULL );
498
499 /* Simple comparison test */
500 DNS_COMPARE ( compare_simple,
501 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
502 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0 );
503
504 /* Compression pointer comparison test */
505 DNS_COMPARE ( compare_ptr,
506 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
507 DATA ( 3, 'o', 'r', 'g', 0, 4, 'i', 'p', 'x', 'e',
508 0xc0, 0x00 ), 5 );
509
510 /* Case insensitive comparison test */
511 DNS_COMPARE ( compare_case,
512 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
513 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'O', 'R', 'G', 0 ), 0 );
514
515 /* Mismatch comparison test */
516 DNS_COMPARE ( compare_mismatch,
517 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
518 DATA ( 4, 'g', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0 );
519
520 /* Infinite loop comparison test */
521 DNS_COMPARE ( compare_infinite,
522 DATA ( 3, 'f', 'o', 'o', 0xc0, 0x00 ), 0,
523 DATA ( 3, 'f', 'o', 'o', 0xc0, 0x00 ), 0 );
524
525 /* Simple copying test */
526 DNS_COPY ( copy_simple,
527 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
528 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0 );
529
530 /* Simple copying test with offset */
531 DNS_COPY ( copy_offset,
532 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0 ), 0,
533 DATA ( 'f', 'o', 'o', 0, 4, 'i', 'p', 'x', 'e',
534 3, 'o', 'r', 'g', 0 ), 4 );
535
536 /* Compression pointer copying test */
537 DNS_COPY ( copy_ptr,
538 DATA ( 3, 'o', 'r', 'g', 0, 3, 'g', 'i', 't', 4, 'i', 'p', 'x', 'e',
539 0xc0, 0x00 ), 5,
540 DATA ( 3, 'g', 'i', 't', 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g',
541 0 ), 0 );
542
543 /* Infinite loop copying test */
544 DNS_COPY ( copy_infinite,
545 DATA ( 4, 'l', 'o', 'o', 'p', 7, 'f', 'o', 'r', 'e', 'v', 'e', 'r',
546 0xc0, 0x05 ), 0,
547 DATA (), 0 );
548
549 /* DNS search list test */
550 DNS_LIST ( search,
551 DATA ( 4, 'i', 'p', 'x', 'e', 3, 'o', 'r', 'g', 0,
552 4, 'b', 'o', 'o', 't', 0xc0, 0x00,
553 3, 'd', 'e', 'v', 0xc0, 0x0a,
554 11, 'n', 'e', 't', 'w', 'o', 'r', 'k', 'b', 'o', 'o', 't',
555 0xc0, 0x05 ),
556 DATA ( "ipxe.org", "boot.ipxe.org", "dev.boot.ipxe.org",
557 "networkboot.org" ) );
558
559 /**
560 * Perform DNS self-test
561 *
562 */
563 static void dns_test_exec ( void ) {
564
565 /* Encoding tests */
566 dns_encode_ok ( &encode_simple );
567 dns_encode_ok ( &encode_single );
568 dns_encode_ok ( &encode_absolute );
569 dns_encode_ok ( &encode_empty );
570 dns_encode_ok ( &encode_root );
571 dns_encode_fail_ok ( &encode_initial_dot );
572 dns_encode_fail_ok ( &encode_double_dot );
573 dns_encode_fail_ok ( &encode_solo_double_dot );
574 dns_encode_fail_ok ( &encode_trailing_double_dot );
575 dns_encode_fail_ok ( &encode_overlength );
576
577 /* Decoding tests */
578 dns_decode_ok ( &decode_simple );
579 dns_decode_ok ( &decode_ptr );
580 dns_decode_ok ( &decode_root );
581 dns_decode_fail_ok ( &decode_incomplete_name );
582 dns_decode_fail_ok ( &decode_incomplete_label );
583 dns_decode_fail_ok ( &decode_incomplete_ptr );
584 dns_decode_fail_ok ( &decode_forward );
585 dns_decode_fail_ok ( &decode_infinite );
586 dns_decode_fail_ok ( &decode_empty );
587
588 /* Comparison tests */
589 dns_compare_ok ( &compare_simple );
590 dns_compare_ok ( &compare_ptr );
591 dns_compare_ok ( &compare_case );
592 dns_compare_fail_ok ( &compare_mismatch );
593 dns_compare_fail_ok ( &compare_infinite );
594
595 /* Copying tests */
596 dns_copy_ok ( &copy_simple );
597 dns_copy_ok ( &copy_offset );
598 dns_copy_ok ( &copy_ptr );
599 dns_copy_fail_ok ( &copy_infinite );
600
601 /* Search list tets */
602 dns_list_ok ( &search );
603 }
604
605 /** DNS self-test */
606 struct self_test dns_test __self_test = {
607 .name = "dns",
608 .exec = dns_test_exec,
609 };