iPXE
dns_test.c
Go to the documentation of this file.
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 */
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  */
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 */
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  */
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 */
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  */
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 */
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 */
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 };
unsigned int count
Number of expected decoded string.
Definition: dns_test.c:355
const char * string
String.
Definition: dns_test.c:46
const char * name
Definition: ath9k_hw.c:1984
int dns_skip(struct dns_name *name)
Skip RFC1035-encoded DNS name.
Definition: dns.c:352
static void dns_list_okx(struct dns_list_test *test, const char *file, unsigned int line)
Report DNS search list test result.
Definition: dns_test.c:387
const char ** strings
Expected decoded search list.
Definition: dns_test.c:353
#define dns_list_ok(test)
Definition: dns_test.c:421
A DNS comparison test.
Definition: dns_test.c:195
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
#define DBGC(...)
Definition: compiler.h:505
const char * string
Expected string.
Definition: dns_test.c:125
Self-test infrastructure.
const char * name
Test set name.
Definition: test.h:17
static void dns_encode_okx(struct dns_encode_test *test, const char *file, unsigned int line)
Report DNS encoding test result.
Definition: dns_test.c:76
void * data
Start of data.
Definition: dns.h:21
A DNS encoding test.
Definition: dns_test.c:44
struct dns_name name
Name.
Definition: dns_test.c:123
A self-test set.
Definition: test.h:15
#define dns_copy_ok(test)
Definition: dns_test.c:328
static void dns_decode_fail_okx(struct dns_decode_test *test, const char *file, unsigned int line)
Report DNS decoding failure test result.
Definition: dns_test.c:184
static void dns_compare_fail_okx(struct dns_compare_test *test, const char *file, unsigned int line)
Report DNS comparison test failure result.
Definition: dns_test.c:250
struct dns_name src
Source name.
Definition: dns_test.c:261
#define DNS_LIST(_name, _list, _strings)
Define a DNS search list test.
Definition: dns_test.c:366
void * memcpy(void *dest, const void *src, size_t len) __nonnull
static void dns_compare_okx(struct dns_compare_test *test, const char *file, unsigned int line)
Report DNS comparison test result.
Definition: dns_test.c:236
#define okx(success, file, line)
Report test result.
Definition: test.h:44
Assertions.
An RFC1035-encoded DNS name.
Definition: dns.h:19
#define DBGC_HDA(...)
Definition: compiler.h:506
static userptr_t size_t offset
Offset of the first segment within the content.
Definition: deflate.h:259
static void dns_copy_fail_okx(struct dns_copy_test *test, const char *file, unsigned int line)
Report a DNS copying failure test result.
Definition: dns_test.c:337
#define DATA(...)
Define inline data.
Definition: dns_test.c:41
size_t offset
Offset of name within data.
Definition: dns.h:23
#define DNS_COMPARE(_name, _first_data, _first_offset, _second_data, _second_offset)
Define a DNS comparison test.
Definition: dns_test.c:212
A DNS copying test.
Definition: dns_test.c:259
#define DNS_COPY(_name, _src_data, _src_offset, _dst_data, _dst_offset)
Define a DNS copying test.
Definition: dns_test.c:276
struct dns_name first
First name.
Definition: dns_test.c:197
const void * data
Encoded string.
Definition: dns_test.c:48
int dns_copy(struct dns_name *src, struct dns_name *dst)
Copy a DNS name.
Definition: dns.c:309
#define dns_encode_ok(test)
Definition: dns_test.c:100
A DNS decoding test.
Definition: dns_test.c:121
size_t strlen(const char *src)
Get length of string.
Definition: string.c:213
int dns_encode(const char *string, struct dns_name *name)
Encode a DNS name using RFC1035 encoding.
Definition: dns.c:88
unsigned char uint8_t
Definition: stdint.h:10
static void dns_copy_okx(struct dns_copy_test *test, const char *file, unsigned int line)
Report a DNS copying test result.
Definition: dns_test.c:300
struct dns_name dst
Expected copied name.
Definition: dns_test.c:263
struct dns_name second
Second name.
Definition: dns_test.c:199
#define DNS_DECODE(_name, _data, _offset, _string)
Define a DNS decoding test.
Definition: dns_test.c:137
uint32_t len
Length.
Definition: ena.h:14
struct self_test dns_test __self_test
DNS self-test.
Definition: dns_test.c:606
#define dns_compare_fail_ok(test)
Definition: dns_test.c:255
static void dns_decode_okx(struct dns_decode_test *test, const char *file, unsigned int line)
Report DNS decoding test result.
Definition: dns_test.c:155
int strcmp(const char *first, const char *second)
Compare strings.
Definition: string.c:157
struct dns_name list
Search list.
Definition: dns_test.c:351
int len
Length of encoded string.
Definition: dns_test.c:50
static void dns_encode_fail_okx(struct dns_encode_test *test, const char *file, unsigned int line)
Report DNS encoding failure test result.
Definition: dns_test.c:109
static void dns_test_exec(void)
Perform DNS self-test.
Definition: dns_test.c:563
int dns_compare(struct dns_name *first, struct dns_name *second)
Compare DNS names for equality.
Definition: dns.c:255
#define dns_decode_ok(test)
Definition: dns_test.c:175
int dns_decode(struct dns_name *name, char *data, size_t len)
Decode RFC1035-encoded DNS name.
Definition: dns.c:204
#define dns_compare_ok(test)
Definition: dns_test.c:241
#define dns_decode_fail_ok(test)
Definition: dns_test.c:191
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
#define dns_encode_fail_ok(test)
Definition: dns_test.c:117
size_t len
Total length of data.
Definition: dns.h:25
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:98
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
static int test
Definition: epic100.c:73
#define DNS_ENCODE(_name, _string, _data)
Define a DNS encoding test.
Definition: dns_test.c:61
DNS protocol.
void * memset(void *dest, int character, size_t len) __nonnull
A DNS search list test.
Definition: dns_test.c:349
#define dns_copy_fail_ok(test)
Definition: dns_test.c:346