bgpdump 0.0.0

A library for parsing MRT formatted data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use byteorder::{BigEndian, ReadBytesExt};
use std::io::{Error, Read};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

use crate::Header;
use crate::AFI;

/// The OSPFv2 struct represents the data contained in an MRT record type of OSPFv2.
#[derive(Debug)]
pub struct OSPFv2 {
    /// The IPv4 address from which this message was received.
    pub remote: Ipv4Addr,

    /// The IPv4 address of the interface on which this message was received.
    pub local: Ipv4Addr,

    /// The binary OSPFv2 message.
    pub message: Vec<u8>,
}

impl OSPFv2 {
    ///
    /// # Summary
    /// Used to parse OSPFv2 MRT records.
    ///
    /// # Panics
    /// This function does not panic.
    ///
    /// # Errors
    /// Any IO error will be returned while reading from the stream.
    /// If an ill-formatted stream or header is provided behavior will be undefined.
    ///
    /// # Safety
    /// This function does not make use of unsafe code.
    ///
    pub fn parse(header: &Header, stream: &mut Read) -> Result<OSPFv2, Error> {
        // The fixed size of the header consisting of two IPv4 addresses.
        let length = (header.length - 2 * AFI::IPV4.size()) as usize;
        let mut record = OSPFv2 {
            remote: Ipv4Addr::from(stream.read_u32::<BigEndian>()?),
            local: Ipv4Addr::from(stream.read_u32::<BigEndian>()?),
            message: vec![0; length as usize],
        };

        // Fill the entire buffer.
        stream.read_exact(&mut record.message)?;
        Ok(record)
    }
}

/// The OSPFv3 struct represents the data contained in an MRT record type of OSPFv3 and OSPFv3_ET.
#[derive(Debug)]
pub struct OSPFv3 {
    /// The IP address of the router from which this message was received.
    pub remote: IpAddr,

    /// The IP address of the interface at which this message was received.
    pub local: IpAddr,

    /// The message that has been received.
    pub message: Vec<u8>,
}

impl OSPFv3 {
    ///
    /// # Summary
    /// Used to parse OSPFv3 MRT records.
    ///
    /// # Panics
    /// This function does not panic.
    ///
    /// # Errors
    /// Any IO error will be returned while reading from the stream.
    /// If an ill-formatted stream or header is provided behavior will be undefined.
    ///
    /// # Safety
    /// This function does not make use of unsafe code.
    ///
    pub fn parse(header: &Header, stream: &mut Read) -> Result<OSPFv3, Error> {
        let mut record = match AFI::from(stream.read_u16::<BigEndian>()?)? {
            AFI::IPV4 => {
                let length = (header.length - 2 * AFI::IPV4.size()) as usize;
                OSPFv3 {
                    remote: IpAddr::V4(Ipv4Addr::from(stream.read_u32::<BigEndian>()?)),
                    local: IpAddr::V4(Ipv4Addr::from(stream.read_u32::<BigEndian>()?)),
                    message: vec![0; length as usize],
                }
            }
            AFI::IPV6 => {
                let length: usize = (header.length - 2 * AFI::IPV6.size()) as usize;
                OSPFv3 {
                    remote: IpAddr::V6(Ipv6Addr::from(stream.read_u128::<BigEndian>()?)),
                    local: IpAddr::V6(Ipv6Addr::from(stream.read_u128::<BigEndian>()?)),
                    message: vec![0; length as usize],
                }
            }
        };

        // Fill the entire buffer.
        stream.read_exact(&mut record.message)?;
        Ok(record)
    }
}