fast 0.4.0

A helper library
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

use crate::linux::io_uring::IoUringError;
use crate::linux::sys::Errno;
use alloc::string::String;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum NetworkError {
    #[error("io_uring error: {0}")]
    IoUring(#[from] IoUringError),

    #[error("Invalid address")]
    InvalidAddress,

    #[error("Address already in use")]
    AddressInUse,

    #[error("Connection refused")]
    ConnectionRefused,

    #[error("Connection reset by peer")]
    ConnectionReset,

    #[error("Connection timed out")]
    TimedOut,

    #[error("Network unreachable")]
    NetworkUnreachable,

    #[error("Host unreachable")]
    HostUnreachable,

    #[error("Broken pipe")]
    BrokenPipe,

    #[error("Not connected")]
    NotConnected,

    #[error("Already connected")]
    AlreadyConnected,

    #[error("Would block")]
    WouldBlock,

    #[error("Protocol error")]
    Protocol,

    #[error("Message too large")]
    MessageTooLarge,

    #[error("Buffer pool exhausted")]
    BufferPoolExhausted,

    #[error("System error: {0}")]
    System(i32),

    #[error("{0}")]
    Internal(String),
}

impl From<Errno> for NetworkError {
    fn from(errno: Errno) -> Self {
        match errno {
            Errno::Again => NetworkError::WouldBlock,
            Errno::ConnRefused => NetworkError::ConnectionRefused,
            Errno::ConnReset => NetworkError::ConnectionReset,
            Errno::TimedOut => NetworkError::TimedOut,
            Errno::NetUnreach => NetworkError::NetworkUnreachable,
            Errno::HostUnreach => NetworkError::HostUnreachable,
            Errno::Pipe => NetworkError::BrokenPipe,
            Errno::NotConn => NetworkError::NotConnected,
            Errno::IsConn => NetworkError::AlreadyConnected,
            Errno::Already => NetworkError::AddressInUse,
            _ => NetworkError::System(errno.as_raw()),
        }
    }
}

pub type Result<T> = core::result::Result<T, NetworkError>;