File Coverage

blib/lib/Data/Validate/Domain.pm

Criterion	Covered	Total	%
statement	63	64	98.4
branch	46	48	95.8
condition	6	9	66.6
subroutine	10	10	100.0
pod	4	4	100.0
total	129	135	95.5

package Data::Validate::Domain;

use strict;
use warnings;

our $VERSION = '0.15';

use Net::Domain::TLD 1.74 qw(tld_exists);

use Exporter qw( import );

## no critic (Modules::ProhibitAutomaticExportation)
our @EXPORT = qw(
    is_domain
    is_hostname
    is_domain_label
);

sub new {
    my $class = shift;

    return bless {@_}, ref($class) || $class;
}

# -------------------------------------------------------------------------------

sub is_domain {
    my ( $value, $opt ) = _maybe_oo(@_);

    my ( $hostname, $bits ) = _domain_labels( $value, $opt );

    return unless $bits;

    my $tld = $bits->[-1];

    # domain_allow_single_label set to true disables this check
    unless ( $opt->{domain_allow_single_label} ) {

        # All domains have more then 1 label (neely.cx good, com not good)
        return if @{$bits} < 2;
    }

    return $hostname if $opt->{domain_disable_tld_validation};

    # If the option to enable domain_private_tld is enabled
    # and a private domain is specified, then we return if that matches
    if ( exists $opt->{domain_private_tld}
        && ref( $opt->{domain_private_tld} ) ) {
        my $lc_tld = lc($tld);
        if ( ref( $opt->{domain_private_tld} ) eq 'HASH' ) {
            if ( exists $opt->{domain_private_tld}->{$lc_tld} ) {
                return $hostname;
            }
        }
        else {
            if ( $tld =~ $opt->{domain_private_tld} ) {
                return $hostname;
            }
        }
    }

    # Verify domain has a valid TLD
    return unless tld_exists($tld);

    return $hostname;
}

# -------------------------------------------------------------------------------

sub is_hostname {
    my ( $value, $opt ) = _maybe_oo(@_);

    my ($hostname) = _domain_labels( $value, $opt );

    # We do not verify TLD for hostnames, as hostname.subhost is a valid hostname

    return $hostname;
}

sub _domain_labels {
    my ( $value, $opt ) = @_;

    return unless defined($value);

    # FYI: DNS limits names to 255 octets, encoded to RDATA. Each label
    # includes a length-octet prefix; those length octets count against the
    # 255-octet maximum. The number of labels exceeds the number of dots by 1
    # (assuming no trailing dot), and the number of length octets exceeds
    # number of labels by 1 (since there’s always a trailing NUL octet). The
    # effective limit is thus 255 - 1 - 1, or 253. See
    # https://devblogs.microsoft.com/oldnewthing/20120412-00/?p=7873 for a
    # more detailed explanation of this.

    my $trailing_dot = $value =~ s/\.\z// ? q{.} : q{};

    my $encoded_length = ( $trailing_dot ? 1 : 2 ) + length($value);

    return if $encoded_length > 255;

    my @bits;
    foreach my $label ( split /\./, $value, -1 ) {
        my $bit = is_domain_label( $label, $opt );
        return unless defined $bit;
        push( @bits, $bit );
    }

    return unless @bits;

    return ( join( '.', @bits ) . $trailing_dot, \@bits );
}

sub is_domain_label {
    my ( $value, $opt ) = _maybe_oo(@_);

    return unless defined($value);

    # Fix Bug: 41033
    return if ( $value =~ /\n/ );

    # bail if we are dealing with more then just a hostname
    return if ( $value =~ /\./ );
    my $length = length($value);
    my $hostname;
    if ( $length == 1 ) {
        if ( $opt->{domain_allow_underscore} ) {
            ($hostname) = $value =~ /^([0-9A-Za-z\_])$/;
        }
        else {
            ($hostname) = $value =~ /^([0-9A-Za-z])$/;
        }
    }
    elsif ( $length > 1 && $length <= 63 ) {
        if ( $opt->{domain_allow_underscore} ) {
            ($hostname)
                = $value =~ /^([0-9A-Za-z\_][0-9A-Za-z\-\_]*[0-9A-Za-z])$/;
        }
        else {
            ($hostname)
                = $value =~ /^([0-9A-Za-z][0-9A-Za-z\-]*[0-9A-Za-z])$/;
        }
    }
    else {
        return;
    }
    return $hostname;
}

sub _maybe_oo {
    if ( ref $_[0] ) {
        return @_[ 1, 0 ];
    }
    else {
        return ( $_[0], ( defined $_[1] ? $_[1] : {} ) );
    }
}

1;

# ABSTRACT: Domain and host name validation

__END__