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

mod endpoint;
mod muxer;
mod noise;
mod transport;

pub use crate::muxer::{QuicMuxer, QuicMuxerError};
pub use crate::transport::{QuicDial, QuicTransport};
pub use libp2p::core::identity::Keypair;
pub use quinn_proto::{ConfigError, ConnectError, ConnectionError, TransportConfig};
pub use snow::params::NoiseParams;

use libp2p::core::transport::TransportError;
use libp2p::Multiaddr;
use thiserror::Error;

/// Quic configuration.
pub struct QuicConfig {
    pub keypair: Keypair,
    pub noise: NoiseParams,
    pub prologue: Vec<u8>,
    pub transport: TransportConfig,
}

impl Default for QuicConfig {
    fn default() -> Self {
        Self {
            keypair: Keypair::generate_ed25519(),
            noise: "Noise_XX_25519_AESGCM_SHA256".parse().unwrap(),
            prologue: vec![],
            transport: TransportConfig::default(),
        }
    }
}

impl std::fmt::Debug for QuicConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("QuicConfig")
            .field("keypair", &self.keypair.public())
            .field("noise", &self.noise)
            .field("prologue", &self.prologue)
            .field("transport", &self.transport)
            .finish()
    }
}

impl QuicConfig {
    /// Creates a new config from a keypair.
    pub fn new(keypair: &Keypair) -> Self {
        Self {
            keypair: keypair.clone(),
            ..Default::default()
        }
    }

    /// Spawns a new endpoint.
    pub async fn listen_on(
        self,
        addr: Multiaddr,
    ) -> Result<QuicTransport, TransportError<QuicError>> {
        QuicTransport::new(self, addr).await
    }
}

#[derive(Debug, Error)]
pub enum QuicError {
    #[error("{0}")]
    Config(#[from] ConfigError),
    #[error("{0}")]
    Connect(#[from] ConnectError),
    #[error("{0}")]
    Muxer(#[from] QuicMuxerError),
    #[error("{0}")]
    Io(#[from] std::io::Error),
    #[error("a `StreamMuxerEvent` was generated before the handshake was complete.")]
    UpgradeError,
}