route_manager 0.2.11

Cross-platform route management interface
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::linux::{
    add_route_req, convert_add_route, delete_route_req, deserialize_res, list_route_req,
    RouteSocket,
};
use crate::AsyncRoute;
use crate::{Route, RouteChange};
use netlink_packet_route::AddressFamily;
use std::collections::VecDeque;
use std::io;
/// AsyncRouteListener for asynchronously receiving route change events.
pub struct AsyncRouteListener {
    list: VecDeque<RouteChange>,
    socket: AsyncRoute<RouteSocket>,
}
impl AsyncRouteListener {
    /// Creates a new AsyncRouteListener.
    pub fn new() -> io::Result<Self> {
        let mut route_socket = RouteSocket::new()?;
        route_socket.add_membership()?;
        let socket = AsyncRoute::new(route_socket)?;
        Ok(Self {
            list: Default::default(),
            socket,
        })
    }
    /// Asynchronously listens for a route change event and returns a RouteChange.
    pub async fn listen(&mut self) -> io::Result<RouteChange> {
        if let Some(route) = self.list.pop_front() {
            return Ok(route);
        }
        let mut buf = vec![0; 4096];
        loop {
            let len = self.socket.read_with(|s| s.recv(&mut buf[..])).await?;
            deserialize_res(
                |route| {
                    self.list.push_back(route);
                },
                &buf[..len],
            )?;
            if let Some(route) = self.list.pop_front() {
                return Ok(route);
            }
        }
    }
}
/// AsyncRouteManager for asynchronously managing routes (adding, deleting, and listing).
pub struct AsyncRouteManager {
    _private: std::marker::PhantomData<()>,
}
impl AsyncRouteManager {
    /// Creates a new AsyncRouteManager.
    pub fn new() -> io::Result<AsyncRouteManager> {
        Ok(AsyncRouteManager {
            _private: std::marker::PhantomData,
        })
    }
    /// Retrieves a new instance of AsyncRouteListener.
    pub fn listener() -> io::Result<AsyncRouteListener> {
        AsyncRouteListener::new()
    }

    /// Asynchronously lists routes for a specific address family.
    async fn list_family(
        socket: &mut AsyncRoute<RouteSocket>,
        family: AddressFamily,
    ) -> io::Result<Vec<RouteChange>> {
        let mut buf = vec![0; 4096];
        let mut list = Vec::new();
        let req = list_route_req(family);
        socket.write_with(|s| s.send(&req)).await?;
        loop {
            let len = socket.read_with(|s| s.recv(&mut buf)).await?;
            let rs = deserialize_res(
                |route| {
                    list.push(route);
                },
                &buf[..len],
            )?;
            if rs {
                break;
            }
        }
        Ok(list)
    }

    /// Asynchronously lists all current routes.
    pub async fn list(&mut self) -> io::Result<Vec<Route>> {
        let mut socket = AsyncRoute::new(RouteSocket::new()?)?;

        // Query IPv4 routes
        let v4_result = Self::list_family(&mut socket, AddressFamily::Inet).await;

        // Query IPv6 routes
        let v6_result = Self::list_family(&mut socket, AddressFamily::Inet6).await;

        // Only fail if both queries failed. If at least one succeeded, return partial results.
        let list = match (v4_result, v6_result) {
            (Ok(v4), Ok(v6)) => [v4, v6].concat(),
            (Ok(v4), Err(_)) => v4,            // IPv4 succeeded
            (Err(_), Ok(v6)) => v6,            // IPv6 succeeded
            (Err(e), Err(_)) => return Err(e), // Both failed, return first error
        };
        Ok(convert_add_route(list))
    }
    /// Asynchronously adds a new route.
    pub async fn add(&mut self, route: &Route) -> io::Result<()> {
        let req = add_route_req(route)?;
        let mut socket = AsyncRoute::new(RouteSocket::new()?)?;
        socket.write_with(|s| s.send(&req)).await?;
        let mut buf = vec![0; 4096];
        let len = socket.read_with(|s| s.recv(&mut buf)).await?;
        deserialize_res(|_| {}, &buf[..len]).map(|_| ())
    }
    /// Asynchronously deletes an existing route.
    pub async fn delete(&mut self, route: &Route) -> io::Result<()> {
        let req = delete_route_req(route)?;
        let mut socket = AsyncRoute::new(RouteSocket::new()?)?;
        socket.write_with(|s| s.send(&req)).await?;
        let mut buf = vec![0; 4096];
        let len = socket.read_with(|s| s.recv(&mut buf)).await?;
        deserialize_res(|_| {}, &buf[..len]).map(|_| ())
    }
}