meadow 0.4.0

Robotics-focused middleware for embedded Linux
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
114

use core::fmt::{Display, Formatter};
use serde::*;

use crate::Error;

/// QUIC-related errors
#[cfg(feature = "quic")]
#[derive(Clone, Debug, thiserror::Error, PartialEq, Serialize, Deserialize)]
pub enum Quic {
    /// Error acquiring owned connection
    #[error("Error acquiring owned connection")]
    Connection,
    /// Error reading .pem key file
    #[error("Error reading .pem key file")]
    ReadKeys,
    /// No certificate path was provided
    #[error("No certificate path was provided")]
    NoProvidedCertPath,
    /// Transparent `quin::ConnectError`
    #[error("`quinn::ConnectError`-based error")]
    ConnectError,
    /// Transparent `quinn::ConnectionError`
    #[error("`quinn::ConnectionError`-based error")]
    ConnectionError,
    /// Transparent `quinn::WriteError`
    #[error("`quinn::WriteError`-based error")]
    WriteError,
    /// Transparent `quinn::ReadError`
    #[error("`quinn::ReadError`-based error")]
    ReadError,
    /// Rustls-based webpki error around adding certificate to RootCertStore
    #[error("Rustls-based webpki error around adding certificate to RootCertStore")]
    Webpki,
    /// Transparent `rustls::Error`
    #[error("`rustls::Error`-based error")]
    RustlsError,
}

// ===== quinn::ConnectError =====
impl From<quinn::ConnectError> for Quic {
    fn from(error: quinn::ConnectError) -> Self {
        // TO_DO: This could be more fleshed out
        Quic::ConnectError
    }
}

impl From<quinn::ConnectError> for crate::Error {
    fn from(error: quinn::ConnectError) -> Self {
        // TO_DO: This could be more fleshed out
        Error::Quic(error.into())
    }
}

// ===== quinn::ConnectionError =====
impl From<quinn::ConnectionError> for Quic {
    fn from(error: quinn::ConnectionError) -> Self {
        // TO_DO: This could be more fleshed out
        Quic::ConnectionError
    }
}

impl From<quinn::ConnectionError> for crate::Error {
    fn from(error: quinn::ConnectionError) -> Self {
        // TO_DO: This could be more fleshed out
        Error::Quic(error.into())
    }
}

// ===== quinn::WriteError =====

impl From<quinn::WriteError> for Quic {
    fn from(error: quinn::WriteError) -> Self {
        // TO_DO: This could be more fleshed out
        Quic::WriteError
    }
}

impl From<quinn::WriteError> for crate::Error {
    fn from(error: quinn::WriteError) -> Self {
        // TO_DO: This could be more fleshed out
        Error::Quic(error.into())
    }
}

// ===== quinn::ReadError =====
impl From<quinn::ReadError> for Quic {
    fn from(error: quinn::ReadError) -> Self {
        // TO_DO: This could be more fleshed out
        Quic::ReadError
    }
}

impl From<quinn::ReadError> for crate::Error {
    fn from(error: quinn::ReadError) -> Self {
        // TO_DO: This could be more fleshed out
        Error::Quic(error.into())
    }
}

// ===== rustls::Error =====

impl From<rustls::Error> for Quic {
    fn from(error: rustls::Error) -> Self {
        // TO_DO: This could be more fleshed out
        Quic::RustlsError
    }
}

impl From<rustls::Error> for crate::Error {
    fn from(error: rustls::Error) -> Self {
        // TO_DO: This could be more fleshed out
        Error::Quic(error.into())
    }
}