ferry-core 0.1.9

Core protocol, discovery, transfer, manifest, trust, and filesystem logic for FileFerry.
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

use std::net::AddrParseError;
use std::path::PathBuf;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("invalid peer address: {0}")]
    InvalidPeerAddress(#[from] AddrParseError),

    #[error("invalid transfer input: {0}")]
    InvalidInput(String),

    #[error("peer not found: {0}")]
    PeerNotFound(String),

    #[error("peer lookup is ambiguous: {0}")]
    AmbiguousPeer(String),

    #[error("peer fingerprint mismatch: expected {expected}, got {actual}")]
    PeerFingerprintMismatch { expected: String, actual: String },

    #[error("filesystem error at {}: {source}", path.display())]
    IoPath {
        path: PathBuf,
        #[source]
        source: std::io::Error,
    },

    #[error("filesystem error: {0}")]
    Io(#[from] std::io::Error),

    #[error("configuration directory is unavailable")]
    ConfigDirUnavailable,

    #[error("configuration parse failed: {0}")]
    ConfigParse(String),

    #[error("configuration serialization failed: {0}")]
    ConfigSerialize(String),

    #[error("mDNS discovery failed: {0}")]
    Discovery(String),

    #[error("certificate generation failed: {0}")]
    CertificateGeneration(#[from] rcgen::Error),

    #[error("TLS configuration failed: {0}")]
    Tls(#[from] rustls::Error),

    #[error("QUIC connection failed: {0}")]
    Connect(#[from] quinn::ConnectError),

    #[error("QUIC connection closed: {0}")]
    Connection(#[from] quinn::ConnectionError),

    #[error("QUIC read failed: {0}")]
    Read(#[from] quinn::ReadError),

    #[error("QUIC exact read failed: {0}")]
    ReadExact(#[from] quinn::ReadExactError),

    #[error("QUIC write failed: {0}")]
    Write(#[from] quinn::WriteError),

    #[error("QUIC stream is closed: {0}")]
    ClosedStream(#[from] quinn::ClosedStream),

    #[error("QUIC endpoint connection refused")]
    NoIncomingConnection,

    #[error("crypto configuration failed: {0}")]
    CryptoConfig(String),

    #[error("protocol error: {0}")]
    Protocol(String),

    #[error("authentication failed: {0}")]
    Authentication(String),

    #[error("transfer failed: {0}")]
    Transfer(String),

    #[error("transfer cancelled")]
    TransferCancelled,

    #[error("{0} is not implemented yet")]
    NotImplemented(&'static str),
}

pub type Result<T> = std::result::Result<T, Error>;