srt_protocol/listener/
input.rs

1use std::net::SocketAddr;
2
3use crate::{
4    connection::Connection,
5    packet::{Packet, ReceivePacketResult},
6};
7
8use super::*;
9
10pub use crate::protocol::pending_connection::{AccessControlRequest, AccessControlResponse};
11
12#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
13pub struct SessionId(pub SocketAddr);
14
15#[derive(Debug, Eq, PartialEq)]
16#[allow(clippy::large_enum_variant)]
17pub enum Input {
18    Packet(ReceivePacketResult),
19    AccessResponse(Option<(SessionId, AccessControlResponse)>),
20    Success(ResultOf),
21    Failure(ResultOf),
22    Timer,
23}
24
25#[derive(Debug, Eq, PartialEq)]
26pub enum Action<'a> {
27    SendPacket((Packet, SocketAddr)),
28    RequestAccess(SessionId, AccessControlRequest),
29    RejectConnection(SessionId, Option<(Packet, SocketAddr)>),
30    OpenConnection(SessionId, Box<(Option<(Packet, SocketAddr)>, Connection)>),
31    DelegatePacket(SessionId, (Packet, SocketAddr)),
32    DropConnection(SessionId),
33    UpdateStatistics(&'a ListenerStatistics),
34    WaitForInput,
35    Close,
36}
37
38#[derive(Debug, Eq, PartialEq)]
39pub enum ResultOf {
40    SendPacket(SocketAddr),
41    RequestAccess(SessionId),
42    RejectConnection(SessionId),
43    OpenConnection(SessionId),
44    DelegatePacket(SessionId),
45    DropConnection(SessionId),
46    UpdateStatistics,
47}
48
49pub struct NextInputContext(Option<ResultOf>);
50
51impl NextInputContext {
52    pub fn for_action(action: &Action) -> Self {
53        use Action::*;
54        let context = match action {
55            SendPacket((_, address)) => Some(ResultOf::SendPacket(*address)),
56            RequestAccess(id, _) => Some(ResultOf::RequestAccess(*id)),
57            RejectConnection(id, _) => Some(ResultOf::RejectConnection(*id)),
58            OpenConnection(id, _) => Some(ResultOf::OpenConnection(*id)),
59            DelegatePacket(id, _) => Some(ResultOf::DelegatePacket(*id)),
60            DropConnection(id) => Some(ResultOf::DropConnection(*id)),
61            UpdateStatistics(_) => Some(ResultOf::UpdateStatistics),
62            WaitForInput | Close => None,
63        };
64        Self(context)
65    }
66
67    pub fn input_from<T, E>(self, result: Result<T, E>) -> Input {
68        let result_of = self.0.unwrap();
69        match result {
70            Ok(_) => Input::Success(result_of),
71            Err(_) => Input::Failure(result_of),
72        }
73    }
74}