geiserx_ts_netstack_smoltcp_socket 0.6.7

userspace netstack built on smoltcp (socket wrappers)
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
124
125
126
127
128
129

use core::{
    fmt::{Debug, Formatter},
    num::NonZeroUsize,
};

use bytes::Bytes;
use netcore::{
    DisplayExt, HasChannel, Response, raw,
    smoltcp::{
        iface::SocketHandle,
        wire::{IpProtocol, IpVersion},
    },
};

/// A raw IP socket.
///
/// This socket type intercepts all traffic for its protocol number, even if there are
/// protocol-specific sockets connected or listening.
pub struct RawSocket {
    handle: SocketHandle,
    ip_protocol: IpProtocol,
    ip_version: IpVersion,
    sender: netcore::Channel,
}

impl Debug for RawSocket {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("UdpSocket")
            .field("handle", &self.handle.as_display_debug())
            .field("version", &self.ip_version)
            .field("proto", &self.ip_protocol)
            .finish()
    }
}

impl RawSocket {
    pub(crate) fn new(
        sender: netcore::Channel,
        handle: SocketHandle,
        ip_protocol: IpProtocol,
        ip_version: IpVersion,
    ) -> Self {
        Self {
            handle,
            ip_protocol,
            ip_version,
            sender,
        }
    }

    /// Send the raw packet contained in `buf` over the network.
    pub fn send_blocking(&self, buf: &[u8]) -> Result<(), netcore::Error> {
        self.request_blocking(raw::Command::Send {
            buf: Bytes::copy_from_slice(buf),
        })?
        .to_ok()
    }

    /// Send the raw packet contained in `buf` over the network.
    pub async fn send(&self, buf: &[u8]) -> Result<(), netcore::Error> {
        self.request(raw::Command::Send {
            buf: Bytes::copy_from_slice(buf),
        })
        .await?
        .to_ok()
    }

    /// Receive a raw packet into `buf` from the network.
    pub fn recv_blocking(&self, buf: &mut [u8]) -> Result<usize, netcore::Error> {
        let len = NonZeroUsize::new(buf.len()).ok_or(netcore::Error::zero_buffer())?;
        let resp = self.request_blocking(raw::Command::Recv { max_len: Some(len) })?;

        self._recv(buf, resp)
    }

    /// Receive a raw packet into `buf` from the network.
    pub async fn recv(&self, buf: &mut [u8]) -> Result<usize, netcore::Error> {
        let len = NonZeroUsize::new(buf.len()).ok_or(netcore::Error::zero_buffer())?;
        let resp = self
            .request(raw::Command::Recv { max_len: Some(len) })
            .await?;

        self._recv(buf, resp)
    }

    /// Receive a raw packet into `buf` from the network.
    pub fn recv_bytes_blocking(&self) -> Result<Bytes, netcore::Error> {
        let resp = self.request_blocking(raw::Command::Recv { max_len: None })?;
        self._recv_bytes(resp)
    }

    /// Receive a raw packet into `buf` from the network.
    pub async fn recv_bytes(&self) -> Result<Bytes, netcore::Error> {
        let resp = self.request(raw::Command::Recv { max_len: None }).await?;
        self._recv_bytes(resp)
    }

    fn _recv(&self, buf: &mut [u8], resp: Response) -> Result<usize, netcore::Error> {
        let ret_buf = self._recv_bytes(resp)?;

        let len = buf.len().min(ret_buf.len());
        buf[..len].copy_from_slice(&ret_buf[..len]);

        Ok(len)
    }

    fn _recv_bytes(&self, resp: Response) -> Result<Bytes, netcore::Error> {
        netcore::try_response_as!(resp, raw::Response::Recv { buf, truncated });

        if let Some(truncated) = truncated {
            tracing::warn!(truncated, "packet was truncated");
        }

        Ok(buf)
    }

    socket_requestor_impl!();
}

impl Drop for RawSocket {
    fn drop(&mut self) {
        if let Err(e) = self
            .sender
            .request_nonblocking(Some(self.handle), raw::Command::Close)
        {
            tracing::warn!(err = %e, "possible socket leak");
        }
    }
}