1use std::{
6 fmt,
7 io::{Error, ErrorKind},
8 net::SocketAddr,
9};
10
11use tokio::io::{AsyncRead, AsyncWrite};
12
13use crate::{
14 serialize::{ByteRead, ByteWrite, SmallReadString, SmallWriteString},
15 socks5::{AuthMethod, SocksRequest, SocksRequestAddress},
16 users::{UserRole, UsersLoadingError},
17};
18
19pub struct Event {
21 pub timestamp: i64,
22 pub data: EventData,
23}
24
25impl Event {
26 pub fn new(timestamp: i64, data: EventData) -> Self {
27 Event { timestamp, data }
28 }
29}
30
31pub enum EventData {
33 NewSocks5Socket(SocketAddr),
34 FailedBindSocks5Socket(SocketAddr, Error),
35 FailedBindAnySocketAborting,
36 RemovedSocks5Socket(SocketAddr),
37 NewSandstormSocket(SocketAddr),
38 FailedBindSandstormSocket(SocketAddr, Error),
39 RemovedSandstormSocket(SocketAddr),
40 LoadingUsersFromFile(String),
41 UsersLoadedFromFile(String, Result<u64, UsersLoadingError>),
42 StartingUpWithSingleDefaultUser(String),
43 SavingUsersToFile(String),
44 UsersSavedToFile(String, Result<u64, Error>),
45 UserRegisteredByArgs(String, UserRole),
46 UserReplacedByArgs(String, UserRole),
47 NewClientConnectionAccepted(u64, SocketAddr),
48 ClientConnectionAcceptFailed(Option<SocketAddr>, Error),
49 ClientRequestedUnsupportedVersion(u64, u8),
50 ClientRequestedUnsupportedCommand(u64, u8),
51 ClientRequestedUnsupportedAtyp(u64, u8),
52 ClientSelectedAuthMethod(u64, AuthMethod),
53 ClientNoAcceptableAuthMethod(u64),
54 ClientRequestedUnsupportedUserpassVersion(u64, u8),
55 ClientAuthenticatedWithUserpass(u64, String, bool),
56 ClientSocksRequest(u64, SocksRequest),
57 ClientDnsLookup(u64, String),
58 ClientAttemptingConnect(u64, SocketAddr),
59 ClientConnectionAttemptBindFailed(u64, Error),
60 ClientConnectionAttemptConnectFailed(u64, Error),
61 ClientFailedToConnectToDestination(u64),
62 ClientConnectedToDestination(u64, SocketAddr),
63 ClientBytesSent(u64, u64),
64 ClientBytesReceived(u64, u64),
65 ClientSourceShutdown(u64),
66 ClientDestinationShutdown(u64),
67 ClientConnectionFinished(u64, u64, u64, Result<(), Error>),
68 NewSandstormConnectionAccepted(u64, SocketAddr),
69 SandstormConnectionAcceptFailed(Option<SocketAddr>, Error),
70 SandstormRequestedUnsupportedVersion(u64, u8),
71 SandstormAuthenticatedAs(u64, String, bool),
72 NewSocksSocketRequestedByManager(u64, SocketAddr),
73 RemoveSocksSocketRequestedByManager(u64, SocketAddr),
74 NewSandstormSocketRequestedByManager(u64, SocketAddr),
75 RemoveSandstormSocketRequestedByManager(u64, SocketAddr),
76 UserRegisteredByManager(u64, String, UserRole),
77 UserUpdatedByManager(u64, String, UserRole, bool),
78 UserDeletedByManager(u64, String, UserRole),
79 AuthMethodToggledByManager(u64, AuthMethod, bool),
80 BufferSizeChangedByManager(u64, u32),
81 SandstormRequestedShutdown(u64),
82 SandstormConnectionFinished(u64, Result<(), Error>),
83 ShutdownSignalReceived,
84}
85
86impl fmt::Display for EventData {
87 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
88 match self {
89 Self::NewSocks5Socket(socket_address) => write!(f, "Listening for socks5 client connections at {socket_address}"),
90 Self::FailedBindSocks5Socket(socket_address, io_error) => write!(f, "Failed to set up socks5 socket at {socket_address}: {io_error}"),
91 Self::FailedBindAnySocketAborting => write!(f, "Failed to bind any socks5 socket! Aborting"),
92 Self::RemovedSocks5Socket(socket_address) => write!(f, "Will no longer listen for socks5 client connections at {socket_address}"),
93 Self::NewSandstormSocket(socket_address) => write!(f, "Listening for Sandstorm connections at {socket_address}"),
94 Self::FailedBindSandstormSocket(socket_address, io_error) => write!(f, "Failed to set up Sandstorm socket at {socket_address}: {io_error}"),
95 Self::RemovedSandstormSocket(socket_address) => write!(f, "Will no longer listen for Sandstorm connections at {socket_address}"),
96 Self::LoadingUsersFromFile(filename) => write!(f, "Loading users from file {filename}"),
97 Self::UsersLoadedFromFile(filename, Ok(user_count)) => write!(f, "Loaded {user_count} users from file {filename}"),
98 Self::UsersLoadedFromFile(filename, Err(load_users_error)) => write!(f, "Error while loading users from file {filename}: {load_users_error}"),
99 Self::StartingUpWithSingleDefaultUser(userpass) => write!(f, "Starting up with single default user {userpass}"),
100 Self::SavingUsersToFile(filename) => write!(f, "Saving users to file {filename}"),
101 Self::UsersSavedToFile(filename, Ok(amount)) => write!(f, "Successfully saved {amount} users to file {filename}"),
102 Self::UsersSavedToFile(filename, Err(io_error)) => write!(f, "Failed to save users to file {filename}: {io_error}"),
103 Self::UserRegisteredByArgs(username, role) => write!(f, "Registered new {role} user {username} specified via argument"),
104 Self::UserReplacedByArgs(username, role) => write!(f, "Replaced user loaded from file {username} with new {role} user specified via argument"),
105 Self::NewClientConnectionAccepted(client_id, socket_address) => write!(f, "New client connection from {socket_address} assigned ID {client_id}"),
106 Self::ClientConnectionAcceptFailed(Some(socket_address), io_error) => write!(f, "Failed to accept incoming socks connection from socket {socket_address}: {io_error}"),
107 Self::ClientConnectionAcceptFailed(None, io_error) => write!(f, "Failed to accept incoming socks connection from unknown socket: {io_error}"),
108 Self::ClientRequestedUnsupportedVersion(client_id, version) => write!(f, "Client {client_id} requested unsupported socks version: {version}"),
109 Self::ClientRequestedUnsupportedCommand(client_id, command) => write!(f, "Client {client_id} requested unsupported socks command: {command}"),
110 Self::ClientRequestedUnsupportedAtyp(client_id, atyp) => write!(f, "Client {client_id} requested unsupported socks ATYP: {atyp}"),
111 Self::ClientSelectedAuthMethod(client_id, auth_method) => write!(f, "Client {client_id} will use auth method {auth_method}"),
112 Self::ClientNoAcceptableAuthMethod(client_id) => write!(f, "Client {client_id} no acceptable authentication method found"),
113 Self::ClientRequestedUnsupportedUserpassVersion(client_id, version) => write!(f, "Client {client_id} requested unsupported userpass version: {version}"),
114 Self::ClientAuthenticatedWithUserpass(client_id, username, true) => write!(f, "Client {client_id} successfully authenticated as {username}"),
115 Self::ClientAuthenticatedWithUserpass(client_id, username, false) => write!(f, "Client {client_id} unsuccessfully authenticated as {username}"),
116 Self::ClientSocksRequest(client_id, request) => {
117 write!(f, "Client {client_id} requested to connect to ")?;
118 match &request.destination {
119 SocksRequestAddress::IPv4(ipv4) => write!(f, "IPv4 {ipv4}:{}", request.port),
120 SocksRequestAddress::IPv6(ipv6) => write!(f, "IPv6 [{ipv6}]:{}", request.port),
121 SocksRequestAddress::Domainname(domainname) => write!(f, "domainname {domainname}:{}", request.port),
122 }
123 },
124 Self::ClientDnsLookup(client_id, domainname) => write!(f, "Client {client_id} performing DNS lookup for {domainname}"),
125 Self::ClientAttemptingConnect(client_id, socket_address) => write!(f, "Client {client_id} attempting to connect to destination at {socket_address}"),
126 Self::ClientConnectionAttemptBindFailed(client_id, io_error) => write!(f, "Client {client_id} failed to bind local socket: {io_error}"),
127 Self::ClientConnectionAttemptConnectFailed(client_id, io_error) => write!(f, "Client {client_id} failed to connect to destination: {io_error}"),
128 Self::ClientFailedToConnectToDestination(client_id) => write!(f, "Client {client_id} failed to connect to destination, sending error response"),
129 Self::ClientConnectedToDestination(client_id, socket_address) => write!(f, "Client {client_id} successfully established connection to destination at {socket_address}"),
130 Self::ClientBytesSent(client_id, count) => write!(f, "Client {client_id} sent {count} bytes"),
131 Self::ClientBytesReceived(client_id, count) => write!(f, "Client {client_id} received {count} bytes"),
132 Self::ClientSourceShutdown(client_id) => write!(f, "Client {client_id} source socket shutdown"),
133 Self::ClientDestinationShutdown(client_id) => write!(f, "Client {client_id} destination socket shutdown"),
134 Self::ClientConnectionFinished(client_id, total_bytes_sent, total_bytes_received,Ok(())) => write!(f, "Client {client_id} finished after {total_bytes_sent} bytes sent and {total_bytes_received} bytes received"),
135 Self::ClientConnectionFinished(client_id, total_bytes_sent, total_bytes_received, Err(io_error)) => write!(f, "Client {client_id} closed with IO error after {total_bytes_sent} bytes sent and {total_bytes_received} bytes received: {io_error}"),
136 Self::NewSandstormConnectionAccepted(manager_id, socket_address) => write!(f, "New management connection from {socket_address} assigned ID {manager_id}"),
137 Self::SandstormConnectionAcceptFailed(Some(socket_address), io_error) => write!(f, "Failed to accept incoming management connection from socket {socket_address}: {io_error}"),
138 Self::SandstormConnectionAcceptFailed(None, io_error) => write!(f, "Failed to accept incoming management connection from unknown socket: {io_error}"),
139 Self::SandstormRequestedUnsupportedVersion(manager_id, version) => write!(f, "Manager {manager_id} requested unsupported sandstorm version: {version}"),
140 Self::SandstormAuthenticatedAs(manager_id, username, true) => write!(f, "Manager {manager_id} successfully authenticated as {username}"),
141 Self::SandstormAuthenticatedAs(manager_id, username, false) => write!(f, "Manager {manager_id} unsuccessfully authenticated as {username}"),
142 Self::NewSocksSocketRequestedByManager(manager_id, socket_address) => write!(f, "Manager {manager_id} requested opening a new socks5 socket at {socket_address}"),
143 Self::RemoveSocksSocketRequestedByManager(manager_id, socket_address) => write!(f, "Manager {manager_id} requested closing socks5 socket at {socket_address}"),
144 Self::NewSandstormSocketRequestedByManager(manager_id, socket_address) => write!(f, "Manager {manager_id} requested opening a new sandstorm socket at {socket_address}"),
145 Self::RemoveSandstormSocketRequestedByManager(manager_id, socket_address) => write!(f, "Manager {manager_id} requested closing sandstorm socket at {socket_address}"),
146 Self::UserRegisteredByManager(manager_id, username, role) => write!(f, "Manager {manager_id} registered new {role} user {username}"),
147 Self::UserUpdatedByManager(manager_id, username, role, false) => write!(f, "Manager {manager_id} updated role of user {username} to {role}"),
148 Self::UserUpdatedByManager(manager_id, username, role, true) => write!(f, "Manager {manager_id} updated user {username} with role {role} and new password"),
149 Self::UserDeletedByManager(manager_id, username, role) => write!(f, "Manager {manager_id} deleted {role} user {username}"),
150 Self::AuthMethodToggledByManager(manager_id, auth_method, false) => write!(f, "Manager {manager_id} disabled authentication method {auth_method}"),
151 Self::AuthMethodToggledByManager(manager_id, auth_method, true) => write!(f, "Manager {manager_id} enabled authentication method {auth_method}"),
152 Self::BufferSizeChangedByManager(manager_id, buffer_size) => write!(f, "Manager {manager_id} set client buffer size to {buffer_size}"),
153 Self::SandstormRequestedShutdown(manager_id) => write!(f, "Manager {manager_id} requested the server shuts down"),
154 Self::SandstormConnectionFinished(manager_id, Ok(())) => write!(f, "Manager {manager_id} finished"),
155 Self::SandstormConnectionFinished(manager_id, Err(io_error)) => write!(f, "Manager {manager_id} closed with IO error: {io_error}"),
156 Self::ShutdownSignalReceived => write!(f, "Shutdown signal received"),
157 }
158 }
159}
160
161impl ByteRead for EventData {
162 async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
163 let t = u8::read(reader).await?;
164
165 match t {
166 0x01 => Ok(Self::NewSocks5Socket(SocketAddr::read(reader).await?)),
167 0x02 => Ok(Self::FailedBindSocks5Socket(
168 SocketAddr::read(reader).await?,
169 Error::read(reader).await?,
170 )),
171 0x03 => Ok(Self::FailedBindAnySocketAborting),
172 0x04 => Ok(Self::RemovedSocks5Socket(SocketAddr::read(reader).await?)),
173 0x05 => Ok(Self::NewSandstormSocket(SocketAddr::read(reader).await?)),
174 0x06 => Ok(Self::FailedBindSandstormSocket(
175 SocketAddr::read(reader).await?,
176 Error::read(reader).await?,
177 )),
178 0x07 => Ok(Self::RemovedSandstormSocket(SocketAddr::read(reader).await?)),
179 0x08 => Ok(Self::LoadingUsersFromFile(String::read(reader).await?)),
180 0x09 => Ok(Self::UsersLoadedFromFile(
181 String::read(reader).await?,
182 <Result<u64, UsersLoadingError> as ByteRead>::read(reader).await?,
183 )),
184 0x0A => Ok(Self::StartingUpWithSingleDefaultUser(String::read(reader).await?)),
185 0x0B => Ok(Self::SavingUsersToFile(String::read(reader).await?)),
186 0x0C => Ok(Self::UsersSavedToFile(
187 String::read(reader).await?,
188 <Result<u64, Error> as ByteRead>::read(reader).await?,
189 )),
190 0x0D => Ok(Self::UserRegisteredByArgs(
191 SmallReadString::read(reader).await?.0,
192 UserRole::read(reader).await?,
193 )),
194 0x0E => Ok(Self::UserReplacedByArgs(
195 SmallReadString::read(reader).await?.0,
196 UserRole::read(reader).await?,
197 )),
198 0x0F => Ok(Self::NewClientConnectionAccepted(
199 u64::read(reader).await?,
200 SocketAddr::read(reader).await?,
201 )),
202 0x10 => Ok(Self::ClientConnectionAcceptFailed(
203 <Option<SocketAddr> as ByteRead>::read(reader).await?,
204 Error::read(reader).await?,
205 )),
206 0x11 => Ok(Self::ClientRequestedUnsupportedVersion(
207 u64::read(reader).await?,
208 u8::read(reader).await?,
209 )),
210 0x12 => Ok(Self::ClientRequestedUnsupportedCommand(
211 u64::read(reader).await?,
212 u8::read(reader).await?,
213 )),
214 0x13 => Ok(Self::ClientRequestedUnsupportedAtyp(
215 u64::read(reader).await?,
216 u8::read(reader).await?,
217 )),
218 0x14 => Ok(Self::ClientSelectedAuthMethod(
219 u64::read(reader).await?,
220 AuthMethod::read(reader).await?,
221 )),
222 0x15 => Ok(Self::ClientNoAcceptableAuthMethod(u64::read(reader).await?)),
223 0x16 => Ok(Self::ClientRequestedUnsupportedUserpassVersion(
224 u64::read(reader).await?,
225 u8::read(reader).await?,
226 )),
227 0x17 => Ok(Self::ClientAuthenticatedWithUserpass(
228 u64::read(reader).await?,
229 SmallReadString::read(reader).await?.0,
230 bool::read(reader).await?,
231 )),
232 0x18 => Ok(Self::ClientSocksRequest(
233 u64::read(reader).await?,
234 SocksRequest::read(reader).await?,
235 )),
236 0x19 => Ok(Self::ClientDnsLookup(
237 u64::read(reader).await?,
238 SmallReadString::read(reader).await?.0,
239 )),
240 0x1A => Ok(Self::ClientAttemptingConnect(
241 u64::read(reader).await?,
242 SocketAddr::read(reader).await?,
243 )),
244 0x1B => Ok(Self::ClientConnectionAttemptBindFailed(
245 u64::read(reader).await?,
246 Error::read(reader).await?,
247 )),
248 0x1C => Ok(Self::ClientConnectionAttemptConnectFailed(
249 u64::read(reader).await?,
250 Error::read(reader).await?,
251 )),
252 0x1D => Ok(Self::ClientFailedToConnectToDestination(u64::read(reader).await?)),
253 0x1E => Ok(Self::ClientConnectedToDestination(
254 u64::read(reader).await?,
255 SocketAddr::read(reader).await?,
256 )),
257 0x1F => Ok(Self::ClientBytesSent(u64::read(reader).await?, u64::read(reader).await?)),
258 0x20 => Ok(Self::ClientBytesReceived(u64::read(reader).await?, u64::read(reader).await?)),
259 0x21 => Ok(Self::ClientSourceShutdown(u64::read(reader).await?)),
260 0x22 => Ok(Self::ClientDestinationShutdown(u64::read(reader).await?)),
261 0x23 => Ok(Self::ClientConnectionFinished(
262 u64::read(reader).await?,
263 u64::read(reader).await?,
264 u64::read(reader).await?,
265 <Result<(), Error> as ByteRead>::read(reader).await?,
266 )),
267 0x24 => Ok(Self::NewSandstormConnectionAccepted(
268 u64::read(reader).await?,
269 SocketAddr::read(reader).await?,
270 )),
271 0x25 => Ok(Self::SandstormConnectionAcceptFailed(
272 <Option<SocketAddr> as ByteRead>::read(reader).await?,
273 Error::read(reader).await?,
274 )),
275 0x26 => Ok(Self::SandstormRequestedUnsupportedVersion(
276 u64::read(reader).await?,
277 u8::read(reader).await?,
278 )),
279 0x27 => Ok(Self::SandstormAuthenticatedAs(
280 u64::read(reader).await?,
281 String::read(reader).await?,
282 bool::read(reader).await?,
283 )),
284 0x28 => Ok(Self::NewSocksSocketRequestedByManager(
285 u64::read(reader).await?,
286 SocketAddr::read(reader).await?,
287 )),
288 0x29 => Ok(Self::RemoveSocksSocketRequestedByManager(
289 u64::read(reader).await?,
290 SocketAddr::read(reader).await?,
291 )),
292 0x2A => Ok(Self::NewSandstormSocketRequestedByManager(
293 u64::read(reader).await?,
294 SocketAddr::read(reader).await?,
295 )),
296 0x2B => Ok(Self::RemoveSandstormSocketRequestedByManager(
297 u64::read(reader).await?,
298 SocketAddr::read(reader).await?,
299 )),
300 0x2C => Ok(Self::UserRegisteredByManager(
301 u64::read(reader).await?,
302 String::read(reader).await?,
303 UserRole::read(reader).await?,
304 )),
305 0x2D => Ok(Self::UserUpdatedByManager(
306 u64::read(reader).await?,
307 String::read(reader).await?,
308 UserRole::read(reader).await?,
309 bool::read(reader).await?,
310 )),
311 0x2E => Ok(Self::UserDeletedByManager(
312 u64::read(reader).await?,
313 String::read(reader).await?,
314 UserRole::read(reader).await?,
315 )),
316 0x2F => Ok(Self::AuthMethodToggledByManager(
317 u64::read(reader).await?,
318 AuthMethod::read(reader).await?,
319 bool::read(reader).await?,
320 )),
321 0x30 => Ok(Self::BufferSizeChangedByManager(u64::read(reader).await?, u32::read(reader).await?)),
322 0x31 => Ok(Self::SandstormRequestedShutdown(u64::read(reader).await?)),
323 0x32 => Ok(Self::SandstormConnectionFinished(
324 u64::read(reader).await?,
325 <Result<(), Error> as ByteRead>::read(reader).await?,
326 )),
327 0x33 => Ok(Self::ShutdownSignalReceived),
328 _ => Err(Error::new(ErrorKind::InvalidData, "Invalid EventData type byte")),
329 }
330 }
331}
332
333impl ByteWrite for EventData {
334 async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
335 match self {
336 Self::NewSocks5Socket(socket_address) => (0x01u8, socket_address).write(writer).await,
337 Self::FailedBindSocks5Socket(socket_address, io_error) => (0x02u8, socket_address, io_error).write(writer).await,
338 Self::FailedBindAnySocketAborting => 0x03u8.write(writer).await,
339 Self::RemovedSocks5Socket(socket_address) => (0x04u8, socket_address).write(writer).await,
340 Self::NewSandstormSocket(socket_address) => (0x05u8, socket_address).write(writer).await,
341 Self::FailedBindSandstormSocket(socket_address, io_error) => (0x06u8, socket_address, io_error).write(writer).await,
342 Self::RemovedSandstormSocket(socket_address) => (0x07u8, socket_address).write(writer).await,
343 Self::LoadingUsersFromFile(filename) => (0x08u8, filename).write(writer).await,
344 Self::UsersLoadedFromFile(filename, result) => (0x09u8, filename, result).write(writer).await,
345 Self::StartingUpWithSingleDefaultUser(userpass) => (0x0Au8, userpass).write(writer).await,
346 Self::SavingUsersToFile(filename) => (0x0Bu8, filename).write(writer).await,
347 Self::UsersSavedToFile(filename, result) => (0x0Cu8, filename, result).write(writer).await,
348 Self::UserRegisteredByArgs(username, role) => (0x0Du8, SmallWriteString(username), role).write(writer).await,
349 Self::UserReplacedByArgs(username, role) => (0x0Eu8, SmallWriteString(username), role).write(writer).await,
350 Self::NewClientConnectionAccepted(client_id, socket_address) => (0x0Fu8, client_id, socket_address).write(writer).await,
351 Self::ClientConnectionAcceptFailed(maybe_socket_address, io_error) => {
352 (0x10u8, maybe_socket_address, io_error).write(writer).await
353 }
354 Self::ClientRequestedUnsupportedVersion(client_id, ver) => (0x11u8, client_id, ver).write(writer).await,
355 Self::ClientRequestedUnsupportedCommand(client_id, cmd) => (0x12u8, client_id, cmd).write(writer).await,
356 Self::ClientRequestedUnsupportedAtyp(client_id, atyp) => (0x13u8, client_id, atyp).write(writer).await,
357 Self::ClientSelectedAuthMethod(client_id, auth_method) => (0x14u8, client_id, auth_method).write(writer).await,
358 Self::ClientNoAcceptableAuthMethod(client_id) => (0x15u8, client_id).write(writer).await,
359 Self::ClientRequestedUnsupportedUserpassVersion(client_id, ver) => (0x16u8, client_id, ver).write(writer).await,
360 Self::ClientAuthenticatedWithUserpass(client_id, username, success) => {
361 (0x17u8, client_id, SmallWriteString(username), success).write(writer).await
362 }
363 Self::ClientSocksRequest(client_id, request) => (0x18u8, client_id, request).write(writer).await,
364 Self::ClientDnsLookup(client_id, domainname) => (0x19u8, client_id, SmallWriteString(domainname)).write(writer).await,
365 Self::ClientAttemptingConnect(client_id, socket_address) => (0x1Au8, client_id, socket_address).write(writer).await,
366 Self::ClientConnectionAttemptBindFailed(client_id, io_error) => (0x1Bu8, client_id, io_error).write(writer).await,
367 Self::ClientConnectionAttemptConnectFailed(client_id, io_error) => (0x1Cu8, client_id, io_error).write(writer).await,
368 Self::ClientFailedToConnectToDestination(client_id) => (0x1Du8, client_id).write(writer).await,
369 Self::ClientConnectedToDestination(client_id, socket_address) => (0x1Eu8, client_id, socket_address).write(writer).await,
370 Self::ClientBytesSent(client_id, count) => (0x1Fu8, client_id, count).write(writer).await,
371 Self::ClientBytesReceived(client_id, count) => (0x20u8, client_id, count).write(writer).await,
372 Self::ClientSourceShutdown(client_id) => (0x21u8, client_id).write(writer).await,
373 Self::ClientDestinationShutdown(client_id) => (0x22u8, client_id).write(writer).await,
374 Self::ClientConnectionFinished(client_id, sent, received, result) => {
375 (0x23u8, client_id, sent, received, result).write(writer).await
376 }
377 Self::NewSandstormConnectionAccepted(manager_id, socket_address) => (0x24u8, manager_id, socket_address).write(writer).await,
378 Self::SandstormConnectionAcceptFailed(maybe_socket_address, io_error) => {
379 (0x25u8, maybe_socket_address, io_error).write(writer).await
380 }
381 Self::SandstormRequestedUnsupportedVersion(manager_id, version) => (0x26u8, manager_id, version).write(writer).await,
382 Self::SandstormAuthenticatedAs(manager_id, username, success) => (0x27u8, manager_id, username, success).write(writer).await,
383 Self::NewSocksSocketRequestedByManager(manager_id, socket_address) => (0x28u8, manager_id, socket_address).write(writer).await,
384 Self::RemoveSocksSocketRequestedByManager(manager_id, socket_address) => {
385 (0x29u8, manager_id, socket_address).write(writer).await
386 }
387 Self::NewSandstormSocketRequestedByManager(manager_id, socket_address) => {
388 (0x2Au8, manager_id, socket_address).write(writer).await
389 }
390 Self::RemoveSandstormSocketRequestedByManager(manager_id, socket_address) => {
391 (0x2Bu8, manager_id, socket_address).write(writer).await
392 }
393 Self::UserRegisteredByManager(manager_id, username, role) => (0x2Cu8, manager_id, username, role).write(writer).await,
394 Self::UserUpdatedByManager(manager_id, username, role, password_changed) => {
395 (0x2Du8, manager_id, username, role, password_changed).write(writer).await
396 }
397 Self::UserDeletedByManager(manager_id, username, role) => (0x2Eu8, manager_id, username, role).write(writer).await,
398 Self::AuthMethodToggledByManager(manager_id, auth_method, enabled) => {
399 (0x2Fu8, manager_id, auth_method, enabled).write(writer).await
400 }
401 Self::BufferSizeChangedByManager(manager_id, buffer_size) => (0x30u8, manager_id, buffer_size).write(writer).await,
402 Self::SandstormRequestedShutdown(manager_id) => (0x31u8, manager_id).write(writer).await,
403 Self::SandstormConnectionFinished(manager_id, result) => (0x32u8, manager_id, result).write(writer).await,
404 Self::ShutdownSignalReceived => 0x33u8.write(writer).await,
405 }
406 }
407}
408
409impl ByteRead for Event {
410 async fn read<R: AsyncRead + Unpin + ?Sized>(reader: &mut R) -> Result<Self, Error> {
411 Ok(Self::new(i64::read(reader).await?, EventData::read(reader).await?))
412 }
413}
414
415impl ByteWrite for Event {
416 async fn write<W: AsyncWrite + Unpin + ?Sized>(&self, writer: &mut W) -> Result<(), Error> {
417 self.timestamp.write(writer).await?;
418 self.data.write(writer).await
419 }
420}