File Coverage

blib/lib/Net/ASN.pm

Criterion	Covered	Total	%
statement	192	207	92.7
branch	72	100	72.0
condition	26	60	43.3
subroutine	32	32	100.0
pod	16	16	100.0
total	338	415	81.4

#    ASN.pm - Perl module to manipulate autonomous system numbers
#
#    Author: David J. Freedman
#
#    Copyright (C) 2008 Convergence Inc.
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms as perl itself.
#

package Net::ASN;

use strict;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);

BEGIN {

	require Exporter;

	@ISA = qw(Exporter);

	@EXPORT = qw();

	%EXPORT_TAGS = (
                    all => [qw{
				plaintodot	plaintodotplus
				dottodotplus	dottoplain
				dottoplain16	dotplustodot
				dotplustoplain	dotplustoplain16
				isprivateasn
                                } ],
                   );

	@EXPORT_OK = qw();

	Exporter::export_ok_tags('all');

    	$VERSION = '1.07';
}

# Preloaded methods go here.
use Carp;

#Constants
use constant	AS_TRANS => 23456;
use constant	AS16_START 	   => 1;
use constant	AS16_PRIVATE_START => 64512;
use constant	AS16_PRIVATE_END   => 65534;
use constant	AS16_END	   => 65535;
use constant	AS32_START 	   => 65536;
use constant	AS32_PRIVATE_START => 4200000000;
use constant	AS32_PRIVATE_END   => 4294967294;
use constant	AS32_END 	   => 4294967295;

##OO Methods

#Initialise with an ASN
#
sub new {

	my $class 	= shift;
	my $self	= {};

	my $asn		= shift;

	my $asasdot	= shift;

	bless $self, $class;

	$self->_parseasn($asn,$asasdot);	#Parse the ASN

	return $self;

}

#Parses an ASN, in any format
sub _parseasn ($;$) {

	my $self = shift;
	my $inasn = shift;
	my $asasdot = shift;

	#Perform some basic checks
	#
	#1) did we even get a parameter?
	unless ($inasn) {
		croak __PACKAGE__, ": ASN not provided";
	}
	#2) does the ASN contain a valid character set?
	unless ($inasn=~m/^[\d\.]+$/) {
		croak __PACKAGE__, ": Invalid ASN (Illegal Characters)";
	}
	#3) Next, check the format

	if ($inasn=~m/^(\d+)$/) {		#ASN is ASN16 (1-65535) or ASN32 ASPLAIN (1-4294967295) or ASDOT if forced
		if ($asasdot) {
			if ($inasn >= AS16_START && $inasn <=  AS16_END) {
				$self->{_informat} = 'asdot';
				$self->{_asdot} = $inasn;
			}
			else {
				croak __PACKAGE__, ": Invalid ASDOT ASN (ASDOT does NOT permit ASPLAIN notation for ASNs 63356-4294967295)";
			}
		}
		elsif ($inasn >= AS16_START && $inasn <=  AS16_END) {
			$self->{_informat} = 'asplain16';
			$self->{_asplain16} = $inasn;
		}
		elsif ($inasn >= AS32_START && $inasn <= AS32_END) {
			$self->{_informat} = 'asplain32';
			$self->{_asplain32} = $inasn;
		}
		else {
			croak __PACKAGE__, ": Invalid ASPLAIN ASN (must be between 1-4294967295)";
		}
	}
	elsif ($inasn=~m/^(\d+)\.(\d+)$/) {	#ASN is ASN32 ASDOT+ notation or ASDOT if forced

		my $firstasn = $1;
		my $secondasn = $2;

		unless (
			($firstasn >= 0 && $firstasn <= AS16_END) &&
			($secondasn >= 0 && $secondasn <= AS16_END) &&
			(
				($firstasn  > 0) ||
				($secondasn > 0)
			)
		) {
			croak __PACKAGE__, ": Invalid ASDOT(+) ASN (must be between 0-65535.0-65535 and NOT 0.0)";
		}

		#Allow input as ASDOT if $asasdot is populated
		if ($asasdot) {
			if ($firstasn > 0) {
				$self->{_informat} = 'asdot';
			}
			else {
				croak __PACKAGE__, ": Invalid ASDOT ASN (ASDOT does NOT permit ASDOT+ notation for ASNs 0-65535)";
			}
		}
		else {
			$self->{_informat} = 'asdotplus';
		}
		$self->{_asdotsedtet1} = $firstasn;
		$self->{_asdotsedtet2} = $secondasn;

	}
	else {
		croak __PACKAGE__, ": Invalid ASN (Illegal Format)";
	}

	return;

}

