| 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; |