Net::BGP::ASPath(3p)

NAME
Net::BGP::ASPath - Class encapsulating BGP-4 AS Path information

SYNOPSIS
    use Net::BGP::ASPath;

    # Constructor
    $aspath  = Net::BGP::ASPath->new(undef, { as4 => 1 });
    $aspath2 = Net::BGP::ASPath->new([65001,65002]);
    $aspath3 = Net::BGP::ASPath->new("(65001 65002) 65010");
    $aspath4 = Net::BGP::ASPath->new("65001 {65011,65010}");

    # Object Copy
    $clone   = $aspath->clone();

    # Modifiers;
    $aspath  = $aspath->prepend(64999);
    $aspath  = $aspath->prepend("64999 65998");
    $aspath  = $aspath->prepend([64999,65998]);

    $aspath  = $aspath->prepend("(64999 65998)");
    $aspath  = $aspath->prepend_confed("64999 65998");

    $aspath += "65001 65002";    # Same as $aspath->prepend("65001 65002")

    $aspath5 = $aspath->striped; # New object
    $aspath  = $aspath->strip;   # Same modified

    $aspath  = $aspath->cleanup  # Same modified

    # Aggregation
    $aspath  = $aspath1->aggregate($aspath2,$aspath3);
    $aspath  = Net::BGP::ASPath->aggregate($aspath1,$aspath2,$aspath3);

    # Accessor Methods
    $length    = $aspath->length;
    $string    = $aspath->as_string;
    $array_ref = $aspath->asarray

    # In context
    $string    = "The AS path is: " . $aspath;
    $firstas   = $aspath[0];

    # Length comparisons
    if ($aspath < $aspath2) { ... };
    if ($aspath > $aspath2) { ... };
    if ($aspath == $aspath2) { ... };
    if ($aspath != $aspath2) { ... };
    @sorted = sort { $a <=> $b } ($aspath, $aspath2, $aspath3, $aspath4);

    # Path comparisons
    if ($aspath eq $aspath2) { ... };
    if ($aspath ne $aspath2) { ... };

DESCRIPTION
This module encapsulates the data contained in a BGP-4 AS_PATH, inluding confederation extentions.

CONSTRUCTOR

new() - create a new Net::BGP::ASPath object
        $aspath = Net::BGP::ASPath->new( PATHDATA, OPTIONS );

    This is the constructor for Net::BGP::ASPath objects. It returns a reference to the newly created object. The first parameter may be either:

    ARRAY_REF
        An array ref containing AS numbers inteperted as an AS_PATH_SEQUENCE.

    SCALAR
        A string with AS numbers seperated by spaces (AS_PATH_SEQUANCE). AS_PATH_SETs is written using "{}" with "," to seperate AS numbers. AS_PATH_CONFED_* is writen equally, but encapsulated in "()".

    Net::BGP::ASPath
        Another ASPath object, in which case a clone is constructed.

    "undef"
        This will create the ASPath object with empty contents

    Following the PATHDATA, the OPTIONS may be specified. Currently the only valid option is c<as4>, which, if true, builds ASPath objects usable for talking to an peer that supports 32 bit ASNs. False, or the default value, assumes that the peer does not support 32 bit ASNs, which affects the decode routines. Note that the encode routines are not dependent upon this option.

    Basically, if as4 is true, AS_PATH is populated from messages assuming 4 byte ASNs and AS4_PATH is not used. Encoded AS_PATH attributes also assume a 4 byte ASN.

    If as4 is false, AS_PATH is populated from messages assuming 2 byte ASNs, and, if available, AS4_PATH is used to replace occurences of 23456 when possible when outputing to user-readable formats. Encoding routines will also allow output of AS4_PATH objects when appropriate.

OBJECT COPY

clone() - clone a Net::BGP::ASPath object
        $clone = $aspath->clone();

    This method creates an exact copy of the Net::BGP::ASPath object.

ACCESSOR METHODS

length()
    Return the path-length used in BGP path selection. This is the sum of the lengths of all AS_PATH elements. This does however not include AS_PATH_CONFED_* elements and AS_SEGMENTS count as one BGP hop.

as_string()
    Returns the path as a string in same notation as the constructor accept.

cleanup()
    Reduce the path by removing meaningless AS_PATH elements (empty sets or sequences) and joining neighbour elements of same _SET type.

strip()
    Strips AS_CONFED_* segments from the path.

striped()
    Returns a strip() 'ed clone() of the path.

prepend(ARRAY)
prepend(SCALAR)
    Strips AS_CONFED_* segments from the path and prepends one or more AS numbers to the path as given as arguments, either as an array of AS numbers or as a string with space seperated AS numbers. If string has "()" arround, prepend_confed will be used instead.

prepend_confed(ARRAY)
prepend_confed(SCALAR)
    Prepends one or more confederation AS numbers to the path as given as arguments, either as an array of AS numbers or as a string with space seperated AS numbers. "()" arround the string is ignored.

aggregate(ASPath)
aggregate(ARRAY)
    Aggregates the current ASPath with the ASPath(s) given as argument. If invoked as class method, aggregate all ASPaths given as argument.

    To aggregate means to find the longest common substring (of the paths of all objects that should be aggregated) and keep them, but replacing the non-common substrings with AS_SET segments. Currently only the longest common normal and confederation head will be found and the remaing will be left as an AS_SET and AS_CONFED_SET.

    Returns the aggregated object. The objects self are not modified.

SEE ALSO
RFC 1771, RFC 1997, Net::BGP, Net::BGP::Process, Net::BGP::Peer, Net::BGP::Notification, Net::BGP::NLRI, Net::BGP::Update

AUTHOR
Martin Lorensen <bgp@martin.lorensen.dk>