dust-devil-core 1.1.0

Shared sources used in the dust-devil socks5 server and monitoring clients.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{io::Error, net::SocketAddr};

use tokio::io::{AsyncRead, AsyncWrite};

use crate::serialize::{ByteRead, ByteWrite};

use super::{RemoveSocketResponse, SandstormCommandType};

/// A Sandstorm list-socks5-sockets request.
pub struct ListSocks5SocketsRequest;

/// A Sandstorm list-socks5-sockets response.
pub struct ListSocks5SocketsResponse(
    /// The list of sockets listening for incoming socks5 connections sent by the server.
    pub Vec<SocketAddr>,
);

/// A borrowed version of [`ListSocks5SocketsResponse`].
pub struct ListSocks5SocketsResponseRef<'a>(
    /// The list of sockets listening for incoming socks5 connections sent by the server.
    &'a [SocketAddr],
);

impl ListSocks5SocketsResponse {
    pub fn as_ref(&self) -> ListSocks5SocketsResponseRef {
        ListSocks5SocketsResponseRef(&self.0)
    }
}

impl ByteRead for ListSocks5SocketsRequest {
    async fn read<R: AsyncRead + Unpin + ?Sized>(_reader: &mut R) -> Result<Self, Error> {
        Ok(Self)
    }
}

impl ByteWrite for ListSocks5SocketsRequest {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        SandstormCommandType::ListSocks5Sockets.write(writer).await
    }
}

impl ByteRead for ListSocks5SocketsResponse {
    async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
        Ok(Self(<Vec<SocketAddr> as ByteRead>::read(reader).await?))
    }
}

impl ByteWrite for ListSocks5SocketsResponse {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        self.as_ref().write(writer).await
    }
}

impl<'a> ByteWrite for ListSocks5SocketsResponseRef<'a> {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        (SandstormCommandType::ListSocks5Sockets, self.0).write(writer).await
    }
}

/// A Sandstorm add-socks5-socket request.
pub struct AddSocks5SocketRequest(
    /// The address of the new socket to open.
    pub SocketAddr,
);

/// A Sandstorm add-socks5-socket response.
pub struct AddSocks5SocketResponse(
    /// The result of the add socket operation.
    pub Result<(), Error>,
);

/// A borrowed version of [`AddSocks5SocketResponse`].
pub struct AddSocks5SocketResponseRef<'a>(
    /// The result of the add socket operation.
    pub Result<(), &'a Error>,
);

impl AddSocks5SocketResponse {
    pub fn as_ref(&self) -> AddSocks5SocketResponseRef {
        AddSocks5SocketResponseRef(self.0.as_ref().map(|_| ()))
    }
}

impl ByteRead for AddSocks5SocketRequest {
    async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
        Ok(Self(SocketAddr::read(reader).await?))
    }
}

impl ByteWrite for AddSocks5SocketRequest {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        (SandstormCommandType::AddSocks5Socket, &self.0).write(writer).await
    }
}

impl ByteRead for AddSocks5SocketResponse {
    async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
        Ok(Self(<Result<(), Error> as ByteRead>::read(reader).await?))
    }
}

impl ByteWrite for AddSocks5SocketResponse {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        self.as_ref().write(writer).await
    }
}

impl<'a> ByteWrite for AddSocks5SocketResponseRef<'a> {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        (SandstormCommandType::AddSocks5Socket, self.0).write(writer).await
    }
}

/// A Sandstorm remove-socks5-socket request.
pub struct RemoveSocks5SocketRequest(
    /// The address of the socket to remove.
    pub SocketAddr,
);

/// A Sandstorm remove-socks5-socket response.
pub struct RemoveSocks5SocketResponse(
    /// The status of the remove socket operation.
    pub RemoveSocketResponse,
);

impl ByteRead for RemoveSocks5SocketRequest {
    async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
        Ok(Self(SocketAddr::read(reader).await?))
    }
}

impl ByteWrite for RemoveSocks5SocketRequest {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        (SandstormCommandType::RemoveSocks5Socket, &self.0).write(writer).await
    }
}

impl ByteRead for RemoveSocks5SocketResponse {
    async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
        Ok(Self(RemoveSocketResponse::read(reader).await?))
    }
}

impl ByteWrite for RemoveSocks5SocketResponse {
    async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
        (SandstormCommandType::RemoveSocks5Socket, &self.0).write(writer).await
    }
}