networking 0.1.9

secure RSA + AES network implementations in a peer to peer enabled manner
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
115

use std::array::TryFromSliceError;
use std::error::Error;
use std::fmt;
use std::string::FromUtf8Error;
use std::sync::mpsc::RecvError as SyncRecvError;
use std::sync::mpsc::SendError as SyncSendError;
use tokio::sync::mpsc::error::RecvError as AsyncRecvError;
use tokio::sync::mpsc::error::SendError as AsyncSendError;
use tokio::task::JoinError;
#[derive(Debug)]
pub enum NetworkError {
    IOError(std::io::Error),
    RSAError(rsa::errors::Error),
    SerdeError(serde_json::error::Error),
    UTF8(FromUtf8Error),
    ConnectionDenied(String),
    FromSlice(TryFromSliceError),
    UnSet(String),
    AsyncSendError(String),
    AsyncRecvError(String),
    SyncSendError(String),
    SyncRecvError(String),
    TomlDeError(toml::de::Error),
    TomlSerError(toml::ser::Error),
    JoinError(JoinError),
    DirError(walkdir::Error),
}
impl fmt::Display for NetworkError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let msg = match self {
            NetworkError::IOError(err) => format!("{}", err),
            NetworkError::RSAError(err) => format!("{}", err),
            NetworkError::SerdeError(err) => format!("{}", err),
            NetworkError::UnSet(e) => e.to_string(),
            NetworkError::UTF8(e) => format!("{}", e),
            NetworkError::ConnectionDenied(e) => e.to_string(),
            NetworkError::FromSlice(e) => format!("{}", e),
            NetworkError::AsyncSendError(e) => e.to_string(),
            NetworkError::AsyncRecvError(e) => e.to_string(),
            NetworkError::SyncSendError(e) => e.to_string(),
            NetworkError::SyncRecvError(e) => e.to_string(),
            NetworkError::TomlDeError(e) => format!("{}", e),
            NetworkError::TomlSerError(e) => format!("{}", e),
            NetworkError::JoinError(e) => format!("{}", e),
            NetworkError::DirError(e) => format!("{}", e),
        };
        write!(f, "{}", msg)
    }
}
impl Error for NetworkError {}
impl From<std::io::Error> for NetworkError {
    fn from(error: std::io::Error) -> NetworkError {
        NetworkError::IOError(error)
    }
}
impl From<rsa::errors::Error> for NetworkError {
    fn from(error: rsa::errors::Error) -> NetworkError {
        NetworkError::RSAError(error)
    }
}
impl From<serde_json::error::Error> for NetworkError {
    fn from(error: serde_json::error::Error) -> NetworkError {
        NetworkError::SerdeError(error)
    }
}
impl From<FromUtf8Error> for NetworkError {
    fn from(error: FromUtf8Error) -> NetworkError {
        NetworkError::UTF8(error)
    }
}
impl From<TryFromSliceError> for NetworkError {
    fn from(error: TryFromSliceError) -> Self {
        NetworkError::FromSlice(error)
    }
}
impl<T> From<AsyncSendError<T>> for NetworkError {
    fn from(error: AsyncSendError<T>) -> NetworkError {
        NetworkError::AsyncSendError(format!("{}", error))
    }
}
impl From<AsyncRecvError> for NetworkError {
    fn from(error: AsyncRecvError) -> NetworkError {
        NetworkError::AsyncRecvError(format!("{}", error))
    }
}
impl<T> From<SyncSendError<T>> for NetworkError {
    fn from(error: SyncSendError<T>) -> NetworkError {
        NetworkError::SyncSendError(format!("{}", error))
    }
}
impl From<SyncRecvError> for NetworkError {
    fn from(error: SyncRecvError) -> NetworkError {
        NetworkError::SyncRecvError(format!("{}", error))
    }
}
impl From<toml::de::Error> for NetworkError {
    fn from(error: toml::de::Error) -> Self {
        NetworkError::TomlDeError(error)
    }
}
impl From<JoinError> for NetworkError {
    fn from(error: JoinError) -> Self {
        NetworkError::JoinError(error)
    }
}
impl From<toml::ser::Error> for NetworkError {
    fn from(error: toml::ser::Error) -> Self {
        NetworkError::TomlSerError(error)
    }
}
impl From<walkdir::Error> for NetworkError {
    fn from(error: walkdir::Error) -> Self {
        NetworkError::DirError(error)
    }
}