qconnection 0.5.0

Encapsulation of QUIC connections, a part of dquic
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

use std::{ops::Deref, sync::Arc};

use qbase::{
    error::Error,
    frame::{
        HandshakeDoneFrame,
        io::{ReceiveFrame, SendFrame},
    },
    role::Role,
};
use qcongestion::HandshakeStatus;

use crate::{
    events::{ArcEventBroker, EmitEvent, Event},
    path::ArcPathContexts,
};

pub type RawHandshake<T> = qbase::handshake::Handshake<T>;

/// A wrapper of [`qbase::handshake::Handshake`] that will emit [`Event::Handshaked`] when the handshake is done.
///
/// Read the documentation of [`qbase::handshake::Handshake`] for more information.
#[derive(Clone)]
pub struct Handshake<T>
where
    T: SendFrame<HandshakeDoneFrame> + Clone,
{
    inner: RawHandshake<T>,
    inform_cc: Arc<HandshakeStatus>,
    broker: ArcEventBroker,
}

impl<T> Handshake<T>
where
    T: SendFrame<HandshakeDoneFrame> + Clone,
{
    pub fn new(
        raw: RawHandshake<T>,
        inform_cc: Arc<HandshakeStatus>,
        broker: ArcEventBroker,
    ) -> Self {
        Self {
            inner: raw,
            inform_cc,
            broker,
        }
    }

    pub fn discard_spaces_on_server_handshake_done(&self, paths: &ArcPathContexts) -> bool {
        let is_server_done = self.inner.done();
        if is_server_done {
            self.inform_cc.handshake_confirmed();
            paths.discard_initial_and_handshake_space();
            self.broker.emit(Event::Handshaked);
        }
        is_server_done
    }

    pub fn role(&self) -> Role {
        self.inner.role()
    }

    pub fn status(&self) -> Arc<HandshakeStatus> {
        self.inform_cc.clone()
    }

    pub fn discard_spaces_on_client_handshake_done(
        &self,
        paths: ArcPathContexts,
    ) -> HandshakeDoneReceiver<T> {
        HandshakeDoneReceiver {
            handshake: self.clone(),
            paths,
        }
    }
}

pub struct HandshakeDoneReceiver<T>
where
    T: SendFrame<HandshakeDoneFrame> + Clone,
{
    handshake: Handshake<T>,
    paths: ArcPathContexts,
}

impl<T> ReceiveFrame<HandshakeDoneFrame> for HandshakeDoneReceiver<T>
where
    T: SendFrame<HandshakeDoneFrame> + Clone,
{
    type Output = ();

    fn recv_frame(&self, frame: &HandshakeDoneFrame) -> Result<(), Error> {
        if self.handshake.inner.recv_frame(frame)? {
            self.handshake.inform_cc.handshake_confirmed();
            self.paths.discard_initial_and_handshake_space();
            self.handshake.broker.emit(Event::Handshaked);
        }
        Ok(())
    }
}

impl<T> Deref for Handshake<T>
where
    T: SendFrame<HandshakeDoneFrame> + Clone,
{
    type Target = HandshakeStatus;

    fn deref(&self) -> &Self::Target {
        &self.inform_cc
    }
}