sub _plaintodot ($) {

	my $self = shift;
	my $asplain = shift;

        unless ($asplain=~m/^(\d+)$/) {
		die ("Internal Error: _plaintodot called with invalid plain");
        }
        else {
                my $asdot=int($asplain/65536);
                $asdot .= ".";
                $asdot .= ($asplain - ($asdot*65536));
                return $asdot;
        }

}

sub _dottoplain ($) {

	my $self = shift;
	my $asdot = shift;

        unless ($asdot=~m/^(\d+)\.(\d+)$/) {
		die("Internal Error: _dottoplain called with invalid dot");
        }
        else {
                my $asplain1 = $1;
                my $asplain2 = $2;
                my $asplain = (65536 * $asplain1);
                $asplain+=$asplain2;
                return $asplain;
        }
}

##Produce ASDOT representation of parsed ASN
sub toasdot () {

	my $self = shift;
	if ($self->{_informat} eq 'asdot') {		#User wants asdot and we already have it, just return it
		if ($self->{_asdot}) {
			return $self->{_asdot};
		}
		else {
			my $value = "$self->{_asdotsedtet1}.$self->{_asdotsedtet2}";
			return ($value);
		}

	}
	elsif ($self->{_informat} eq 'asdotplus') {	#User wants asdot and has given us asdotplus, so return asplain if
		if ($self->{_asdotsedtet1} == 0) {	#If first sedtet is 0, return the second only
			return ($self->{_asdotsedtet2});
		}
		else {					#Else, return both
			my $value = "$self->{_asdotsedtet1}.$self->{_asdotsedtet2}";
			return ($value);
		}
	}
	elsif ($self->{_informat} eq 'asplain16') {	#User wants asdot and has given us an 16 bit asplain (just return asplain)
		my $value = $self->{_asplain16};
		return ($value);
	}
	elsif ($self->{_informat} eq 'asplain32') {	#User wants asdot and has given us an 32 bit asplain
		my $value = $self->{_asplain32};
		$value = $self->_plaintodot($value);
		return ($value);
	}
	else {
		die ("Internal Error: no acceptable informat defined");
	}

}

##Produce ASDOT+ representation of parsed ASN
sub toasdotplus () {

        my $self = shift;
	if ($self->{_informat} eq 'asdot') {		#User wants asdotplus and we have asdot
		if ($self->{_asdot}) {
			my $value = $self->_plaintodot($self->{_asdot});
			return ($value);
		}
		else {
			my $value = "$self->{_asdotsedtet1}.$self->{_asdotsedtet2}";
			return ($value);
		}
	}
        elsif ($self->{_informat} eq 'asdotplus') {     #User wants asdotplus and we have it, just return it
                my $value = "$self->{_asdotsedtet1}.$self->{_asdotsedtet2}";
                return ($value);
        }
        elsif ($self->{_informat} eq 'asplain16') {     #User wants asdotplus and has given us an 16 bit asplain
		my $value = $self->{_asplain16};
		$value = $self->_plaintodot($value);
		return ($value);
        }
        elsif ($self->{_informat} eq 'asplain32') {     #User wants asdotplus and has given us an 32 bit asplain
                my $value = $self->{_asplain32};
                $value = $self->_plaintodot($value);
                return ($value);
        }
        else {
                die ("Internal Error: no acceptable informat defined");
        }

}

##Produce ASPLAIN representation of parsed ASN (32 bit version)
sub toasplain () {

	my $self = shift;

	if ($self->{_informat} eq 'asdot') {		#User wants asplain and we have asdot
		if ($self->{_asdot}) {
			return ($self->{_asdot});
		}
		else {
			my $value = "$self->{_asdotsedtet1}.$self->{_asdotsedtet2}";
			$value = $self->_dottoplain($value);
			return ($value);
		}
	}
	elsif ($self->{_informat} eq 'asplain16') {	#User wants asplain and we have it
		my $value = $self->{_asplain16};
		return ($value);
	}
	elsif ($self->{_informat} eq 'asplain32') {	#User wants asplain and we have it
		my $value = $self->{_asplain32};
		return ($value);
	}
	elsif ($self->{_informat} eq 'asdotplus') {	#User wants asplain and has given us asdotplus so return asplain
		my $value = "$self->{_asdotsedtet1}.$self->{_asdotsedtet2}";
		$value = $self->_dottoplain($value);
		return ($value);
	}
        else {
                die ("Internal Error: no acceptable informat defined");
        }
}

