Zonemaster/Engine/Test/Syntax.pm untested

filter: Statementstmt 0.0% 0 / 333 Branchbran 0.0% 0 / 108 Conditioncond 0.0% 0 / 27 MC/DCmcdc 0.0% 0 / 18 Subroutinesub 0.0% 0 / 35 Podpod 0.0% 0 / 19 totaltotal 0.0% 0 / 540 CC 55 SCAR 48.9
CC
55
Cov
0%
syntax06
462.0
all
132.0
_check_name_syntax
42.0
CRAP 132.5
1 package Zonemaster::Engine::Test::Syntax;
2  
3 use v5.16.0;
4 use warnings;
5  
6 use version; our $VERSION = version->declare( "v1.0.10" );
7  
8 use Carp;
9 use Email::Valid;
10 use List::MoreUtils qw[uniq none any];
11 use Locale::TextDomain qw[Zonemaster-Engine];
12 use Readonly;
13 use Time::Local;
14  
15 use Zonemaster::Engine::Profile;
16 use Zonemaster::Engine::Constants qw[:name :ip];
17 use Zonemaster::Engine::DNSName;
18 use Zonemaster::Engine::Packet;
19 use Zonemaster::Engine::TestMethods;
20 use Zonemaster::Engine::Util qw[should_run_test name];
21 use Zonemaster::LDNS;
22  
23 =head1 NAME
24  
25 Zonemaster::Engine::Test::Syntax - Module implementing tests focused on validating the syntax of host names and other data
26  
27 =head1 SYNOPSIS
28  
29 my @results = Zonemaster::Engine::Test::Syntax->all( $zone );
30  
31 =head1 METHODS
32  
33 =over
34  
35 =item all()
36  
37 my @logentry_array = all( $zone );
38  
39 Runs the default set of tests for that module, i.e. between L<three and eight tests|/TESTS> depending on the tested zone.
40 If L<Syntax01|/syntax01()> passes, the remaining tests are run.
41  
42 Takes a L<Zonemaster::Engine::Zone> object.
43  
44 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
45  
46 =back
47  
48 =cut
49  
50 sub all {
51 my ( $class, $zone ) = @_;
52  
53 my @results;
54  
55 my $only_allowed_chars = 1;
56 if ( should_run_test( q{syntax01} ) ) {
57 push @results, $class->syntax01( $zone );
58 $only_allowed_chars = any { $_->tag eq q{ONLY_ALLOWED_CHARS} } @results;
59 }
60  
61 push @results, $class->syntax02( $zone )
62 if should_run_test( q{syntax02} );
63  
64 push @results, $class->syntax03( $zone )
65 if should_run_test( q{syntax03} );
66  
67 return @results
68 if !$only_allowed_chars;
69  
70 push @results, $class->syntax04( Zonemaster::Engine->zone( $zone ) )
71 if Zonemaster::Engine::Util::should_run_test( q{syntax04} );
72  
73 my $all_soa_responses = 1;
74 if ( should_run_test( q{syntax05} ) ) {
75 push @results, $class->syntax05( $zone );
76 $all_soa_responses = none { $_->tag eq q{NO_RESPONSE_SOA_QUERY} } @results;
77 }
78  
79 if ( $all_soa_responses ) {
80 push @results, $class->syntax06( $zone )
81 if should_run_test( q{syntax06} );
82  
83 push @results, $class->syntax07( $zone )
84 if should_run_test( q{syntax07} );
85 }
86  
87 push @results, $class->syntax08( $zone )
88 if should_run_test( q{syntax08} );
89  
90 return @results;
91 } ## end sub all
92  
93 =over
94  
95 =item metadata()
96  
97 my $hash_ref = metadata();
98  
99 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
100 an array containing all the message tags that the Test Case can use in L<log entries|Zonemaster::Engine::Logger::Entry>.
101  
102 =back
103  
104 =cut
105  
106 sub metadata {
107 my ( $class ) = @_;
108  
109 return {
110 syntax01 => [
111 qw(
112 ONLY_ALLOWED_CHARS
113 NON_ALLOWED_CHARS
114 TEST_CASE_END
115 TEST_CASE_START
116 )
117 ],
118 syntax02 => [
119 qw(
120 INITIAL_HYPHEN
121 TERMINAL_HYPHEN
122 NO_ENDING_HYPHENS
123 TEST_CASE_END
124 TEST_CASE_START
125 )
126 ],
127 syntax03 => [
128 qw(
129 DISCOURAGED_DOUBLE_DASH
130 NO_DOUBLE_DASH
131 TEST_CASE_END
132 TEST_CASE_START
133 )
134 ],
135 syntax04 => [
136 qw(
137 NAMESERVER_DISCOURAGED_DOUBLE_DASH
138 NAMESERVER_NON_ALLOWED_CHARS
139 NAMESERVER_NUMERIC_TLD
140 NAMESERVER_SYNTAX_OK
141 TEST_CASE_END
142 TEST_CASE_START
143 )
144 ],
145 syntax05 => [
146 qw(
147 RNAME_MISUSED_AT_SIGN
148 RNAME_NO_AT_SIGN
149 NO_RESPONSE_SOA_QUERY
150 TEST_CASE_END
151 TEST_CASE_START
152 )
153 ],
154 syntax06 => [
155 qw(
156 NO_RESPONSE
157 NO_RESPONSE_SOA_QUERY
158 RNAME_MAIL_DOMAIN_INVALID
159 RNAME_MAIL_DOMAIN_LOCALHOST
160 RNAME_MAIL_ILLEGAL_CNAME
161 RNAME_RFC822_INVALID
162 RNAME_RFC822_VALID
163 TEST_CASE_END
164 TEST_CASE_START
165 )
166 ],
167 syntax07 => [
168 qw(
169 MNAME_DISCOURAGED_DOUBLE_DASH
170 MNAME_NON_ALLOWED_CHARS
171 MNAME_NUMERIC_TLD
172 MNAME_SYNTAX_OK
173 NO_RESPONSE_SOA_QUERY
174 TEST_CASE_END
175 TEST_CASE_START
176 )
177 ],
178 syntax08 => [
179 qw(
180 MX_DISCOURAGED_DOUBLE_DASH
181 MX_NON_ALLOWED_CHARS
182 MX_NUMERIC_TLD
183 MX_SYNTAX_OK
184 NO_RESPONSE_MX_QUERY
185 TEST_CASE_END
186 TEST_CASE_START
187 )
188 ],
189 };
190 } ## end sub metadata
191  
192 Readonly my %TAG_DESCRIPTIONS => (
193 SYNTAX01 => sub {
194 __x # SYNTAX:SYNTAX01
195 'No illegal characters in the domain name';
196 },
197 SYNTAX02 => sub {
198 __x # SYNTAX:SYNTAX02
199 'No hyphen (\'-\') at the start or end of the domain name';
200 },
201 SYNTAX03 => sub {
202 __x # SYNTAX:SYNTAX03
203 'There must be no double hyphen (\'--\') in position 3 and 4 of the domain name';
204 },
205 SYNTAX04 => sub {
206 __x # SYNTAX:SYNTAX04
207 'The NS name must have a valid domain/hostname';
208 },
209 SYNTAX05 => sub {
210 __x # SYNTAX:SYNTAX05
211 'Misuse of \'@\' character in the SOA RNAME field';
212 },
213 SYNTAX06 => sub {
214 __x # SYNTAX:SYNTAX06
215 'No illegal characters in the SOA RNAME field';
216 },
217 SYNTAX07 => sub {
218 __x # SYNTAX:SYNTAX07
219 'No illegal characters in the SOA MNAME field';
220 },
221 SYNTAX08 => sub {
222 __x # SYNTAX:SYNTAX08
223 'MX name must have a valid hostname';
224 },
225 DISCOURAGED_DOUBLE_DASH => sub {
226 __x # SYNTAX:DISCOURAGED_DOUBLE_DASH
227 'Domain name ({domain}) has a label ({label}) with a double hyphen (\'--\') '
228 . 'in position 3 and 4 (with a prefix which is not \'xn--\').',
229 @_;
230 },
231 INITIAL_HYPHEN => sub {
232 __x # SYNTAX:INITIAL_HYPHEN
233 'Domain name ({domain}) has a label ({label}) starting with an hyphen (\'-\').', @_;
234 },
235 IPV4_DISABLED => sub {
236 __x # SYNTAX:IPV4_DISABLED
237 'IPv4 is disabled, not sending "{rrtype}" query to {ns}.', @_;
238 },
239 IPV6_DISABLED => sub {
240 __x # SYNTAX:IPV6_DISABLED
241 'IPv6 is disabled, not sending "{rrtype}" query to {ns}.', @_;
242 },
243 MNAME_DISCOURAGED_DOUBLE_DASH => sub {
244 __x # SYNTAX:MNAME_DISCOURAGED_DOUBLE_DASH
245 'SOA MNAME ({domain}) has a label ({label}) with a double hyphen (\'--\') '
246 . 'in position 3 and 4 (with a prefix which is not \'xn--\').',
247 @_;
248 },
249 MNAME_NON_ALLOWED_CHARS => sub {
250 __x # SYNTAX:MNAME_NON_ALLOWED_CHARS
251 'Found illegal characters in SOA MNAME ({domain}).', @_;
252 },
253 MNAME_NUMERIC_TLD => sub {
254 __x # SYNTAX:MNAME_NUMERIC_TLD
255 'SOA MNAME ({domain}) within a \'numeric only\' TLD ({tld}).', @_;
256 },
257 MNAME_SYNTAX_OK => sub {
258 __x # SYNTAX:MNAME_SYNTAX_OK
259 'SOA MNAME ({domain}) syntax is valid.', @_;
260 },
261 MX_DISCOURAGED_DOUBLE_DASH => sub {
262 __x # SYNTAX:MX_DISCOURAGED_DOUBLE_DASH
263 'Domain name MX ({domain}) has a label ({label}) with a double hyphen (\'--\') '
264 . 'in position 3 and 4 (with a prefix which is not \'xn--\').',
265 @_;
266 },
267 MX_NON_ALLOWED_CHARS => sub {
268 __x # SYNTAX:MX_NON_ALLOWED_CHARS
269 'Found illegal characters in MX ({domain}).', @_;
270 },
271 MX_NUMERIC_TLD => sub {
272 __x # SYNTAX:MX_NUMERIC_TLD
273 'Domain name MX ({domain}) within a \'numeric only\' TLD ({tld}).', @_;
274 },
275 MX_SYNTAX_OK => sub {
276 __x # SYNTAX:MX_SYNTAX_OK
277 'Domain name MX ({domain}) syntax is valid.', @_;
278 },
279 NAMESERVER_DISCOURAGED_DOUBLE_DASH => sub {
280 __x # SYNTAX:NAMESERVER_DISCOURAGED_DOUBLE_DASH
281 'Nameserver ({domain}) has a label ({label}) with a double hyphen (\'--\') '
282 . 'in position 3 and 4 (with a prefix which is not \'xn--\').',
283 @_;
284 },
285 NAMESERVER_NON_ALLOWED_CHARS => sub {
286 __x # SYNTAX:NAMESERVER_NON_ALLOWED_CHARS
287 'Found illegal characters in the nameserver ({domain}).', @_;
288 },
289 NAMESERVER_NUMERIC_TLD => sub {
290 __x # SYNTAX:NAMESERVER_NUMERIC_TLD
291 'Nameserver ({domain}) within a \'numeric only\' TLD ({tld}).', @_;
292 },
293 NAMESERVER_SYNTAX_OK => sub {
294 __x # SYNTAX:NAMESERVER_SYNTAX_OK
295 'Nameserver ({domain}) syntax is valid.', @_;
296 },
297 NON_ALLOWED_CHARS => sub {
298 __x # SYNTAX:NON_ALLOWED_CHARS
299 'Found illegal characters in the domain name ({domain}).', @_;
300 },
301 NO_DOUBLE_DASH => sub {
302 __x # SYNTAX:NO_DOUBLE_DASH
303 'Domain name ({domain}) has no label with a double hyphen (\'--\') '
304 . 'in position 3 and 4 (with a prefix which is not \'xn--\').',
305 @_;
306 },
307 NO_ENDING_HYPHENS => sub {
308 __x # SYNTAX:NO_ENDING_HYPHENS
309 "Neither end of any label in the domain name ({domain}) has a hyphen.", @_;
310 },
311 NO_RESPONSE => sub {
312 __x # SYNTAX:NO_RESPONSE
313 'No response from {ns} asking for {domain}.', @_;
314 },
315 NO_RESPONSE_MX_QUERY => sub {
316 __x # SYNTAX:NO_RESPONSE_MX_QUERY
317 'No response from nameserver(s) on MX queries.', @_;
318 },
319 NO_RESPONSE_SOA_QUERY => sub {
320 __x # SYNTAX:NO_RESPONSE_SOA_QUERY
321 'No response from nameserver(s) on SOA queries.', @_;
322 },
323 ONLY_ALLOWED_CHARS => sub {
324 __x # SYNTAX:ONLY_ALLOWED_CHARS
325 'No illegal characters in the domain name ({domain}).', @_;
326 },
327 RNAME_MAIL_DOMAIN_INVALID => sub {
328 __x # SYNTAX:RNAME_MAIL_DOMAIN_INVALID
329 'The SOA RNAME mail domain ({domain}) cannot be resolved to a mail server with an IP address.', @_;
330 },
331 RNAME_MAIL_DOMAIN_LOCALHOST => sub {
332 __x # SYNTAX:RNAME_MAIL_DOMAIN_LOCALHOST
333 'The SOA RNAME mail domain ({domain}) resolved to a mail server with localhost ({localhost}) IP address.', @_;
334 },
335 RNAME_MAIL_ILLEGAL_CNAME => sub {
336 __x # SYNTAX:RNAME_MAIL_ILLEGAL_CNAME
337 'The SOA RNAME mail domain ({domain}) refers to an address which is an alias (CNAME).', @_;
338 },
339 RNAME_MISUSED_AT_SIGN => sub {
340 __x # SYNTAX:RNAME_MISUSED_AT_SIGN
341 "Misused '\@' character found in SOA RNAME field ({rname}).", @_;
342 },
343 RNAME_NO_AT_SIGN => sub {
344 __x # SYNTAX:RNAME_NO_AT_SIGN
345 'There is no misused \'@\' character in the SOA RNAME field ({rname}).', @_;
346 },
347 RNAME_RFC822_INVALID => sub {
348 __x # SYNTAX:RNAME_RFC822_INVALID
349 "Illegal character(s) found in SOA RNAME field ({rname}).", @_;
350 },
351 RNAME_RFC822_VALID => sub {
352 __x # SYNTAX:RNAME_RFC822_VALID
353 'The SOA RNAME field ({rname}) is compliant with RFC2822.', @_;
354 },
355 TERMINAL_HYPHEN => sub {
356 __x # SYNTAX:TERMINAL_HYPHEN
357 "Domain name ({domain}) has a label ({label}) ending with a hyphen ('-').", @_;
358 },
359 TEST_CASE_END => sub {
360 __x # SYNTAX:TEST_CASE_END
361 'TEST_CASE_END {testcase}.', @_;
362 },
363 TEST_CASE_START => sub {
364 __x # SYNTAX:TEST_CASE_START
365 'TEST_CASE_START {testcase}.', @_;
366 },
367 );
368  
369 =over
370  
371 =item tag_descriptions()
372  
373 my $hash_ref = tag_descriptions();
374  
375 Used by the L<built-in translation system|Zonemaster::Engine::Translator>.
376  
377 Returns a reference to a hash, the keys of which are the message tags and the corresponding values are strings (message IDs).
378  
379 =back
380  
381 =cut
382  
383 sub tag_descriptions {
384 return \%TAG_DESCRIPTIONS;
385 }
386  
387 =over
388  
389 =item version()
390  
391 my $version_string = version();
392  
393 Returns a string containing the version of the current module.
394  
395 =back
396  
397 =cut
398  
399 sub version {
400 return "$Zonemaster::Engine::Test::Syntax::VERSION";
401 }
402  
403 =head1 INTERNAL METHODS
404  
405 =over
406  
407 =item _emit_log()
408  
409 my $log_entry = _emit_log( $message_tag_string, $hash_ref );
410  
411 Adds a message to the L<logger|Zonemaster::Engine::Logger> for this module.
412 See L<Zonemaster::Engine::Logger::Entry/add($tag, $argref, $module, $testcase)> for more details.
413  
414 Takes a string (message tag) and a reference to a hash (arguments).
415  
416 Returns a L<Zonemaster::Engine::Logger::Entry> object.
417  
418 =back
419  
420 =cut
421  
422 sub _emit_log { my ( $tag, $argref ) = @_; return Zonemaster::Engine->logger->add( $tag, $argref, 'Syntax' ); }
423  
424 =over
425  
426 =item _ip_disabled_message()
427  
428 my $bool = _ip_disabled_message( $logentry_array_ref, $ns, @query_type_array );
429  
430 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.
431  
432 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).
433  
434 Returns a boolean.
435  
436 =back
437  
438 =cut
439  
440 sub _ip_disabled_message {
441 my ( $results_array, $ns, @rrtypes ) = @_;
442  
443 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv6}) and $ns->address->version == $IP_VERSION_6 ) {
444 push @$results_array, map {
445 _emit_log(
446 IPV6_DISABLED => {
447 ns => $ns->string,
448 rrtype => $_
449 }
450 )
451 } @rrtypes;
452 return 1;
453 }
454  
455 if ( not Zonemaster::Engine::Profile->effective->get(q{net.ipv4}) and $ns->address->version == $IP_VERSION_4 ) {
456 push @$results_array, map {
457 _emit_log(
458 IPV4_DISABLED => {
459 ns => $ns->string,
460 rrtype => $_,
461 }
462 )
463 } @rrtypes;
464 return 1;
465 }
466 return 0;
467 }
468  
469 =over
470  
471 =item _name_has_only_legal_characters()
472  
473 my $bool = _name_has_only_legal_characters( $name );
474  
475 Checks if a given name contains only allowed characters.
476  
477 Takes a L<Zonemaster::Engine::DNSName> object.
478  
479 Returns a boolean.
480  
481 =back
482  
483 =cut
484  
485 sub _name_has_only_legal_characters {
486 my ( $name ) = @_;
487  
488 if ( List::MoreUtils::all { m/\A[-A-Za-z0-9]+\z/smx } @{ $name->labels } ) {
489 return 1;
490 }
491 else {
492 return 0;
493 }
494 }
495  
496 =over
497  
498 =item _label_starts_with_hyphen()
499  
500 my $bool = _label_starts_with_hyphen( $name );
501  
502 Checks if a given name starts with an hyphen ('-').
503  
504 Takes a L<Zonemaster::Engine::DNSName> object.
505  
506 Returns a boolean.
507  
508 =back
509  
510 =cut
511  
512 sub _label_starts_with_hyphen {
513 my ( $label ) = @_;
514  
515 return 0 if not $label;
516  
517 if ( $label =~ /\A-/smgx ) {
518 return 1;
519 }
520 else {
521 return 0;
522 }
523 }
524  
525 =over
526  
527 =item _label_ends_with_hyphen()
528  
529 my $bool = _label_ends_with_hyphen( $name );
530  
531 Checks if a given name ends with an hyphen ('-').
532  
533 Takes a L<Zonemaster::Engine::DNSName> object.
534  
535 Returns a boolean.
536  
537 =back
538  
539 =cut
540  
541 sub _label_ends_with_hyphen {
542 my ( $label ) = @_;
543  
544 return 0 if not $label;
545  
546 if ( $label =~ /-\z/smgx ) {
547 return 1;
548 }
549 else {
550 return 0;
551 }
552 }
553  
554 =over
555  
556 =item _label_not_ace_has_double_hyphen_in_position_3_and_4()
557  
558 my $bool = _label_not_ace_has_double_hyphen_in_position_3_and_4( $name );
559  
560 Checks if a given name does not contain a double hyphen ('--'), with the exception of 'xn--'.
561  
562 Takes a L<Zonemaster::Engine::DNSName> object.
563  
564 Returns a boolean.
565  
566 =back
567  
568 =cut
569  
570 sub _label_not_ace_has_double_hyphen_in_position_3_and_4 {
571 my ( $label ) = @_;
572  
573 return 0 if not $label;
574  
575 if ( $label =~ /\A..--/smx and $label !~ /\Axn/ismx ) {
576 return 1;
577 }
578 else {
579 return 0;
580 }
581 }
582  
583 =over
584  
585 =item _check_name_syntax()
586  
587 my @logentry_array = _check_name_syntax( $label_prefix_string, $name );
588  
589 Checks the syntax of a given name. Makes use of L</_name_has_only_legal_characters()> and L</_label_not_ace_has_double_hyphen_in_position_3_and_4()>.
590 Used as an helper function for Test Cases L<Syntax04|/syntax04()>, L<Syntax07|/syntax07()> and L<Syntax08|/syntax08()>.
591  
592 Takes a string (label prefix) and either a string (name) or a L<Zonemaster::Engine::DNSName> object.
593  
594 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
595  
596 =back
597  
598 =cut
599  
600 sub _check_name_syntax {
601 my ( $info_label_prefix, $name ) = @_;
602 my @results;
603  
604 $name = Zonemaster::Engine::Util::name( $name );
605  
606 if ( not _name_has_only_legal_characters( $name ) ) {
607 push @results,
608 _emit_log(
609 $info_label_prefix
610 . q{_NON_ALLOWED_CHARS} => {
611 domain => $name,
612 }
613 );
614 }
615  
616 if ( $name ne q{.} ) {
617 foreach my $local_label ( @{ $name->labels } ) {
618 if ( _label_not_ace_has_double_hyphen_in_position_3_and_4( $local_label ) ) {
619 push @results,
620 _emit_log(
621 $info_label_prefix
622 . q{_DISCOURAGED_DOUBLE_DASH} => {
623 label => $local_label,
624 domain => "$name",
625 }
626 );
627 }
628 }
629  
630 my $tld = @{ $name->labels }[-1];
631 if ( $tld =~ /\A\d+\z/smgx ) {
632 push @results,
633 _emit_log(
634 $info_label_prefix
635 . q{_NUMERIC_TLD} => {
636 domain => "$name",
637 tld => $tld,
638 }
639 );
640 }
641  
642 } ## end if ( $name ne q{.} )
643  
644 if ( not grep { $_->tag ne q{TEST_CASE_START} } @results ) {
645 push @results,
646 _emit_log(
647 $info_label_prefix
648 . q{_SYNTAX_OK} => {
649 domain => "$name",
650 }
651 );
652 }
653  
654 return @results;
655 } ## end sub _check_name_syntax
656  
657 =head1 TESTS
658  
659 =over
660  
661 =item syntax01()
662  
663 my @logentry_array = syntax01( $zone );
664  
665 Runs the L<Syntax01 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax01.md>.
666  
667 Takes a L<Zonemaster::Engine::Zone> object.
668  
669 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
670  
671 =back
672  
673 =cut
674  
675 sub syntax01 {
676 my ( $class, $zone ) = @_;
677  
678 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax01';
679 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
680  
681 my $name = $zone->name;
682  
683 if ( _name_has_only_legal_characters( $name ) ) {
684 push @results,
685 _emit_log(
686 ONLY_ALLOWED_CHARS => {
687 domain => $name,
688 }
689 );
690 }
691 else {
692 push @results,
693 _emit_log(
694 NON_ALLOWED_CHARS => {
695 domain => $name,
696 }
697 );
698 }
699  
700 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
701 } ## end sub syntax01
702  
703 =over
704  
705 =item syntax02()
706  
707 my @logentry_array = syntax02( $zone );
708  
709 Runs the L<Syntax02 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax02.md>.
710  
711 Takes a L<Zonemaster::Engine::Zone> object.
712  
713 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
714  
715 =back
716  
717 =cut
718  
719 sub syntax02 {
720 my ( $class, $zone ) = @_;
721  
722 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax02';
723 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
724  
725 my $name = $zone->name;
726  
727 foreach my $local_label ( @{ $name->labels } ) {
728 if ( _label_starts_with_hyphen( $local_label ) ) {
729 push @results,
730 _emit_log(
731 INITIAL_HYPHEN => {
732 label => $local_label,
733 domain => $name,
734 }
735 );
736 }
737 if ( _label_ends_with_hyphen( $local_label ) ) {
738 push @results,
739 _emit_log(
740 TERMINAL_HYPHEN => {
741 label => $local_label,
742 domain => $name,
743 }
744 );
745 }
746 } ## end foreach my $local_label ( @...)
747  
748 if ( scalar @{ $name->labels } and not grep { $_->tag ne q{TEST_CASE_START} } @results ) {
749 push @results,
750 _emit_log(
751 NO_ENDING_HYPHENS => {
752 domain => $name,
753 }
754 );
755 }
756  
757 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
758 } ## end sub syntax02
759  
760 =over
761  
762 =item syntax03()
763  
764 my @logentry_array = syntax03( $zone );
765  
766 Runs the L<Syntax03 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax03.md>.
767  
768 Takes a L<Zonemaster::Engine::Zone> object.
769  
770 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
771  
772 =back
773  
774 =cut
775  
776 sub syntax03 {
777 my ( $class, $zone ) = @_;
778  
779 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax03';
780 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
781  
782 my $name = $zone->name;
783  
784 foreach my $local_label ( @{ $name->labels } ) {
785 if ( _label_not_ace_has_double_hyphen_in_position_3_and_4( $local_label ) ) {
786 push @results,
787 _emit_log(
788 DISCOURAGED_DOUBLE_DASH => {
789 label => $local_label,
790 domain => $name,
791 }
792 );
793 }
794 }
795  
796 if ( scalar @{ $name->labels } and not grep { $_->tag ne q{TEST_CASE_START} } @results ) {
797 push @results,
798 _emit_log(
799 NO_DOUBLE_DASH => {
800 domain => $name,
801 }
802 );
803 }
804  
805 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
806 } ## end sub syntax03
807  
808 =over
809  
810 =item syntax04()
811  
812 my @logentry_array = syntax04( $zone );
813  
814 Runs the L<Syntax04 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax04.md>.
815  
816 Takes a L<Zonemaster::Engine::Zone> object.
817  
818 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
819  
820 =back
821  
822 =cut
823  
824 sub syntax04 {
825 my ( $class, $zone ) = @_;
826  
827 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax04';
828 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
829  
830 foreach my $local_nsname (
831 uniq(
832 @{ Zonemaster::Engine::TestMethods->method2( $zone ) },
833 @{ Zonemaster::Engine::TestMethods->method3( $zone ) }
834 )
835 )
836 {
837 push @results, _check_name_syntax( q{NAMESERVER}, $local_nsname );
838 }
839  
840 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
841 }
842  
843 =over
844  
845 =item syntax05()
846  
847 my @logentry_array = syntax05( $zone );
848  
849 Runs the L<Syntax05 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax05.md>.
850  
851 Takes a L<Zonemaster::Engine::Zone> object.
852  
853 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
854  
855 =back
856  
857 =cut
858  
859 sub syntax05 {
860 my ( $class, $zone ) = @_;
861  
862 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax05';
863 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
864  
865 my $p = $zone->query_one( $zone->name, q{SOA} );
866  
867 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
868 my $rname = $soa->rname;
869 $rname =~ s/\\./\./smgx;
870 if ( index( $rname, q{@} ) != -1 ) {
871 push @results,
872 _emit_log(
873 RNAME_MISUSED_AT_SIGN => {
874 rname => $soa->rname,
875 }
876 );
877 }
878 else {
879 push @results,
880 _emit_log(
881 RNAME_NO_AT_SIGN => {
882 rname => $soa->rname,
883 }
884 );
885 }
886 } ## end if ( $p and my ( $soa ...))
887 else {
888 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
889 }
890  
891 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
892 } ## end sub syntax05
893  
894 =over
895  
896 =item syntax06()
897  
898 my @logentry_array = syntax06( $zone );
899  
900 Runs the L<Syntax06 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax06.md>.
901  
902 Takes a L<Zonemaster::Engine::Zone> object.
903  
904 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
905  
906 =back
907  
908 =cut
909  
910 sub syntax06 {
911 my ( $class, $zone ) = @_;
912  
913 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax06';
914 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
915  
916 my @nss;
917 {
918 my %nss = map { $_->string => $_ }
919 @{ Zonemaster::Engine::TestMethods->method4( $zone ) },
920 @{ Zonemaster::Engine::TestMethods->method5( $zone ) };
921 @nss = sort values %nss;
922 }
923  
924 my %rname_candidates;
925 my %seen_mail_servers;
926 my $invalid_exchanges = undef;
927 for my $ns ( @nss ) {
928 if ( _ip_disabled_message( \@results, $ns, q{SOA} ) ) {
929 next;
930 }
931  
932 my $p = $ns->query( $zone->name, q{SOA}, { recurse => 0, usevc => 0 } );
933  
934 if ( not $p ) {
935 push @results,
936 _emit_log(
937 NO_RESPONSE => {
938 ns => $ns->string,
939 domain => $zone->name,
940 }
941 );
942 next;
943 }
944  
945 my ( $soa ) = $p->get_records( q{SOA}, q{answer} );
946  
947 if ( not $soa ) {
948 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
949 next;
950 }
951  
952 my $rname = $soa->rname;
953 $rname =~ s/([^\\])[.]/$1@/smx; # Replace first non-escaped dot with an at-sign
954 $rname =~ s/[\\][.]/./smgx; # Un-escape dots
955 $rname =~ s/[.]\z//smgx; # Validator does not like final dots
956 if ( not Email::Valid->address( $rname ) ) {
957 push @results,
958 _emit_log(
959 RNAME_RFC822_INVALID => {
960 rname => $rname,
961 }
962 );
963 next;
964 }
965  
966 my $domain = name( ( $rname =~ s/.*@//r ) );
967 my $p_mx = Zonemaster::Engine::Recursor->recurse( $domain, q{MX} );
968  
969 if ( not $p_mx or $p_mx->rcode ne 'NOERROR' ) {
970 push @results, _emit_log( RNAME_MAIL_DOMAIN_INVALID => { domain => $domain } );
971 next;
972 }
973  
974 # Retrieve followed CNAME, if any
975 if ( $domain ne ($p_mx->question)[0]->owner ) { # CNAME was followed in a new recursive query
976 $domain = name( ($p_mx->question)[0]->owner );
977 }
978 elsif ( scalar $p_mx->get_records( q{CNAME}, q{answer} ) ) { # CNAME was followed in the same query
979 my %cnames = map { name( $_->owner ) => name( $_->cname ) } $p_mx->get_records( q{CNAME}, q{answer} );
980 $domain = $cnames{$domain} while $cnames{$domain};
981 }
982  
983 # Determine mail server(s)
984 my @mail_servers;
985 if ( my @mxs = $p_mx->get_records_for_name( q{MX}, $domain ) ) {
986 @mail_servers = uniq( map { $_->exchange } @mxs );
987 }
988 else {
989 @mail_servers = ( $domain );
990 }
991  
992 for my $mail_server ( @mail_servers ) {
993 next if $seen_mail_servers{$mail_server};
994 $seen_mail_servers{$mail_server} = 1;
995  
996 # Assume mail server is invalid until we see an actual IP address
997 my $exchange_valid = 0;
998 $invalid_exchanges = 0 unless defined $invalid_exchanges;
999  
1000 # Lookup IPv4 address for mail server
1001 my $p_a = Zonemaster::Engine::Recursor->recurse( $mail_server, q{A} );
1002 if ( $p_a ) {
1003 if ( $p_a->get_records( q{CNAME}, q{answer} ) ) {
1004 push @results, _emit_log( RNAME_MAIL_ILLEGAL_CNAME => { domain => $mail_server } );
1005 }
1006 else {
1007 my @rrs_a = grep { $_->owner eq $mail_server } $p_a->get_records( q{A}, q{answer} );
1008  
1009 if ( grep { $_->address eq q{127.0.0.1} } @rrs_a ) {
1010 push @results, _emit_log( RNAME_MAIL_DOMAIN_LOCALHOST => { domain => $mail_server, localhost => q{127.0.0.1} } );
1011 }
1012 elsif ( @rrs_a ) {
1013 $exchange_valid = 1;
1014 }
1015 }
1016 }
1017  
1018 # Lookup IPv6 address for mail server
1019 my $p_aaaa = Zonemaster::Engine::Recursor->recurse( $mail_server, q{AAAA} );
1020 if ( $p_aaaa ) {
1021 if ( $p_aaaa->get_records( q{CNAME}, q{answer} ) ) {
1022 push @results, _emit_log( RNAME_MAIL_ILLEGAL_CNAME => { domain => $mail_server } );
1023 }
1024 else {
1025 my @rrs_aaaa = grep { $_->owner eq $mail_server } $p_aaaa->get_records( q{AAAA}, q{answer} );
1026  
1027 if ( grep { $_->address eq q{::1} } @rrs_aaaa) {
1028 push @results, _emit_log( RNAME_MAIL_DOMAIN_LOCALHOST => { domain => $mail_server, localhost => q{::1} } );
1029 }
1030 elsif ( @rrs_aaaa ) {
1031 $exchange_valid = 1;
1032 }
1033 }
1034 }
1035  
1036 # Emit verdict for mail server
1037 if ( $exchange_valid ) {
1038 $rname_candidates{$rname} = 1;
1039 }
1040 else {
1041 push @results, _emit_log( RNAME_MAIL_DOMAIN_INVALID => { domain => $mail_server } );
1042 delete $rname_candidates{$rname};
1043 $invalid_exchanges++;
1044 }
1045 } ## end for my $mail_server ( @mail_servers)
1046  
1047 } ## end for my $ns ( @nss )
1048  
1049 if ( defined $invalid_exchanges and $invalid_exchanges == 0 ) {
1050 push @results,
1051 _emit_log(
1052 RNAME_RFC822_VALID => {
1053 rname => $_,
1054 }
1055 ) for keys %rname_candidates;
1056 }
1057  
1058 return ( @results, _emit_log( TEST_CASE_END => { testcase => (split /::/, (caller(0))[3])[-1] } ) );
1059 } ## end sub syntax06
1060  
1061 =over
1062  
1063 =item syntax07()
1064  
1065 my @logentry_array = syntax07( $zone );
1066  
1067 Runs the L<Syntax07 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax07.md>.
1068  
1069 Takes a L<Zonemaster::Engine::Zone> object.
1070  
1071 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1072  
1073 =back
1074  
1075 =cut
1076  
1077 sub syntax07 {
1078 my ( $class, $zone ) = @_;
1079  
1080 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax07';
1081 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1082  
1083 my $p = $zone->query_one( $zone->name, q{SOA} );
1084  
1085 if ( $p and my ( $soa ) = $p->get_records( q{SOA}, q{answer} ) ) {
1086 my $mname = $soa->mname;
1087  
1088 push @results, _check_name_syntax( q{MNAME}, $mname );
1089 }
1090 else {
1091 push @results, _emit_log( NO_RESPONSE_SOA_QUERY => {} );
1092 }
1093  
1094 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1095 }
1096  
1097 =over
1098  
1099 =item syntax08()
1100  
1101 my @logentry_array = syntax08( $zone );
1102  
1103 Runs the L<Syntax08 Test Case|https://github.com/zonemaster/zonemaster/blob/master/docs/public/specifications/tests/Syntax-TP/syntax08.md>.
1104  
1105 Takes a L<Zonemaster::Engine::Zone> object.
1106  
1107 Returns a list of L<Zonemaster::Engine::Logger::Entry> objects.
1108  
1109 =back
1110  
1111 =cut
1112  
1113 sub syntax08 {
1114 my ( $class, $zone ) = @_;
1115  
1116 local $Zonemaster::Engine::Logger::TEST_CASE_NAME = 'Syntax08';
1117 push my @results, _emit_log( TEST_CASE_START => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } );
1118  
1119 my $p = $zone->query_one( $zone->name, q{MX} );
1120  
1121 if ( $p ) {
1122 my %mx = map { $_->exchange => 1 } $p->get_records( q{MX}, q{answer} );
1123 foreach my $mx ( sort keys %mx ) {
1124 push @results, _check_name_syntax( q{MX}, $mx );
1125 }
1126 }
1127 else {
1128 push @results, _emit_log( NO_RESPONSE_MX_QUERY => {} );
1129 }
1130  
1131 return ( @results, _emit_log( TEST_CASE_END => { testcase => $Zonemaster::Engine::Logger::TEST_CASE_NAME } ) );
1132 }
1133  
1134 1;