s2n-quic-dc 0.47.0

Internal crate used by s2n-quic
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

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use crate::{
    clock::Timer,
    msg,
    stream::{
        recv::application::{Inner, LocalState, Reader},
        runtime,
        shared::ArcShared,
        socket,
    },
};
use core::mem::ManuallyDrop;
use s2n_quic_core::endpoint;

pub struct Builder {
    endpoint: endpoint::Type,
    runtime: runtime::ArcHandle,
}

impl Builder {
    #[inline]
    pub fn new(endpoint: endpoint::Type, runtime: runtime::ArcHandle) -> Self {
        Self { endpoint, runtime }
    }
}

impl Builder {
    #[inline]
    pub fn build(self, shared: ArcShared, sockets: socket::ArcApplication) -> Reader {
        let Self { endpoint, runtime } = self;

        let remote_addr = shared.read_remote_addr();
        // we only need a timer for unreliable transports
        let is_reliable = sockets.read_application().features().is_reliable();
        let timer = if is_reliable {
            None
        } else {
            Some(Timer::new(&shared.clock))
        };
        let gso = shared.gso.clone();
        let send_buffer = msg::send::Message::new(remote_addr, gso);
        let read_mode = Default::default();
        let ack_mode = Default::default();
        let local_state = match endpoint {
            // reliable transports on the client need to read at least one packet in order to
            // process secret control packets
            endpoint::Type::Client if is_reliable => LocalState::Ready,
            // unreliable transports use background workers to drive state
            endpoint::Type::Client => LocalState::Reading,
            // the server acceptor already read from the socket at least once
            endpoint::Type::Server => LocalState::Reading,
        };

        Reader(ManuallyDrop::new(Box::new(Inner {
            shared,
            sockets,
            send_buffer,
            read_mode,
            ack_mode,
            timer,
            local_state,
            runtime,
        })))
    }
}