Zonemaster/Engine/Test/Nameserver.pm untested

filter: Statementstmt 0.0% 0 / 571 Branchbran 0.0% 0 / 224 Conditioncond 0.0% 0 / 132 MC/DCmcdc 0.0% 0 / 77 Subroutinesub 0.0% 0 / 33 Podpod 0.0% 0 / 20 totaltotal 0.0% 0 / 1057 CC 113 SCAR 46.7
CC
113
Cov
0%
nameserver11
272.0
all
240.0
nameserver09
132.0
CRAP 106.6
1 package Zonemaster::Engine::Test::Nameserver;
2  
3 use v5.16.0;
4 use warnings;
5  
6 use version; our $VERSION = version->declare( "v1.1.0" );
7  
8 use JSON::PP;
9 use List::MoreUtils qw[uniq none];
10 use Locale::TextDomain qw[Zonemaster-Engine];
11 use Net::IP::XS;
12 use Readonly;
13  
14 use Zonemaster::Engine::Constants qw[:ip];
15 use Zonemaster::Engine::Profile;
16 use Zonemaster::Engine::Test::Address;
17 use Zonemaster::Engine::TestMethods;
18 use Zonemaster::Engine::Util qw( escape_unprintable scramble_case );
19  
20 =head1 NAME
21  
22 Zonemaster::Engine::Test::Nameserver - Module implementing tests focused on the properties of a name server
23  
24 =head1 SYNOPSIS
25  
26 my @results = Zonemaster::Engine::Test::Nameserver->all( $zone );
27  
28 =cut
29  
30 Readonly my @NONEXISTENT_NAMES => qw{
31 xn--nameservertest.iis.se
32 xn--nameservertest.icann.org
33 xn--nameservertest.ripe.net
34 };
35  
36 =head1 METHODS
37  
38 =over
39  
40 =item all()
41  
42 my @logentry_array = all( $zone );
43  
44 Runs the default set of tests for that module, i.e. L<fourteen tests|/TESTS>.
45  
46 Takes a L<Zonemaster::Engine::Zone> object.
47  
48 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
49  
50 =back
51  
52 =cut
53  
54 sub all {
55 my ( $class, $zone ) = @_;
56 my @results;
57  
58 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver01} ) ) {
59 push @results, $class->nameserver01( $zone );
60 }
61 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver02} ) ) {
62 push @results, $class->nameserver02( $zone );
63 }
64 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver03} ) ) {
65 push @results, $class->nameserver03( $zone );
66 }
67 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver04} ) ) {
68 push @results, $class->nameserver04( $zone );
69 }
70 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver05} ) ) {
71 push @results, $class->nameserver05( $zone );
72 }
73 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver06} ) ) {
74 push @results, $class->nameserver06( $zone );
75 }
76 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver07} ) ) {
77 push @results, $class->nameserver07( $zone );
78 }
79 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver08} ) ) {
80 push @results, $class->nameserver08( $zone );
81 }
82 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver09} ) ) {
83 push @results, $class->nameserver09( $zone );
84 }
85 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver10} ) ) {
86 push @results, $class->nameserver10( $zone );
87 }
88 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver11} ) ) {
89 push @results, $class->nameserver11( $zone );
90 }
91 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver12} ) ) {
92 push @results, $class->nameserver12( $zone );
93 }
94 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver13} ) ) {
95 push @results, $class->nameserver13( $zone );
96 }
97 if ( Zonemaster::Engine::Util::should_run_test( q{nameserver15} ) ) {
98 push @results, $class->nameserver15( $zone );
99 }
100  
101 return @results;
102 } ## end sub all
103  
104 =over
105  
106 =item metadata()
107  
108 my $hash_ref = metadata();
109  
110 Returns a reference to a hash, the keys of which are the names of all Test Cases in the module, and the corresponding values are references to
111 an array containing all the message tags that the Test Case can use in L<log entries|Zonemaster::Engine::Logger::Entry>.
112  
113 =back
114  
115 =cut
116  
117 sub metadata {
118 my ( $class ) = @_;
119  
120 return {
121 nameserver01 => [
122 qw(
123 IS_A_RECURSOR
124 NO_RECURSOR
125 NO_RESPONSE
126 TEST_CASE_END
127 TEST_CASE_START
128 )
129 ],
130 nameserver02 => [
131 qw(
132 BREAKS_ON_EDNS
133 EDNS_RESPONSE_WITHOUT_EDNS
134 EDNS_VERSION_ERROR
135 EDNS0_SUPPORT
136 NO_EDNS_SUPPORT
137 NO_RESPONSE
138 NS_ERROR
139 TEST_CASE_END
140 TEST_CASE_START
141 )
142 ],
143 nameserver03 => [
144 qw(
145 AXFR_FAILURE
146 AXFR_AVAILABLE
147 TEST_CASE_END
148 TEST_CASE_START
149 )
150 ],
151 nameserver04 => [
152 qw(
153 DIFFERENT_SOURCE_IP
154 SAME_SOURCE_IP
155 TEST_CASE_END
156 TEST_CASE_START
157 )
158 ],
159 nameserver05 => [
160 qw(
161 AAAA_BAD_RDATA
162 AAAA_QUERY_DROPPED
163 AAAA_UNEXPECTED_RCODE
164 AAAA_WELL_PROCESSED
165 A_UNEXPECTED_RCODE
166 NO_RESPONSE
167 IPV4_DISABLED
168 IPV6_DISABLED
169 TEST_CASE_END
170 TEST_CASE_START
171 )
172 ],
173 nameserver06 => [
174 qw(
175 CAN_NOT_BE_RESOLVED
176 CAN_BE_RESOLVED
177 NO_RESOLUTION
178 TEST_CASE_END
179 TEST_CASE_START
180 )
181 ],
182 nameserver07 => [
183 qw(
184 UPWARD_REFERRAL_IRRELEVANT
185 UPWARD_REFERRAL
186 NO_UPWARD_REFERRAL
187 TEST_CASE_END
188 TEST_CASE_START
189 )
190 ],
191 nameserver08 => [
192 qw(
193 QNAME_CASE_INSENSITIVE
194 QNAME_CASE_SENSITIVE
195 TEST_CASE_END
196 TEST_CASE_START
197 )
198 ],
199 nameserver09 => [
200 qw(
201 CASE_QUERY_SAME_ANSWER
202 CASE_QUERY_DIFFERENT_ANSWER
203 CASE_QUERY_SAME_RC
204 CASE_QUERY_DIFFERENT_RC
205 CASE_QUERY_NO_ANSWER
206 CASE_QUERIES_RESULTS_OK
207 CASE_QUERIES_RESULTS_DIFFER
208 TEST_CASE_END
209 TEST_CASE_START
210 )
211 ],
212 nameserver10 => [
213 qw(
214 N10_NO_RESPONSE_EDNS1_QUERY
215 N10_UNEXPECTED_RCODE
216 N10_EDNS_RESPONSE_ERROR
217 TEST_CASE_END
218 TEST_CASE_START
219 )
220 ],
221 nameserver11 => [
222 qw(
223 N11_NO_EDNS
224 N11_NO_RESPONSE
225 N11_RETURNS_UNKNOWN_OPTION_CODE
226 N11_UNEXPECTED_ANSWER_SECTION
227 N11_UNEXPECTED_RCODE
228 N11_UNSET_AA
229 TEST_CASE_END
230 TEST_CASE_START
231 )
232 ],
233 nameserver12 => [
234 qw(
235 NO_RESPONSE
236 NO_EDNS_SUPPORT
237 Z_FLAGS_NOTCLEAR
238 NS_ERROR
239 TEST_CASE_END
240 TEST_CASE_START
241 )
242 ],
243 nameserver13 => [
244 qw(
245 NO_RESPONSE
246 NO_EDNS_SUPPORT
247 NS_ERROR
248 MISSING_OPT_IN_TRUNCATED
249 TEST_CASE_END
250 TEST_CASE_START
251 )
252 ],
253 nameserver15 => [
254 qw(
255 N15_ERROR_ON_VERSION_QUERY
256 N15_NO_VERSION_REVEALED
257 N15_SOFTWARE_VERSION
258 N15_WRONG_CLASS
259 )
260 ],
261 };
262 } ## end sub metadata
263  
264 Readonly my %TAG_DESCRIPTIONS => (
265 NAMESERVER01 => sub {
266 __x # NAMESERVER:NAMESERVER01
267 'A name server should not be a recursor';
268 },
269 NAMESERVER02 => sub {
270 __x # NAMESERVER:NAMESERVER02
271 'Test of EDNS0 support';
272 },
273 NAMESERVER03 => sub {
274 __x # NAMESERVER:NAMESERVER03
275 'Test availability of zone transfer (AXFR)';
276 },
277 NAMESERVER04 => sub {
278 __x # NAMESERVER:NAMESERVER04
279 'Same source address';
280 },
281 NAMESERVER05 => sub {
282 __x # NAMESERVER:NAMESERVER05
283 'Behaviour against AAAA query';
284 },
285 NAMESERVER06 => sub {
286 __x # NAMESERVER:NAMESERVER06
287 'NS can be resolved';
288 },
289 NAMESERVER07 => sub {
290 __x # NAMESERVER:NAMESERVER07
291 'To check whether authoritative name servers return an upward referral';
292 },
293 NAMESERVER08 => sub {
294 __x # NAMESERVER:NAMESERVER08
295 'Testing QNAME case insensitivity';
296 },
297 NAMESERVER09 => sub {
298 __x # NAMESERVER:NAMESERVER09
299 'Testing QNAME case sensitivity';
300 },
301 NAMESERVER10 => sub {
302 __x # NAMESERVER:NAMESERVER10
303 'Test for undefined EDNS version';
304 },
305 NAMESERVER11 => sub {
306 __x # NAMESERVER:NAMESERVER11
307 'Test for unknown EDNS OPTION-CODE';
308 },
309 NAMESERVER12 => sub {
310 __x # NAMESERVER:NAMESERVER12
311 'Test for unknown EDNS flags';
312 },
313 NAMESERVER13 => sub {
314 __x # NAMESERVER:NAMESERVER13
315 'Test for truncated response on EDNS query';
316 },
317 NAMESERVER15 => sub {
318 __x # NAMESERVER:NAMESERVER15
319 'Checking for revealed software version';
320 },
321 AAAA_BAD_RDATA => sub {
322 __x # NAMESERVER:AAAA_BAD_RDATA
323 'Nameserver {ns} answered AAAA query with an unexpected RDATA length ({length} instead of 16).', @_;
324 },
325 AAAA_QUERY_DROPPED => sub {
326 __x # NAMESERVER:AAAA_QUERY_DROPPED
327 'Nameserver {ns} dropped AAAA query.', @_;
328 },
329 AAAA_UNEXPECTED_RCODE => sub {
330 __x # NAMESERVER:AAAA_UNEXPECTED_RCODE
331 'Nameserver {ns} answered AAAA query with an unexpected rcode ({rcode}).', @_;
332 },
333 AAAA_WELL_PROCESSED => sub {
334 __x # NAMESERVER:AAAA_WELL_PROCESSED
335 'The following nameservers answer AAAA queries without problems : {ns_list}.', @_;
336 },
337 A_UNEXPECTED_RCODE => sub {
338 __x # NAMESERVER:A_UNEXPECTED_RCODE
339 'Nameserver {ns} answered A query with an unexpected rcode ({rcode}).', @_;
340 },
341 AXFR_AVAILABLE => sub {
342 __x # NAMESERVER:AXFR_AVAILABLE
343 'Nameserver {ns} allow zone transfer using AXFR.', @_;
344 },
345 AXFR_FAILURE => sub {
346 __x # NAMESERVER:AXFR_FAILURE
347 'AXFR not available on nameserver {ns}.', @_;
348 },
349 BREAKS_ON_EDNS => sub {
350 __x # NAMESERVER:BREAKS_ON_EDNS
351 'No response from {ns} when EDNS is used in query asking for {domain}.', @_;
352 },
353 CAN_BE_RESOLVED => sub {
354 __x # NAMESERVER:CAN_BE_RESOLVED
355 'All nameservers succeeded to resolve to an IP address.', @_;
356 },
357 CAN_NOT_BE_RESOLVED => sub {
358 __x # NAMESERVER:CAN_NOT_BE_RESOLVED
359 'The following nameservers failed to resolve to an IP address : {nsname_list}.', @_;
360 },
361 CASE_QUERIES_RESULTS_DIFFER => sub {
362 __x # NAMESERVER:CASE_QUERIES_RESULTS_DIFFER
363 'When asked for {type} records on "{domain}" with different cases, all servers do not reply consistently.', @_;
364 },
365 CASE_QUERIES_RESULTS_OK => sub {
366 __x # NAMESERVER:CASE_QUERIES_RESULTS_OK
367 'When asked for {type} records on "{domain}" with different cases, all servers reply consistently.', @_;
368 },
369 CASE_QUERY_DIFFERENT_ANSWER => sub {
370 __x # NAMESERVER:CASE_QUERY_DIFFERENT_ANSWER
371 'When asked for {type} records on "{query1}" and "{query2}", '
372 . 'nameserver {ns} returns different answers.',
373 @_;
374 },
375 CASE_QUERY_DIFFERENT_RC => sub {
376 __x # NAMESERVER:CASE_QUERY_DIFFERENT_RC
377 'When asked for {type} records on "{query1}" and "{query2}", '
378 . 'nameserver {ns} returns different RCODE ("{rcode1}" vs "{rcode2}").',
379 @_;
380 },
381 CASE_QUERY_NO_ANSWER => sub {
382 __x # NAMESERVER:CASE_QUERY_NO_ANSWER
383 'When asked for {type} records on "{domain}", nameserver {ns} returns nothing.', @_;
384 },
385 CASE_QUERY_SAME_ANSWER => sub {
386 __x # NAMESERVER:CASE_QUERY_SAME_ANSWER
387 'When asked for {type} records on "{query1}" and "{query2}", nameserver {ns} returns same answers.',
388 @_;
389 },
390 CASE_QUERY_SAME_RC => sub {
391 __x # NAMESERVER:CASE_QUERY_SAME_RC
392 'When asked for {type} records on "{query1}" and "{query2}", '
393 . 'nameserver {ns} returns same RCODE "{rcode}".',
394 @_;
395 },
396 DIFFERENT_SOURCE_IP => sub {
397 __x # NAMESERVER:DIFFERENT_SOURCE_IP
398 'Nameserver {ns} replies on a SOA query with a different source address ({source}).', @_;
399 },
400 EDNS_RESPONSE_WITHOUT_EDNS => sub {
401 __x # NAMESERVER:EDNS_RESPONSE_WITHOUT_EDNS
402 'Response without EDNS from {ns} on query with EDNS0 asking for {domain}.', @_;
403 },
404 EDNS_VERSION_ERROR => sub {
405 __x # NAMESERVER:EDNS_VERSION_ERROR
406 'Incorrect version of EDNS (expected 0) in response from {ns} '
407 . 'on query with EDNS (version 0) asking for {domain}.',
408 @_;
409 },
410 EDNS0_SUPPORT => sub {
411 __x # NAMESERVER:EDNS0_SUPPORT
412 'The following nameservers support EDNS0 : {ns_list}.', @_;
413 },
414 IPV4_DISABLED => sub {
415 __x # NAMESERVER:IPV4_DISABLED
416 'IPv4 is disabled, not sending "{rrtype}" query to {ns}.', @_;
417 },
418 IPV6_DISABLED => sub {
419 __x # NAMESERVER:IPV6_DISABLED
420 'IPv6 is disabled, not sending "{rrtype}" query to {ns}.', @_;
421 },
422 IS_A_RECURSOR => sub {
423 __x # NAMESERVER:IS_A_RECURSOR
424 'Nameserver {ns} is a recursor.', @_;
425 },
426 MISSING_OPT_IN_TRUNCATED => sub {
427 __x # NAMESERVER:MISSING_OPT_IN_TRUNCATED
428 'Nameserver {ns} replies on an EDNS query with a truncated response without EDNS.', @_;
429 },
430 NO_EDNS_SUPPORT => sub {
431 __x # NAMESERVER:NO_EDNS_SUPPORT
432 'Nameserver {ns} does not support EDNS0 (replies with FORMERR).', @_;
433 },
434 NO_RECURSOR => sub {
435 __x # NAMESERVER:NO_RECURSOR
436 'Nameserver {ns} is not a recursor.', @_;
437 },
438 NO_RESOLUTION => sub {
439 __x # NAMESERVER:NO_RESOLUTION
440 "No nameserver was successfully resolved to an IP address.", @_;
441 },
442 NO_RESPONSE => sub {
443 __x # NAMESERVER:NO_RESPONSE
444 'No response from {ns} asking for {domain}.', @_;
445 },
446 NO_UPWARD_REFERRAL => sub {
447 __x # NAMESERVER:NO_UPWARD_REFERRAL
448 'None of the following nameservers returns an upward referral : {nsname_list}.', @_;
449 },
450 NS_ERROR => sub {
451 __x # NAMESERVER:NS_ERROR
452 'Erroneous response from nameserver {ns}.', @_;
453 },
454 N10_EDNS_RESPONSE_ERROR => sub {
455 __x # NAMESERVER:N10_EDNS_RESPONSE_ERROR
456 'Expected RCODE but received erroneous response to an EDNS version 1 query. Fetched from the nameservers with IP addresses {ns_ip_list}', @_;
457 },
458 N10_NO_RESPONSE_EDNS1_QUERY => sub {
459 __x # NAMESERVER:N10_NO_RESPONSE_EDNS1_QUERY
460 'No response to an EDNS version 1 query. Fetched from the nameservers with IP addresses {ns_ip_list}', @_;
461 },
462 N10_UNEXPECTED_RCODE => sub {
463 __x # NAMESERVER:N10_UNEXPECTED_RCODE
464 'Erroneous RCODE ("{rcode}") in response to an EDNS version 1 query. Fetched from the nameservers with IP addresses {ns_ip_list}', @_;
465 },
466 N11_NO_EDNS => sub {
467 __x # NAMESERVER:N11_NO_EDNS
468 'The DNS response, on query with unknown EDNS option-code, does not contain any EDNS from name servers "{ns_ip_list}".', @_;
469 },
470 N11_NO_RESPONSE => sub {
471 __x # NAMESERVER:N11_NO_RESPONSE
472 'There is no response on query with unknown EDNS option-code from name servers "{ns_ip_list}".', @_;
473 },
474 N11_RETURNS_UNKNOWN_OPTION_CODE => sub {
475 __x # NAMESERVER:N11_RETURNS_UNKNOWN_OPTION_CODE
476 'The DNS response contains an unknown EDNS option-code. Returned from name servers "{ns_ip_list}".', @_;
477 },
478 N11_UNEXPECTED_ANSWER_SECTION => sub {
479 __x # NAMESERVER:N11_UNEXPECTED_ANSWER_SECTION
480 'The DNS response, on query with unknown EDNS option-code, does not contain the expected SOA record in the answer section from name servers "{ns_ip_list}".', @_;
481 },
482 N11_UNEXPECTED_RCODE => sub {
483 __x # NAMESERVER:N11_UNEXPECTED_RCODE
484 'The DNS response, on query with unknown EDNS option-code, has unexpected RCODE name "{rcode}" from name servers "{ns_ip_list}".', @_;
485 },
486 N11_UNSET_AA => sub {
487 __x # NAMESERVER:N11_UNSET_AA
488 'The DNS response, on query with unknown EDNS option-code, is unexpectedly not authoritative from name servers "{ns_ip_list}".', @_;
489 },
490 N15_ERROR_ON_VERSION_QUERY => sub {
491 __x # NAMESERVER:N15_ERROR_ON_VERSION_QUERY
492 'The following name server(s) do not respond or respond with SERVFAIL to software version query "{query_name}". Returned from name servers: "{ns_list}"', @_;
493 },
494 N15_NO_VERSION_REVEALED => sub {
495 __x # NAMESERVER:N15_NO_VERSION_REVEALED
496 'The following name server(s) do not reveal the software version. Returned from name servers: "{ns_list}"', @_;
497 },
498 N15_SOFTWARE_VERSION => sub {
499 __x # NAMESERVER:N15_SOFTWARE_VERSION
500 'The following name server(s) respond to software version query "{query_name}" with string "{string}". Returned from name servers: "{ns_list}"', @_;
501 },
502 N15_WRONG_CLASS => sub {
503 __x # NAMESERVER:N15_WRONG_CLASS
504 'The following name server(s) do not return CH class record(s) on CH class query. Returned from name servers: "{ns_list}"', @_;
505 },
506 QNAME_CASE_INSENSITIVE => sub {
507 __x # NAMESERVER:QNAME_CASE_INSENSITIVE
508 'Nameserver {ns} does not preserve original case of the queried name ({domain}).', @_;
509 },
510 QNAME_CASE_SENSITIVE => sub {
511 __x # NAMESERVER:QNAME_CASE_SENSITIVE
512 "Nameserver {ns} preserves original case of queried names ({domain}).", @_;
513 },
514 SAME_SOURCE_IP => sub {
515 __x # NAMESERVER:SAME_SOURCE_IP
516 'All nameservers reply with same IP used to query them.', @_;
517 },
518 TEST_CASE_END => sub {
519 __x # NAMESERVER:TEST_CASE_END
520 'TEST_CASE_END {testcase}.', @_;
521 },
522 TEST_CASE_START => sub {
523 __x # NAMESERVER:TEST_CASE_START
524 'TEST_CASE_START {testcase}.', @_;
525 },
526 UPWARD_REFERRAL => sub {
527 __x # NAMESERVER:UPWARD_REFERRAL
528 'Nameserver {ns} returns an upward referral.', @_;
529 },
530 UPWARD_REFERRAL_IRRELEVANT => sub {
531 __x # NAMESERVER:UPWARD_REFERRAL_IRRELEVANT
532 'Upward referral tests skipped for root zone.', @_;
533 },
534 Z_FLAGS_NOTCLEAR => sub {
535 __x # NAMESERVER:Z_FLAGS_NOTCLEAR
536 'Nameserver {ns} has one or more unknown EDNS Z flag bits set.', @_;
537 },
538 );
539  
540 =over
541  
542 =item tag_descriptions()
543  
544 my $hash_ref = tag_descriptions();
545  
546 Used by the L<built-in translation system|Zonemaster::Engine::Translator>.
547  
548 Returns a reference to a hash, the keys of which are the message tags and the corresponding values are strings (message IDs).
549  
550 =back
551  
552 =cut
553  
554 sub tag_descriptions {
555 return \%TAG_DESCRIPTIONS;
556 }
557  
558 =over
559  
560 =item version()
561  
562 my $version_string = version();
563  
564 Returns a string containing the version of the current module.
565  
566 =back
567  
568 =cut
569  
570 sub version {
571 return "$Zonemaster::Engine::Test::Nameserver::VERSION";
572 }
573  
574 =head1 INTERNAL METHODS
575  
576 =over
577  
578 =item _emit_log()
579  
580 my $log_entry = _emit_log( $message_tag_string, $hash_ref );
581  
582 Adds a message to the L<logger|Zonemaster::Engine::Logger> for this module.
583 See L<Zonemaster::Engine::Logger::Entry/add($tag, $argref, $module, $testcase)> for more details.
584  
585 Takes a string (message tag) and a reference to a hash (arguments).
586  
587 Returns a L<Zonemaster::Engine::Logger::Entry> object.
588  
589 =back
590  
591 =cut
592  
593 sub _emit_log { my ( $tag, $argref ) = @_; return Zonemaster::Engine->logger->add( $tag, $argref, 'Nameserver' ); }
594  
595 =over
596  
597 =item _ip_disabled_message()
598  
599 my $bool = _ip_disabled_message( $logentry_array_ref, $ns, @query_type_array );
600  
601 Checks if the IP version of a given name server is allowed to be queried. If not, it adds a logging message and returns true. Else, it returns false.
602  
603 Takes a reference to an array of L<Zonemaster::Engine::Logger::Entry> objects, a L<Zonemaster::Engine::Nameserver> object and an array of strings (query type).
604  
605 Returns a boolean.
606  
607 =back
608  
609 =cut
610  
611 sub _ip_disabled_message {
612 my ( $results_array, $ns, @rrtypes ) = @_;
613  
614 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) {
615 push @$results_array, map {
616 _emit_log(
617 IPV6_DISABLED => {
618 ns => $ns->string,
619 rrtype => $_
620 }
621 )
622 } @rrtypes;
623 return 1;
624 }
625  
626 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) {
627 push @$results_array, map {
628 _emit_log(
629 IPV4_DISABLED => {
630 ns => $ns->string,
631 rrtype => $_,
632 }
633 )
634 } @rrtypes;
635 return 1;
636 }
637 return 0;
638 }
639  
640 =head1 TESTS
641  
642 =over
643  
644 =item nameserver01()
645  
646 my @logentry_array = nameserver01( $zone );
647  
648 Runs the L<Nameserver01 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver01.md>.
649  
650 Takes a L<Zonemaster::Engine::Zone> object.
651  
652 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
653  
654 =back
655  
656 =cut
657  
658 sub nameserver01 {
659 my ( $class, $zone ) = @_;
660  
661 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver01';
662 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
663  
664 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
665  
666 for my $ns ( @nss ) {
667  
668 next if ( _ip_disabled_message( \@results, $ns, q{A} ) );
669  
670 my $response_count = 0;
671 my $nxdomain_count = 0;
672 my $is_no_recursor = 1;
673 my $has_seen_ra = 0;
674 for my $nonexistent_name ( @NONEXISTENT_NAMES ) {
675  
676 my $p = $ns->query( $nonexistent_name, q{A} );
677 if ( !$p ) {
678 push @results,
679 _emit_log(
680 NO_RESPONSE => {
681 ns => $ns->string,
682 domain => $nonexistent_name,
683 }
684 );
685 $is_no_recursor = 0;
686 }
687 else {
688 $response_count++;
689  
690 if ( $p->ra ) {
691 $has_seen_ra = 1;
692 }
693  
694 if ( $p->rcode eq q{NXDOMAIN} ) {
695 $nxdomain_count++;
696 }
697 }
698 } ## end for my $nonexistent_name...
699  
700 if ( $has_seen_ra || ( $response_count > 0 && $nxdomain_count == $response_count ) ) {
701 push @results, _emit_log( IS_A_RECURSOR => { ns => $ns->string } );
702 $is_no_recursor = 0;
703 }
704  
705 if ( $is_no_recursor ) {
706 push @results, _emit_log( NO_RECURSOR => { ns => $ns->string } );
707 }
708 } ## end for my $ns ( @nss )
709  
710 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
711 } ## end sub nameserver01
712  
713 =over
714  
715 =item nameserver02()
716  
717 my @logentry_array = nameserver02( $zone );
718  
719 Runs the L<Nameserver02 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver02.md>.
720  
721 Takes a L<Zonemaster::Engine::Zone> object.
722  
723 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
724  
725 =back
726  
727 =cut
728  
729 sub nameserver02 {
730 my ( $class, $zone ) = @_;
731  
732 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver02';
733 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
734 my %nsnames_and_ip;
735 my $n_error = 0;
736  
737 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
738  
739 foreach my $local_ns ( @nss ) {
740 next if ( _ip_disabled_message( \@results, $local_ns, q{SOA} ) );
741  
742 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
743  
744 my $p = $local_ns->query( $zone->name, q{SOA}, { edns_details => { version => 0 } } );
745 if ( $p ) {
746 if ( $p->rcode eq q{FORMERR} and not $p->has_edns) {
747 push @results, _emit_log( NO_EDNS_SUPPORT => { ns => $local_ns->string } );
748 $n_error++;
749 }
750 elsif ( $p->rcode eq q{NOERROR} and not $p->edns_rcode and $p->get_records( q{SOA}, q{answer} ) and $p->edns_version == 0 ) {
751 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
752 next;
753 }
754 elsif ( $p->rcode eq q{NOERROR} and not $p->has_edns ) {
755 push @results,
756 _emit_log(
757 EDNS_RESPONSE_WITHOUT_EDNS => {
758 ns => $local_ns->string,
759 domain => $zone->name,
760 }
761 );
762 $n_error++;
763 }
764 elsif ( $p->rcode eq q{NOERROR} and $p->has_edns and $p->edns_version != 0 ) {
765 push @results,
766 _emit_log(
767 EDNS_VERSION_ERROR => {
768 ns => $local_ns->string,
769 domain => $zone->name,
770 }
771 );
772 $n_error++;
773 }
774 else {
775 push @results, _emit_log( NS_ERROR => { ns => $local_ns->string } );
776 $n_error++;
777 }
778 }
779 else {
780 my $p2 = $local_ns->query( $zone->name, q{SOA} );
781 if ( $p2 ) {
782 push @results,
783 _emit_log(
784 BREAKS_ON_EDNS => {
785 ns => $local_ns->string,
786 domain => $zone->name,
787 }
788 );
789 $n_error++;
790 }
791 else {
792 push @results,
793 _emit_log(
794 NO_RESPONSE => {
795 ns => $local_ns->string,
796 domain => $zone->name,
797 }
798 );
799 $n_error++;
800 }
801 }
802  
803 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
804 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
805  
806 if ( scalar keys %nsnames_and_ip and not $n_error ) {
807 push @results,
808 _emit_log(
809 EDNS0_SUPPORT => {
810 ns_list => join( q{;}, keys %nsnames_and_ip ),
811 }
812 );
813 }
814  
815 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
816 } ## end sub nameserver02
817  
818 =over
819  
820 =item nameserver03()
821  
822 my @logentry_array = nameserver03( $zone );
823  
824 Runs the L<Nameserver03 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver03.md>.
825  
826 Takes a L<Zonemaster::Engine::Zone> object.
827  
828 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
829  
830 =back
831  
832 =cut
833  
834 sub nameserver03 {
835 my ( $class, $zone ) = @_;
836  
837 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver03';
838 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
839 my %nsnames_and_ip;
840  
841 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
842  
843 foreach my $local_ns ( @nss ) {
844  
845 next if ( _ip_disabled_message( \@results, $local_ns, q{AXFR} ) );
846  
847 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
848  
849 my $first_rr;
850 eval {
851 $local_ns->axfr( $zone->name, sub { ( $first_rr ) = @_; return 0; } );
852 1;
853 } or do {
854 push @results, _emit_log( AXFR_FAILURE => { ns => $local_ns->string } );
855 };
856  
857 if ( $first_rr and $first_rr->type eq q{SOA} ) {
858 push @results, _emit_log( AXFR_AVAILABLE => { ns => $local_ns->string } );
859 }
860  
861 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
862 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
863  
864 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
865 } ## end sub nameserver03
866  
867 =over
868  
869 =item nameserver04()
870  
871 my @logentry_array = nameserver04( $zone );
872  
873 Runs the L<Nameserver04 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver04.md>.
874  
875 Takes a L<Zonemaster::Engine::Zone> object.
876  
877 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
878  
879 =back
880  
881 =cut
882  
883 sub nameserver04 {
884 my ( $class, $zone ) = @_;
885  
886 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver04';
887 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
888 my %nsnames_and_ip;
889 my $n_error = 0;
890  
891 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
892  
893 foreach my $local_ns ( @nss ) {
894  
895 next if ( _ip_disabled_message( \@results, $local_ns, q{SOA} ) );
896  
897 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
898  
899 my $p = $local_ns->query( $zone->name, q{SOA} );
900 if ( $p ) {
901 if ( $p->answerfrom and ( $local_ns->address->short ne Net::IP::XS->new( $p->answerfrom )->short ) ) {
902 push @results,
903 _emit_log(
904 DIFFERENT_SOURCE_IP => {
905 ns => $local_ns->string,
906 source => $p->answerfrom,
907 }
908 );
909 $n_error++;
910 }
911 }
912 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
913 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
914  
915 if ( scalar keys %nsnames_and_ip and not $n_error) {
916 push @results,
917 _emit_log(
918 SAME_SOURCE_IP => {
919 names => join( q{,}, keys %nsnames_and_ip ),
920 }
921 );
922 }
923  
924 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
925 } ## end sub nameserver04
926  
927 =over
928  
929 =item nameserver05()
930  
931 my @logentry_array = nameserver05( $zone );
932  
933 Runs the L<Nameserver05 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver05.md>.
934  
935 Takes a L<Zonemaster::Engine::Zone> object.
936  
937 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
938  
939 =back
940  
941 =cut
942  
943 sub nameserver05 {
944 my ( $class, $zone ) = @_;
945  
946 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver05';
947 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
948 my %nsnames_and_ip;
949 my $aaaa_issue = 0;
950 my @aaaa_ok;
951  
952 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
953  
954 foreach my $ns ( @nss ) {
955  
956 next if ( _ip_disabled_message( \@results, $ns, q{A} ) );
957  
958 next if $nsnames_and_ip{ $ns->name->string . q{/} . $ns->address->short };
959  
960 $nsnames_and_ip{ $ns->name->string . q{/} . $ns->address->short }++;
961  
962 my $p = $ns->query( $zone->name, q{A}, { usevc => 0 } );
963  
964 if ( not $p ) {
965 push @results,
966 _emit_log(
967 NO_RESPONSE => {
968 ns => $ns->string,
969 domain => $zone->name,
970 }
971 );
972 }
973 elsif ( $p->rcode ne q{NOERROR} ) {
974 push @results,
975 _emit_log(
976 A_UNEXPECTED_RCODE => {
977 ns => $ns->string,
978 rcode => $p->rcode,
979 }
980 );
981 }
982 else {
983 $p = $ns->query( $zone->name, q{AAAA}, { usevc => 0 } );
984  
985 if ( not $p ) {
986 push @results,
987 _emit_log( AAAA_QUERY_DROPPED => { ns => $ns->string } );
988 $aaaa_issue++;
989 }
990 elsif ( $p->rcode ne q{NOERROR} ) {
991 push @results,
992 _emit_log(
993 AAAA_UNEXPECTED_RCODE => {
994 ns => $ns->string,
995 rcode => $p->rcode,
996 }
997 );
998 $aaaa_issue++;
999 }
1000 else {
1001 foreach my $rr ( $p->get_records( q{AAAA}, q{answer} ) ) {
1002 if ( length($rr->rdf(0)) != 16 ) {
1003 push @results,
1004 _emit_log(
1005 AAAA_BAD_RDATA => {
1006 ns => $ns->string,
1007 length => length( $rr->rdf( 0 ) ),
1008 }
1009 );
1010 $aaaa_issue++;
1011 }
1012 else {
1013 push @aaaa_ok, $rr->address;
1014 }
1015 }
1016 }
1017 }
1018 }
1019  
1020 if ( scalar @aaaa_ok and not $aaaa_issue ) {
1021 push @results,
1022 _emit_log(
1023 AAAA_WELL_PROCESSED => {
1024 ns_list => join( q{;}, keys %nsnames_and_ip ),
1025 }
1026 );
1027 }
1028  
1029 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1030 } ## end sub nameserver05
1031  
1032 =over
1033  
1034 =item nameserver06()
1035  
1036 my @logentry_array = nameserver06( $zone );
1037  
1038 Runs the L<Nameserver06 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver06.md>.
1039  
1040 Takes a L<Zonemaster::Engine::Zone> object.
1041  
1042 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1043  
1044 =back
1045  
1046 =cut
1047  
1048 sub nameserver06 {
1049 my ( $class, $zone ) = @_;
1050  
1051 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver06';
1052 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1053 my @all_nsnames = uniq map { lc( $_->string ) } @{ Zonemaster::Engine::TestMethods->method2( $zone ) },
1054 @{ Zonemaster::Engine::TestMethods->method3( $zone ) };
1055 my @all_nsnames_with_ip = uniq map { lc( $_->name->string ) } @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1056 my @all_nsnames_without_ip;
1057 my %diff;
1058  
1059 @diff{@all_nsnames} = undef;
1060 delete @diff{@all_nsnames_with_ip};
1061  
1062 @all_nsnames_without_ip = keys %diff;
1063 if ( scalar @all_nsnames_without_ip and scalar @all_nsnames_with_ip ) {
1064 push @results,
1065 _emit_log(
1066 CAN_NOT_BE_RESOLVED => {
1067 nsname_list => join( q{;}, @all_nsnames_without_ip ),
1068 }
1069 );
1070 }
1071 elsif ( not scalar @all_nsnames_with_ip ) {
1072 push @results,
1073 _emit_log(
1074 NO_RESOLUTION => {
1075 names => join( q{,}, @all_nsnames_without_ip ),
1076 }
1077 );
1078 }
1079 else {
1080 push @results, _emit_log( CAN_BE_RESOLVED => {} );
1081 }
1082  
1083 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1084 } ## end sub nameserver06
1085  
1086 =over
1087  
1088 =item nameserver07()
1089  
1090 my @logentry_array = nameserver07( $zone );
1091  
1092 Runs the L<Nameserver07 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver07.md>.
1093  
1094 Takes a L<Zonemaster::Engine::Zone> object.
1095  
1096 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1097  
1098 =back
1099  
1100 =cut
1101  
1102 sub nameserver07 {
1103 my ( $class, $zone ) = @_;
1104  
1105 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver07';
1106 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1107 my %nsnames_and_ip;
1108 my %nsnames;
1109 my $n_error = 0;
1110  
1111 if ( $zone->name eq q{.} ) {
1112 push @results, _emit_log( UPWARD_REFERRAL_IRRELEVANT => {} );
1113 }
1114 else {
1115 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1116 foreach my $local_ns ( @nss ) {
1117 next if ( _ip_disabled_message( \@results, $local_ns, q{NS} ) );
1118  
1119 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
1120  
1121 my $p = $local_ns->query( q{.}, q{NS} );
1122 if ( $p ) {
1123 my @ns = $p->get_records( q{NS}, q{authority} );
1124  
1125 if ( @ns ) {
1126 push @results, _emit_log( UPWARD_REFERRAL => { ns => $local_ns->string } );
1127 $n_error++;
1128 }
1129 }
1130 $nsnames{ $local_ns->name }++;
1131 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
1132 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
1133  
1134 if ( scalar keys %nsnames_and_ip and not $n_error ) {
1135 push @results,
1136 _emit_log(
1137 NO_UPWARD_REFERRAL => {
1138 nsname_list => join( q{;}, sort keys %nsnames ),
1139 }
1140 );
1141 }
1142 } ## end else [ if ( $zone->name eq q{.})]
1143  
1144 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1145 } ## end sub nameserver07
1146  
1147 =over
1148  
1149 =item nameserver08()
1150  
1151 my @logentry_array = nameserver08( $zone );
1152  
1153 Runs the L<Nameserver08 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver08.md>.
1154  
1155 Takes a L<Zonemaster::Engine::Zone> object.
1156  
1157 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1158  
1159 =back
1160  
1161 =cut
1162  
1163 sub nameserver08 {
1164 my ( $class, $zone ) = @_;
1165  
1166 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver08';
1167 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1168 my %nsnames_and_ip;
1169 my $original_name = q{www.} . $zone->name->string;
1170 my $randomized_uc_name;
1171  
1172 $original_name =~ s/[.]+\z//smgx;
1173  
1174 do {
1175 $randomized_uc_name = scramble_case $original_name;
1176 } while ( $randomized_uc_name eq $original_name );
1177  
1178 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1179  
1180 foreach my $local_ns ( @nss ) {
1181  
1182 next if ( _ip_disabled_message( \@results, $local_ns, q{SOA} ) );
1183  
1184 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
1185  
1186 my $p = $local_ns->query( $randomized_uc_name, q{SOA} );
1187  
1188 if ( $p and my ( $qrr ) = $p->question() ) {
1189 my $qrr_name = $qrr->name();
1190 $qrr_name =~ s/\.\z//smgx;
1191 if ( $qrr_name eq $randomized_uc_name ) {
1192 push @results,
1193 _emit_log(
1194 QNAME_CASE_SENSITIVE => {
1195 ns => $local_ns->string,
1196 domain => $randomized_uc_name,
1197 }
1198 );
1199 }
1200 else {
1201 push @results,
1202 _emit_log(
1203 QNAME_CASE_INSENSITIVE => {
1204 ns => $local_ns->string,
1205 domain => $randomized_uc_name,
1206 }
1207 );
1208 }
1209 } ## end if ( $p and my ( $qrr ...))
1210 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
1211 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
1212  
1213 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1214 } ## end sub nameserver08
1215  
1216 =over
1217  
1218 =item nameserver09()
1219  
1220 my @logentry_array = nameserver09( $zone );
1221  
1222 Runs the L<Nameserver09 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver09.md>.
1223  
1224 Takes a L<Zonemaster::Engine::Zone> object.
1225  
1226 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1227  
1228 =back
1229  
1230 =cut
1231  
1232 sub nameserver09 {
1233 my ( $class, $zone ) = @_;
1234  
1235 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver09';
1236 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1237 my %nsnames_and_ip;
1238 my $original_name = q{www.} . $zone->name->string;
1239 my $record_type = q{SOA};
1240 my $randomized_uc_name1;
1241 my $randomized_uc_name2;
1242 my $all_results_match = 1;
1243  
1244 $original_name =~ s/[.]+\z//smgx;
1245  
1246 do {
1247 $randomized_uc_name1 = scramble_case $original_name;
1248 } while ( $randomized_uc_name1 eq $original_name );
1249  
1250 do {
1251 $randomized_uc_name2 = scramble_case $original_name;
1252 } while ( $randomized_uc_name2 eq $original_name or $randomized_uc_name2 eq $randomized_uc_name1 );
1253  
1254 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1255  
1256 foreach my $local_ns ( @nss ) {
1257  
1258 next if ( _ip_disabled_message( \@results, $local_ns, $record_type ) );
1259  
1260 next if $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short };
1261  
1262 my $p1 = $local_ns->query( $randomized_uc_name1, $record_type );
1263 my $p2 = $local_ns->query( $randomized_uc_name2, $record_type );
1264  
1265 my $answer1_string = q{};
1266 my $answer2_string = q{};
1267 my $json = JSON::PP->new->canonical->pretty;
1268 if ( $p1 and scalar $p1->answer ) {
1269  
1270 my @answer1 = map { lc $_->string } sort $p1->answer;
1271 $answer1_string = $json->encode( \@answer1 );
1272  
1273 if ( $p2 and scalar $p2->answer ) {
1274  
1275 my @answer2 = map { lc $_->string } sort $p2->answer;
1276 $answer2_string = $json->encode( \@answer2 );
1277 }
1278  
1279 if ( $answer1_string eq $answer2_string ) {
1280 push @results,
1281 _emit_log(
1282 CASE_QUERY_SAME_ANSWER => {
1283 ns => $local_ns->string,
1284 type => $record_type,
1285 query1 => $randomized_uc_name1,
1286 query2 => $randomized_uc_name2,
1287 }
1288 );
1289 }
1290 else {
1291 $all_results_match = 0;
1292 push @results,
1293 _emit_log(
1294 CASE_QUERY_DIFFERENT_ANSWER => {
1295 ns => $local_ns->string,
1296 type => $record_type,
1297 query1 => $randomized_uc_name1,
1298 query2 => $randomized_uc_name2,
1299 }
1300 );
1301 }
1302  
1303 } ## end if ( $p1 and scalar $p1...)
1304 elsif ( $p1 and $p2 ) {
1305  
1306 if ( $p1->rcode eq $p2->rcode ) {
1307 push @results,
1308 _emit_log(
1309 CASE_QUERY_SAME_RC => {
1310 ns => $local_ns->string,
1311 type => $record_type,
1312 query1 => $randomized_uc_name1,
1313 query2 => $randomized_uc_name2,
1314 rcode => $p1->rcode,
1315 }
1316 );
1317 }
1318 else {
1319 $all_results_match = 0;
1320 push @results,
1321 _emit_log(
1322 CASE_QUERY_DIFFERENT_RC => {
1323 ns => $local_ns->string,
1324 type => $record_type,
1325 query1 => $randomized_uc_name1,
1326 query2 => $randomized_uc_name2,
1327 rcode1 => $p1->rcode,
1328 rcode2 => $p2->rcode,
1329 }
1330 );
1331 }
1332  
1333 } ## end elsif ( $p1 and $p2 )
1334 elsif ( $p1 or $p2 ) {
1335 $all_results_match = 0;
1336 push @results,
1337 _emit_log(
1338 CASE_QUERY_NO_ANSWER => {
1339 ns => $local_ns->string,
1340 type => $record_type,
1341 domain => $p1 ? $randomized_uc_name1 : $randomized_uc_name2,
1342 }
1343 );
1344 }
1345  
1346 $nsnames_and_ip{ $local_ns->name->string . q{/} . $local_ns->address->short }++;
1347 } ## end foreach my $local_ns ( @{ Zonemaster::Engine::TestMethods...})
1348  
1349 if ( $all_results_match ) {
1350 push @results,
1351 _emit_log(
1352 CASE_QUERIES_RESULTS_OK => {
1353 type => $record_type,
1354 domain => $original_name,
1355 }
1356 );
1357 }
1358 else {
1359 push @results,
1360 _emit_log(
1361 CASE_QUERIES_RESULTS_DIFFER => {
1362 type => $record_type,
1363 domain => $original_name,
1364 }
1365 );
1366 }
1367  
1368 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1369 } ## end sub nameserver09
1370  
1371 =over
1372  
1373 =item nameserver10()
1374  
1375 my @logentry_array = nameserver10( $zone );
1376  
1377 Runs the L<Nameserver10 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver10.md>.
1378  
1379 Takes a L<Zonemaster::Engine::Zone> object.
1380  
1381 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1382  
1383 =back
1384  
1385 =cut
1386  
1387 sub nameserver10 {
1388 my ( $class, $zone ) = @_;
1389  
1390 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver10';
1391 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1392  
1393 my @no_response_edns1;
1394 my %unexpected_rcode;
1395 my @edns_response_error;
1396  
1397 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1398  
1399 for my $ns ( @nss ) {
1400  
1401 next if ( _ip_disabled_message( \@results, $ns, q{SOA} ) );
1402  
1403 my $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0 } } );
1404  
1405 if ( $p and $p->rcode eq q{NOERROR} ){
1406 my $p2 = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 1 } } );
1407  
1408 if ( $p2 ) {
1409 if ( ($p2->rcode ne q{NOERROR} and $p2->edns_rcode != 1) ) {
1410 push @{ $unexpected_rcode{$p->rcode} }, $ns->address->short;
1411 }
1412 elsif ( ($p2->rcode eq q{NOERROR} and $p2->edns_rcode == 1) and $p2->edns_version == 0 and not scalar $p2->answer){
1413 next;
1414 }
1415 else {
1416 push @edns_response_error, $ns->address->short;
1417 }
1418 }
1419 else {
1420 push @no_response_edns1, $ns->address->short;
1421 }
1422 }
1423 }
1424  
1425 if ( scalar @no_response_edns1 ){
1426 push @results,
1427 _emit_log(
1428 N10_NO_RESPONSE_EDNS1_QUERY => {
1429 ns_ip_list => join ( q{;}, uniq sort @no_response_edns1 )
1430 }
1431 );
1432 }
1433  
1434 if ( scalar keys %unexpected_rcode ){
1435 push @results, map {
1436 _emit_log(
1437 N10_UNEXPECTED_RCODE => {
1438 rcode => $_,
1439 ns_ip_list => join( q{;}, uniq sort @{ $unexpected_rcode{$_} } )
1440 }
1441 )
1442 } keys %unexpected_rcode;
1443 }
1444  
1445 if ( scalar @edns_response_error ){
1446 push @results,
1447 _emit_log(
1448 N10_EDNS_RESPONSE_ERROR => {
1449 ns_ip_list => join ( q{;}, uniq sort @edns_response_error )
1450 }
1451 );
1452 }
1453  
1454 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1455 } ## end sub nameserver10
1456  
1457 =over
1458  
1459 =item nameserver11()
1460  
1461 my @logentry_array = nameserver11( $zone );
1462  
1463 Runs the L<Nameserver11 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver11.md>.
1464  
1465 Takes a L<Zonemaster::Engine::Zone> object.
1466  
1467 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1468  
1469 =back
1470  
1471 =cut
1472  
1473 sub nameserver11 {
1474 my ( $class, $zone ) = @_;
1475  
1476 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver11';
1477 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1478  
1479 my @no_response;
1480 my %unexpected_rcode;
1481 my @no_edns;
1482 my @unexpected_answer;
1483 my @unset_aa;
1484 my @unknown_opt_code;
1485  
1486 # Choose an unassigned EDNS0 Option Codes
1487 # values 15-26945 are Unassigned. Let's say we use 137 ???
1488 my $opt_code = 137;
1489 my $opt_data = q{};
1490 my $opt_length = length($opt_data);
1491 my $rdata = $opt_code*65536 + $opt_length;
1492  
1493 foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) } ) {
1494  
1495 next if ( _ip_disabled_message( \@results, $ns, q{SOA} ) );
1496  
1497 my $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0 } } );
1498  
1499 if ( not $p or not $p->has_edns or $p->rcode ne q{NOERROR} or not $p->aa or not $p->get_records_for_name(q{SOA}, $zone->name, q{answer}) ) {
1500 next;
1501 }
1502  
1503 $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0, data => $rdata } } );
1504  
1505 if ( $p ) {
1506 if ( $p->rcode ne q{NOERROR} ) {
1507 push @{ $unexpected_rcode{$p->rcode} }, $ns->address->short;
1508 }
1509  
1510 elsif ( not $p->has_edns ) {
1511 push @no_edns, $ns->address->short;
1512 }
1513  
1514 elsif ( not $p->get_records_for_name(q{SOA}, $zone->name, q{answer}) ) {
1515 push @unexpected_answer, $ns->address->short;
1516 }
1517  
1518 elsif ( not $p->aa ) {
1519 push @unset_aa, $ns->address->short;
1520 }
1521  
1522 elsif ( defined $p->edns_data ) {
1523 my $p_opt = $p->edns_data;
1524  
1525 # Unpack the bytes string:
1526 # - OPTION-CODE as unsigned short (16-bit) in "network" (big-endian) order, and
1527 # - OPTION-DATA as a sequence of bytes of length specified by a prefixed unsigned short (16-bit)
1528 # in "network" (big-endian) order (OPTION-LENGTH), and
1529 # - Remaining data, if any (i.e., other OPTIONS)
1530  
1531 my @unpacked_opt = eval { unpack("(n n/a)*", $p_opt) };
1532  
1533 while ( my ( $p_opt_code, $p_opt_data, @next_data ) = @unpacked_opt ) {
1534 if ( $p_opt_code == $opt_code ) {
1535 push @unknown_opt_code, $ns->address->short;
1536 last;
1537 }
1538  
1539 @unpacked_opt = @next_data;
1540 }
1541 }
1542 }
1543 else{
1544 push @no_response, $ns->address->short;
1545 }
1546 }
1547  
1548 if ( scalar @no_response ) {
1549 push @results, _emit_log( N11_NO_RESPONSE => { ns_ip_list => join( q{;}, uniq sort @no_response ) } );
1550 }
1551  
1552 if ( scalar keys %unexpected_rcode ) {
1553 push @results, map {
1554 _emit_log(
1555 N11_UNEXPECTED_RCODE => {
1556 rcode => $_,
1557 ns_ip_list => join( q{;}, uniq sort @{ $unexpected_rcode{$_} } )
1558 }
1559 )
1560 } keys %unexpected_rcode;
1561 }
1562  
1563 if ( scalar @no_edns ) {
1564 push @results, _emit_log( N11_NO_EDNS => { ns_ip_list => join( q{;}, uniq sort @no_edns ) } );
1565 }
1566  
1567 if ( scalar @unexpected_answer ) {
1568 push @results, _emit_log( N11_UNEXPECTED_ANSWER_SECTION => { ns_ip_list => join( q{;}, uniq sort @unexpected_answer ) } );
1569 }
1570  
1571 if ( scalar @unset_aa ) {
1572 push @results, _emit_log( N11_UNSET_AA => { ns_ip_list => join( q{;}, uniq sort @unset_aa ) } );
1573 }
1574  
1575 if ( scalar @unknown_opt_code ) {
1576 push @results, _emit_log( N11_RETURNS_UNKNOWN_OPTION_CODE => { ns_ip_list => join( q{;}, uniq sort @unknown_opt_code ) } );
1577 }
1578  
1579 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1580 } ## end sub nameserver11
1581  
1582 =over
1583  
1584 =item nameserver12()
1585  
1586 my @logentry_array = nameserver12( $zone );
1587  
1588 Runs the L<Nameserver12 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver12.md>.
1589  
1590 Takes a L<Zonemaster::Engine::Zone> object.
1591  
1592 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1593  
1594 =back
1595  
1596 =cut
1597  
1598 sub nameserver12 {
1599 my ( $class, $zone ) = @_;
1600  
1601 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver12';
1602 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1603  
1604 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1605  
1606 for my $ns ( @nss ) {
1607  
1608 next if ( _ip_disabled_message( \@results, $ns, q{SOA} ) );
1609  
1610 my $p = $ns->query( $zone->name, q{SOA}, { edns_details => { version => 0, z => 3 } } );
1611  
1612 if ( $p ) {
1613 if ( $p->rcode eq q{FORMERR} and not $p->edns_rcode ) {
1614 push @results, _emit_log( NO_EDNS_SUPPORT => { ns => $ns->string } );
1615 }
1616 elsif ( $p->edns_z ) {
1617 push @results, _emit_log( Z_FLAGS_NOTCLEAR => { ns => $ns->string } );
1618 }
1619 elsif ( $p->rcode eq q{NOERROR} and not $p->edns_rcode and $p->edns_version == 0 and $p->edns_z == 0 and $p->get_records( q{SOA}, q{answer} ) ) {
1620 next;
1621 }
1622 else {
1623 push @results, _emit_log( NS_ERROR => { ns => $ns->string } );
1624 }
1625 }
1626 else {
1627 push @results,
1628 _emit_log(
1629 NO_RESPONSE => {
1630 ns => $ns->string,
1631 domain => $zone->name,
1632 }
1633 );
1634 }
1635 }
1636  
1637 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1638 } ## end sub nameserver12
1639  
1640 =over
1641  
1642 =item nameserver13()
1643  
1644 my @logentry_array = nameserver13( $zone );
1645  
1646 Runs the L<Nameserver13 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver13.md>.
1647  
1648 Takes a L<Zonemaster::Engine::Zone> object.
1649  
1650 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1651  
1652 =back
1653  
1654 =cut
1655  
1656 sub nameserver13 {
1657 my ( $class, $zone ) = @_;
1658  
1659 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver13';
1660 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1661  
1662 my @nss = @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) };
1663  
1664 for my $ns ( @nss ) {
1665  
1666 next if ( _ip_disabled_message( \@results, $ns, q{DNSKEY} ) );
1667  
1668 my $p = $ns->query( $zone->name, q{DNSKEY}, { usevc => 0, fallback => 0, edns_details => { version => 0, do => 1, size => 512 } } );
1669  
1670 if ( $p ) {
1671 if ( $p->rcode eq q{FORMERR} and not $p->edns_rcode ) {
1672 push @results, _emit_log( NO_EDNS_SUPPORT => { ns => $ns->string, } );
1673 }
1674 elsif ( $p->tc and not $p->has_edns ) {
1675 push @results, _emit_log( MISSING_OPT_IN_TRUNCATED => { ns => $ns->string } );
1676 }
1677 elsif ( $p->rcode eq q{NOERROR} and not $p->edns_rcode and $p->edns_version == 0 ) {
1678 next;
1679 }
1680 else {
1681 push @results, _emit_log( NS_ERROR => { ns => $ns->string } );
1682 }
1683 }
1684 else {
1685 push @results,
1686 _emit_log(
1687 NO_RESPONSE => {
1688 ns => $ns->string,
1689 domain => $zone->name,
1690 }
1691 );
1692 }
1693 }
1694  
1695 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1696 } ## end sub nameserver13
1697  
1698 =over
1699  
1700 =item nameserver15()
1701  
1702 my @logentry_array = nameserver15( $zone );
1703  
1704 Runs the L<Nameserver15 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Nameserver-TP/nameserver15.md>.
1705  
1706 Takes a L<Zonemaster::Engine::Zone> object.
1707  
1708 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1709  
1710 =back
1711  
1712 =cut
1713  
1714 sub nameserver15 {
1715 my ( $class, $zone ) = @_;
1716  
1717 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Nameserver15';
1718 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1719  
1720 my %txt_data;
1721 my %error_on_version_query;
1722 my %sending_version_query;
1723 my @wrong_record_class;
1724  
1725 foreach my $ns ( @{ Zonemaster::Engine::TestMethods->method4and5( $zone ) } ) {
1726 next if ( _ip_disabled_message( \@results, $ns, q{SOA TXT} ) );
1727  
1728 my $p_soa = $ns->query( $zone->name, q{SOA} );
1729  
1730 next if not $p_soa;
1731  
1732 $sending_version_query{$ns} = 1;
1733  
1734 foreach my $query_name ( q{version.bind}, q{version.server} ) {
1735 my $p_txt = $ns->query( $query_name, q{TXT}, { class => q{CH} } );
1736  
1737 if ( not $p_txt or $p_txt->rcode eq q{SERVFAIL} ) {
1738 push @{ $error_on_version_query{$query_name} }, $ns;
1739 next;
1740 }
1741  
1742 my @rrs_txt = $p_txt->get_records_for_name(q{TXT}, $query_name, q{answer});
1743  
1744 if ( scalar @rrs_txt ) {
1745 foreach my $rr ( @rrs_txt ) {
1746 if ( $rr->class ne q{CH} ) {
1747 push @wrong_record_class, $ns;
1748 }
1749  
1750 my $string = escape_unprintable($rr->txtdata);
1751 $string =~ s/^\s+|\s+$//g; # Remove leading and trailing spaces
1752  
1753 if ( $string ne "" ) {
1754 push @{ $txt_data{$string}{$query_name} }, $ns;
1755 delete $sending_version_query{$ns};
1756 }
1757 }
1758 }
1759 }
1760 }
1761  
1762 if ( scalar keys %txt_data ) {
1763 foreach my $string ( keys %txt_data ) {
1764 push @results, map {
1765 _emit_log(
1766 N15_SOFTWARE_VERSION => {
1767 string => $string,
1768 query_name => $_,
1769 ns_list => join( q{;}, sort @{ $txt_data{$string}{$_} } )
1770 }
1771 )
1772 } keys %{ $txt_data{$string} };
1773 }
1774 }
1775  
1776 if ( scalar keys %error_on_version_query ) {
1777 push @results, map {
1778 _emit_log(
1779 N15_ERROR_ON_VERSION_QUERY => {
1780 query_name => $_,
1781 ns_list => join( q{;}, sort @{ $error_on_version_query{$_} } )
1782 }
1783 )
1784 } keys %error_on_version_query;
1785 }
1786  
1787 if ( scalar keys %sending_version_query ) {
1788 push @results,
1789 _emit_log(
1790 N15_NO_VERSION_REVEALED => {
1791 ns_list => join( q{;}, sort keys %sending_version_query )
1792 }
1793 );
1794 }
1795  
1796 if ( scalar @wrong_record_class ) {
1797 push @results,
1798 _emit_log(
1799 N15_WRONG_CLASS => {
1800 ns_list => join( q{;}, sort @wrong_record_class )
1801 }
1802 );
1803 }
1804  
1805 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1806 } ## end sub nameserver15
1807  
1808 1;