##Produce ASPLAIN representation of parsed ASN (16 bit version)
sub toasplain16 () {

        my $self = shift;

	if ($self->{_informat} eq 'asdot') {		#User wants asplain16 and we have asdot
		if ($self->{_asdot}) {
			return ($self->{_asdot});
		}
		else {
			return (AS_TRANS);
		}
	}
        elsif ($self->{_informat} eq 'asplain16') {     #User wants asplain and we have it
                my $value = $self->{_asplain16};
                return ($value);
        }
        elsif ($self->{_informat} eq 'asplain32') {     #User wants asplain so return AS_TRANS
                return (AS_TRANS);
        }
        elsif ($self->{_informat} eq 'asdotplus') {     #User wants asplain and has given us asdotplus, return AS_TRANS for 32 bit
		if ($self->{_asdotsedtet1} == 0) {
			return ($self->{_asdotsedtet2});
		}
		else {
			return (AS_TRANS);
		}
        }
        else {
                die ("Internal Error: no acceptable informat defined");
        }
}

##Return parsed type
sub gettype () {
	my $self = shift;
	my $informat = $self->{_informat};
	$informat=~s/\d+//g;	#Remove ASPLAIN differentiation
	return ($informat);
}

##RFC 6996 reserves some ASN's for private use
sub isprivate {
    my $self = shift;
    my $asn = $self->toasplain;
    if ( ( $asn >= AS16_PRIVATE_START && $asn <= AS16_PRIVATE_END ) ||
         ( $asn >= AS32_PRIVATE_START && $asn <= AS32_PRIVATE_END ) ) {
         return 1;
     }
     return 0;
 }

###NON OO Function wrappers
##toasdot
sub plaintodot ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	croak __PACKAGE__, ": Must provide ASPLAIN" unless ($inasn=~m/^(\d+)$/);	#Ensure only numerical is passed
	my $asn = Net::ASN->new($inasn) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->toasdot);
}
##toasdotplus
sub plaintodotplus ($) {
        my $inasn = shift;
        croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	croak __PACKAGE__, ": Must provide ASPLAIN" unless ($inasn=~m/^(\d+)$/);	#Ensure only numerical is passed
        my $asn = Net::ASN->new($inasn) || croak __PACKAGE__, ": Could not create new Net::ASN object";
        return ($asn->toasdotplus);
}
##toasdotplus
sub dottodotplus ($) {
        my $inasn = shift;
        croak __PACKAGE__, ": No ASN specified" unless ($inasn);
        my $asn = Net::ASN->new($inasn,1) || croak __PACKAGE__, ": Could not create new Net::ASN object";
        return ($asn->toasdotplus);
}
##toasplain
sub dottoplain ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	my $asn = Net::ASN->new($inasn,1) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->toasplain);
}
##toasplain16
sub dottoplain16 ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	my $asn = Net::ASN->new($inasn,1) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->toasplain16);
}
##toasdot again
sub dotplustodot ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	croak __PACKAGE__, ": Must provide ASDOT+" unless ($inasn=~m/\./);	#Ensure only dotted is passed
	my $asn = Net::ASN->new($inasn) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->toasdot);
}
##toasplain
sub dotplustoplain ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	croak __PACKAGE__, ": Must provide ASDOT+" unless ($inasn=~m/\./);	#Ensure only dotted is passed
	my $asn = Net::ASN->new($inasn) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->toasplain);
}
##toasplain16
sub dotplustoplain16 ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	croak __PACKAGE__, ": Must provide ASDOT+" unless ($inasn=~m/\./);	#Ensure only dotted is passed
	my $asn = Net::ASN->new($inasn) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->toasplain16);
}

##isprivate
sub isprivateasn ($) {
	my $inasn = shift;
	croak __PACKAGE__, ": No ASN specified" unless ($inasn);
	my $asn = Net::ASN->new($inasn) || croak __PACKAGE__, ": Could not create new Net::ASN object";
	return ($asn->isprivate);
}

1;
__END__