routecore 0.7.1

A Library with Building Blocks for BGP Routing
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

use octseq::{Octets, Parser};

use crate::bgp::message::Header;
use crate::bgp::types::{Afi, AfiSafiType, RouteRefreshSubtype};
use crate::util::parser::ParseError;

/// BGP RouteRefresh message, variant of the [`Message`] enum.
#[derive(Clone, Debug)]
pub struct RouteRefreshMessage<Octets> {
    octets: Octets,
    afisafi: AfiSafiType,
    subtype: RouteRefreshSubtype,
}

impl<Octs: Octets> RouteRefreshMessage<Octs> {
    pub fn from_octets(octets: Octs) -> Result<Self, ParseError> {
        let mut parser = Parser::from_ref(&octets);
        {
            let header = Header::parse(&mut parser)?;
            if header.length() != 23 || parser.remaining() != 4 {
                return Err(ParseError::form_error(
                        "ROUTEREFRESH of invalid size"
                ));
            }
        }
        let afi = parser.parse_u16_be()?;
        let subtype = parser.parse_u8()?.into();
        let safi = parser.parse_u8()?;
        let afisafi = (afi, safi).into();

        Ok(RouteRefreshMessage { octets, afisafi, subtype })
    }

    pub fn octets(&self) -> &Octs {
            &self.octets
    }
}

impl<Octs> RouteRefreshMessage<Octs> {
    /// Returns the `Afi` for this Route Refresh message.
    pub fn afi(&self) -> Afi {
        self.afisafi.afi()
    }

    /// Returns the `AfiSafi` for this Route Refresh message.
    pub fn afisafi(&self) -> AfiSafiType {
        self.afisafi
    }

    /// Returns the `RouteRefreshSubtype` for this Route Refresh message.
    ///
    /// The subtype, as defined in RFC7313 (Enhanced Route Refresh
    /// Capability), is put in the 'reserved' byte as specified in the
    /// original RFC2918. That reserved byte should be set to 0 in the
    /// original, non-enhanced case, which translates to the
    /// RouteRefreshSubtype::Normal variant.
    /// This method does not distinguish between whether this message was
    /// received over a session with vs without Enhanced Route Refresh
    /// Capability.
    pub fn subtype(&self) -> RouteRefreshSubtype {
        self.subtype
    }
}

impl<Octs: Octets> AsRef<[u8]> for RouteRefreshMessage<Octs> {
    fn as_ref(&self) -> &[u8] {
        self.octets.as_ref()
    }
}


//------------ Tests ---------------------------------------------------------

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn from_octets() {

        let raw = vec![
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
            0x00, 0x17, 0x05, 0x00, 0x01, 0x01, 0x01
        ];

        let rr = RouteRefreshMessage::from_octets(&raw).unwrap();
        assert_eq!(rr.afisafi(), AfiSafiType::Ipv4Unicast);
        assert_eq!(rr.subtype(), RouteRefreshSubtype::Begin);

    }
}