rs-matter-stack 0.2.0

Utility for configuring and running rs-matter
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

//! UDP transport implementation for edge-nal

use core::fmt::Debug;
use core::net::{IpAddr, Ipv4Addr};

use edge_nal::{MulticastV4, MulticastV6, Readable, UdpReceive, UdpSend};

use rs_matter::error::{Error, ErrorCode};
use rs_matter::transport::network::{Address, NetworkMulticast, NetworkReceive, NetworkSend};

/// UDP transport implementation for edge-nal
pub struct Udp<T>(pub T);

impl<T> NetworkSend for Udp<T>
where
    T: UdpSend,
{
    async fn send_to(&mut self, data: &[u8], addr: Address) -> Result<(), Error> {
        if let Address::Udp(remote) = addr {
            self.0.send(remote, data).await.map_err(map_err)?;

            Ok(())
        } else {
            Err(ErrorCode::NoNetworkInterface.into())
        }
    }
}

impl<T> NetworkReceive for Udp<T>
where
    T: UdpReceive + Readable,
{
    async fn wait_available(&mut self) -> Result<(), Error> {
        self.0.readable().await.map_err(map_err)?;

        Ok(())
    }

    async fn recv_from(&mut self, buffer: &mut [u8]) -> Result<(usize, Address), Error> {
        let (size, addr) = self.0.receive(buffer).await.map_err(map_err)?;

        Ok((size, Address::Udp(addr)))
    }
}

pub struct Multicast<M4, M6> {
    m4: M4,
    m4_network: Ipv4Addr,
    m6: M6,
    m6_interface: u32,
}

impl<M4, M6> Multicast<M4, M6>
where
    M4: MulticastV4,
    M6: MulticastV6,
{
    pub const fn new(m4: M4, m4_network: Ipv4Addr, m6: M6, m6_interface: u32) -> Self {
        Self {
            m4,
            m4_network,
            m6,
            m6_interface,
        }
    }
}

impl<M4, M6> NetworkMulticast for Udp<Multicast<M4, M6>>
where
    M4: MulticastV4,
    M6: MulticastV6,
{
    async fn join(&mut self, addr: IpAddr) -> Result<(), Error> {
        match addr {
            IpAddr::V4(remote) => self
                .0
                .m4
                .join_v4(remote, self.0.m4_network)
                .await
                .map_err(map_err),
            IpAddr::V6(remote) => self
                .0
                .m6
                .join_v6(remote, self.0.m6_interface)
                .await
                .map_err(map_err),
        }
    }

    async fn leave(&mut self, addr: IpAddr) -> Result<(), Error> {
        match addr {
            IpAddr::V4(remote) => self
                .0
                .m4
                .leave_v4(remote, self.0.m4_network)
                .await
                .map_err(map_err),
            IpAddr::V6(remote) => self
                .0
                .m6
                .leave_v6(remote, self.0.m6_interface)
                .await
                .map_err(map_err),
        }
    }
}

fn map_err<E: Debug>(e: E) -> Error {
    warn!("Network error: {:?}", debug2format!(e));
    ErrorCode::StdIoError.into() // TODO
}