ts_netstack_smoltcp_core 0.3.3

command-channel-based userspace netstack built on smoltcp (core functionality)
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

//! Commands for UDP sockets.

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

use bytes::Bytes;
use smoltcp::iface::SocketHandle;

use crate::command;

/// Commands driving UDP sockets.
pub enum Command {
    /// Bind a new socket to the given endpoint.
    Bind {
        /// The endpoint to bind to.
        ///
        /// The port on this endpoint may not be unspecified.
        endpoint: SocketAddr,
    },

    /// Send a message to the given endpoint.
    Send {
        /// The endpoint to send the message to.
        endpoint: SocketAddr,
        /// The message payload.
        buf: Bytes,
    },

    /// Receive a packet incoming on the socket.
    Recv {
        /// If `Some`, limit the length of the received packet to at most the contained
        /// value.
        ///
        /// If the actual received length of the packet was longer, this may lead to
        /// payload truncation, indicated by the presence of the
        /// [`Response::RecvFrom::truncated`] field.
        ///
        /// For use in emulating an API like `recv_from(&mut [u8])`, where the caller
        /// supplies the buffer.
        max_len: Option<NonZeroUsize>,
    },

    /// Close the socket.
    Close,
}

impl Debug for Command {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Bind { endpoint } => f.debug_struct("Bind").field("endpoint", endpoint).finish(),
            Self::Send { endpoint, buf } => f
                .debug_struct("Send")
                .field("endpoint", endpoint)
                .field("buf_len", &buf.len())
                .finish(),
            Self::Recv { max_len } => f.debug_struct("Recv").field("max_len", max_len).finish(),
            Self::Close => f.debug_struct("Close").finish(),
        }
    }
}

impl From<Command> for command::Command {
    fn from(value: Command) -> Self {
        command::Command::Udp(value)
    }
}

/// UDP response messages.
pub enum Response {
    /// Socket was bound successfully.
    Bound {
        /// The bound socket's handle.
        handle: SocketHandle,
        /// The local endpoint to which the socket was bound.
        local: SocketAddr,
    },
    /// A packet was received.
    RecvFrom {
        /// The remote address that sent the packet.
        remote: SocketAddr,

        /// The packet payload.
        buf: Bytes,

        /// If present, indicates that the packet held more data than is in the `buf` field,
        /// which was truncated because [`Command::Recv::max_len`] was set.
        ///
        /// The contained value is the original length of the packet before truncation.
        truncated: Option<usize>,
    },
}

impl From<Response> for command::Response {
    fn from(value: Response) -> Self {
        Self::Udp(value)
    }
}

impl Debug for Response {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Bound { handle, local } => f
                .debug_struct("Bound")
                .field("handle", handle)
                .field("local", local)
                .finish(),
            Self::RecvFrom {
                remote,
                buf,
                truncated,
            } => f
                .debug_struct("RecvFrom")
                .field("remote", remote)
                .field("buf_len", &buf.len())
                .field("truncated", truncated)
                .finish(),
        }
    }
}