packetz 2.0.0

Create async packet-based servers with ease, Built with gamedev in mind. Stay tuned for UDP support, and more!
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

use std::io;
use tokio::{net, io::split};
use std::net::SocketAddr;
use crate::packet::*;

pub type TcpPacketStream = PacketStream<net::TcpStream, net::TcpStream>;

pub struct Server<Url: net::ToSocketAddrs> {
    bind: Url
}

impl<Url: net::ToSocketAddrs> Server<Url> {
    pub const fn bind(bind: Url) -> Self {
        return Self {
            bind
        }
    }
    pub async fn listen(&self) -> Result<ServerListener, io::Error> {
        Ok(ServerListener {
            listener: net::TcpListener::bind(&self.bind).await?
        })
    }
}

pub struct ServerListener {
    listener: net::TcpListener
}

impl ServerListener {
    pub async fn accept(&self) -> Result<(TcpPacketStream, SocketAddr), io::Error> {
        let (stream, addr) = self.listener.accept().await?;
        let (read, write) = split(stream);
        Ok((
            PacketStream {
                read: PacketRead { stream: read },
                write: PacketWrite { stream: write }
            },
            addr
        ))
    }
}

#[cfg(feature = "tls")]
pub mod tls {
    use std::io;
    use std::sync::Arc;
    use tokio::io::split;
    use tokio::net;
    use std::net::SocketAddr;
    use tokio_rustls::TlsAcceptor;
    use crate::packet::*;
    use tokio_rustls::rustls::ServerConfig;

    pub type TlsServerTcpPacketStream = PacketStream<tokio_rustls::server::TlsStream<tokio::net::TcpStream>, tokio_rustls::server::TlsStream<tokio::net::TcpStream>>;

    pub struct Server<Url: net::ToSocketAddrs> {
        bind: Url
    }

    impl<Url: net::ToSocketAddrs> Server<Url> {
        pub const fn bind(bind: Url) -> Self {
            return Self {
                bind
            }
        }
        pub async fn listen(&self, config: Arc<ServerConfig>) -> Result<ServerListener, io::Error> {
            Ok(ServerListener {
                listener: net::TcpListener::bind(&self.bind).await?,
                acceptor: TlsAcceptor::from(config)
            })
        }
    }

    pub struct ServerListener {
        listener: net::TcpListener,
        acceptor: TlsAcceptor
    }

    impl ServerListener {
        pub async fn accept(&self) -> Result<(TlsServerTcpPacketStream, SocketAddr), io::Error> {
            let (stream, addr) = self.listener.accept().await?;
            let stream = self.acceptor.accept(stream).await?;
            let (read, write) = split(stream);
            Ok((
                PacketStream {
                    read: PacketRead { stream: read },
                    write: PacketWrite { stream: write }
                },
                addr
            ))
        }
    }
}