dope-tls 0.19.0

TCP TLS streams for dope runtime, shin-backed
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

use crate::error;
use crate::state::Internals as _;
use crate::state::{self, direct, sessions, staged};

pub trait Client<'d> {
    fn read_tcp(&mut self, bytes: &[u8], receive: impl FnMut(&[u8])) -> Result<(), error::Error>;

    #[doc(hidden)]
    fn read_tcp_in_place<'a>(&mut self, bytes: &'a mut [u8]) -> direct::WireRead<'a>;

    #[doc(hidden)]
    fn read_staged_wire(&mut self, bytes: &[u8]) -> staged::WireRead<'d>;

    fn try_read_tcp(&mut self, bytes: &[u8], receive: impl FnMut(&[u8])) -> bool;
}

pub trait Server<'d> {
    fn read_tcp(&mut self, bytes: &[u8], receive: impl FnMut(&[u8])) -> Result<(), error::Error>;

    #[doc(hidden)]
    fn read_tcp_in_place<'a>(&mut self, bytes: &'a mut [u8]) -> direct::WireRead<'a>;

    #[doc(hidden)]
    fn read_staged_wire(&mut self, bytes: &[u8]) -> staged::WireRead<'d>;

    fn try_read_tcp(&mut self, bytes: &[u8], receive: impl FnMut(&[u8])) -> bool;
}

impl<'d, S: sessions::ClientPeer> Client<'d> for state::State<'d, S> {
    fn read_tcp(
        &mut self,
        bytes: &[u8],
        mut receive: impl FnMut(&[u8]),
    ) -> Result<(), error::Error> {
        let read = staged::Reader::new(self).read(
            bytes,
            &mut |session, epoch, data, events| session.read_into(epoch, data, events),
            &mut receive,
        );
        let drained = self.drain_pending_control();
        read?;
        drained
    }

    fn read_tcp_in_place<'a>(&mut self, bytes: &'a mut [u8]) -> direct::WireRead<'a> {
        let mut read = direct::Reader::new(self)
            .read_in_place(bytes, &mut |session, epoch, data, events| {
                session.read_into(epoch, data, events)
            });
        if self.drain_pending_control().is_err() {
            read.fail();
        }
        read
    }

    fn read_staged_wire(&mut self, bytes: &[u8]) -> staged::WireRead<'d> {
        let mut read = staged::Reader::new(self)
            .read_one_wire(bytes, &mut |session, epoch, data, events| {
                session.read_into(epoch, data, events)
            });
        if self.drain_pending_control().is_err() {
            read.fail();
        }
        read
    }

    fn try_read_tcp(&mut self, bytes: &[u8], receive: impl FnMut(&[u8])) -> bool {
        bytes.is_empty() || Client::read_tcp(self, bytes, receive).is_ok()
    }
}

impl<'d, S: sessions::ServerPeer> Server<'d> for state::State<'d, S> {
    fn read_tcp(
        &mut self,
        bytes: &[u8],
        mut receive: impl FnMut(&[u8]),
    ) -> Result<(), error::Error> {
        let read = staged::Reader::new(self).read(
            bytes,
            &mut |session, epoch, data, events| session.read_into(epoch, data, events),
            &mut receive,
        );
        let drained = self.drain_pending_control();
        read?;
        drained
    }

    fn read_tcp_in_place<'a>(&mut self, bytes: &'a mut [u8]) -> direct::WireRead<'a> {
        let mut read = direct::Reader::new(self)
            .read_in_place(bytes, &mut |session, epoch, data, events| {
                session.read_into(epoch, data, events)
            });
        if self.drain_pending_control().is_err() {
            read.fail();
        }
        read
    }

    fn read_staged_wire(&mut self, bytes: &[u8]) -> staged::WireRead<'d> {
        let mut read = staged::Reader::new(self)
            .read_one_wire(bytes, &mut |session, epoch, data, events| {
                session.read_into(epoch, data, events)
            });
        if self.drain_pending_control().is_err() {
            read.fail();
        }
        read
    }

    fn try_read_tcp(&mut self, bytes: &[u8], receive: impl FnMut(&[u8])) -> bool {
        bytes.is_empty() || Server::read_tcp(self, bytes, receive).is_ok()
    }
}