dope-core 0.35.0

Owned native I/O and completion driver for dope
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 std::num;

use dope_sys::{
    Cloexec, Errno, Nonblock,
    io::socket::{Setup, SetupOrigin, addr},
};

use crate::{
    driver::result,
    io::{
        socket,
        socket::{
            adoption,
            install::{Operation, adopt, receive, slot},
        },
    },
};

/// Exact bootstrap failure with typed validation and numeric OS causes.
#[derive(PartialEq, Eq, Debug)]
pub enum Error {
    Slot(slot::Error),
    Receive(receive::Error),
    Adopt(adopt::Error),
    FastOpen(num::NonZero<i32>),
    Address(socket::Error),
    LocalAddress(addr::Local<Errno>),
    DescriptorFlags(crate::Errno),
    CloseOnExec(crate::Errno),
    StatusFlags(crate::Errno),
    Nonblocking(crate::Errno),
    Sigpipe(crate::Errno),
    System {
        operation: Operation,
        fault: crate::Errno,
    },
    Kernel {
        operation: Operation,
        cause: result::Kernel,
    },
}

impl Error {
    pub(crate) fn reuse((reuse, errno): (socket::Reuse, dope_sys::Errno)) -> Self {
        Self::syscall(socket::reuse_step(reuse), errno)
    }

    pub(crate) fn setup(error: Setup) -> Self {
        match error.origin() {
            SetupOrigin::Cloexec(Cloexec::Get(error)) => Self::DescriptorFlags(error),
            SetupOrigin::Cloexec(Cloexec::Set(error)) => Self::CloseOnExec(error),
            SetupOrigin::Nonblock(Nonblock::Get(error)) => Self::StatusFlags(error),
            SetupOrigin::Nonblock(Nonblock::Set(error)) => Self::Nonblocking(error),
            SetupOrigin::Sigpipe(error) => Self::Sigpipe(error),
        }
    }

    pub(crate) const fn syscall(op: Operation, fault: dope_sys::Errno) -> Self {
        Self::System {
            operation: op,
            fault,
        }
    }

    pub(crate) const fn kernel(op: Operation, cause: result::Kernel) -> Self {
        Self::Kernel {
            operation: op,
            cause,
        }
    }

    pub(crate) fn validation(error: adoption::Error) -> Self {
        match error {
            adoption::Error::Syscall(errno) => Self::syscall(Operation::Validate, errno),
            adoption::Error::Role(error) => Self::Adopt(error),
        }
    }
}