bgp-rs 0.6.0

A library for parsing Border Gateway Protocol (BGP) formatted streams.
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

use byteorder::ReadBytesExt;

use std::io::{Cursor, Result};

// Attempt to detect whether the prefix has a path ID or not.
// Modelled heavily on the Wireshark code - https://github.com/wireshark/wireshark/blob/24e43bf542d65f5b802b65355caacfba2c7b00d0/epan/dissectors/packet-bgp.c#L2336
//
// This is used because whilst we *do* look at the OPEN messages, some BMP implementations
// don't send OPENs as part of the Peer Up messages. •`_´•  Looking at you XR 6.4.2
pub(crate) fn detect_add_path_prefix(cur: &mut Cursor<Vec<u8>>, max_bit_len: u32) -> Result<bool> {
    let cursor_init = cur.position();
    let cursor_end = cur.get_ref().len() as u64;

    let mut i = cur.position() + 4;
    while i < cursor_end {
        cur.set_position(i);
        let prefix_len = u32::from(cur.read_u8()?);

        if prefix_len > max_bit_len {
            cur.set_position(cursor_init);
            return Ok(false); // Not ADD PATH
        }

        let addr_len = (prefix_len + 7) / 8;
        // let addr_len = (f32::from(prefix_len) / 8.0).ceil() as u8;
        i += u64::from(1 + addr_len);

        if i > cursor_end {
            cur.set_position(cursor_init);
            return Ok(false);
        }

        if prefix_len % 8 > 0 {
            // detect bits set after the end of the prefix
            cur.set_position(i - 1);
            let v = cur.read_u8()?;
            if v & (0xFF >> (prefix_len % 8)) > 0 {
                cur.set_position(cursor_init);
                return Ok(false);
            }
        }

        i += 4;
    }

    cur.set_position(cursor_init);
    let mut j = cur.position();
    while j < cursor_end {
        cur.set_position(j);
        let prefix_len = u32::from(cur.read_u8()?);

        if prefix_len == 0 && (cursor_end - (j + 1)) > 0 {
            cur.set_position(cursor_init);
            return Ok(true);
        }

        if prefix_len > max_bit_len {
            cur.set_position(cursor_init);
            return Ok(true);
        }

        let addr_len = (prefix_len + 7) / 8;
        // let addr_len = (f32::from(prefix_len) / 8.0).ceil() as u8;
        j += u64::from(1 + addr_len);

        if j > cursor_end {
            cur.set_position(cursor_init);
            return Ok(true);
        }

        if prefix_len % 8 > 0 {
            // detect bits set after the end of the prefix
            cur.set_position(j - 1);
            let v = cur.read_u8()?;
            if v & (0xFF >> (prefix_len % 8)) > 0 {
                cur.set_position(cursor_init);
                return Ok(true);
            }
        }
    }

    cur.set_position(cursor_init);
    Ok(false)
}