Crate bgp_rs

The bgp-rs crate provides functionality to parse BGP-formatted streams.

Examples

Reading a MRT file containing BPG4MP messages

use std::fs::File;
use std::io::Cursor;
use std::io::Read;
use std::io::BufReader;
use libflate::gzip::Decoder;
use bgp_rs::{Identifier, PathAttribute};
use mrt_rs::Record;
use mrt_rs::bgp4mp::BGP4MP;

// Download an update message.
let file = File::open("res/mrt/updates.20190101.0000.gz").unwrap();

// Decode the GZIP stream.
let mut decoder = Decoder::new(BufReader::new(file)).unwrap();

// Keep reading MRT (Header, Record) tuples till the end of the file has been reached.
while let Ok(Some((_, record))) = mrt_rs::read(&mut decoder) {

    // Extract BGP4MP::MESSAGE_AS4 entries.
    if let Record::BGP4MP(BGP4MP::MESSAGE_AS4(x)) = record {

        // Read each BGP (Header, Message)
        let cursor = Cursor::new(x.message);
        let mut reader = bgp_rs::Reader::new(cursor);
        let (_, message) = reader.read().unwrap();

        // If this is an UPDATE message that contains announcements, extract its origin.
        if let bgp_rs::Message::Update(x) = message {
            if x.is_announcement() {
                if let PathAttribute::AS_PATH(path) = x.get(Identifier::AS_PATH).unwrap()
                {
                    // Test the path.origin() method.
                    let origin = path.origin();

                    // Do other stuff ...
                }
            }
        }
    }
}

Reading a MRT file containing TABLE_DUMP_V2 messages

use std::fs::File;
use std::io::Cursor;
use std::io::Read;
use std::io::BufReader;
use libflate::gzip::Decoder;
use bgp_rs::{Identifier, PathAttribute, Capabilities};
use mrt_rs::records::tabledump::TABLE_DUMP_V2;
use mrt_rs::Record;
use mrt_rs::bgp4mp::BGP4MP;

// Download an update message.
let file = File::open("res/mrt/bview.20100101.0759.gz").unwrap();

// Decode the GZIP stream.
let mut decoder = Decoder::new(BufReader::new(file)).unwrap();

// Keep reading MRT (Header, Record) tuples till the end of the file has been reached.
while let Ok(Some((_, record))) = mrt_rs::read(&mut decoder) {

    // Extract TABLE_DUMP_V2::RIB_IPV4_UNICAST entries.
    if let Record::TABLE_DUMP_V2(TABLE_DUMP_V2::RIB_IPV4_UNICAST(x)) = record {

        // Loop over each route for this particular prefix.
        for mut entry in x.entries {
            let length = entry.attributes.len() as u64;
            let mut cursor = Cursor::new(entry.attributes);

            // Parse each PathAttribute in each route.
            while cursor.position() < length {
                PathAttribute::parse(&mut cursor, &Default::default()).unwrap();
            }
        }
    }
}

Re-exports

pub use crate::open::*;

pub use crate::notification::*;

pub use crate::update::*;

Modules

notification	Contains the NOTIFICATION Message implementation
open	Contains the OPEN Message implementation The open mod provides structs and implementation for OPEN messages
update	Contains the UPDATE Message implementation

Structs

Header	Represents the BGP header accompanying every BGP message.
Reader	The BGPReader can read BGP messages from a BGP-formatted stream.
RouteRefresh	Represents a BGP Route Refresh message.

Enums

AFI	Represents an Address Family Identifier. Currently only IPv4 and IPv6 are supported. Currently only IPv4, IPv6, and L2VPN are supported.
Message	Represents a single BGP message.
SAFI	Represents an Subsequent Address Family Identifier. Currently only Unicast and Multicast are supported.

Traits

CapabilitiesRef

An abstract way of getting a reference to a Capabilities struct. This is used in Reader to allow use of either an owned Capabilites or a reference to one.