dope-net 0.38.0

Owned network transports for dope
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Ownership and lifetime contracts.
//!
//! Reservation cannot widen the lifetime of the protocol owner it borrows.
//! Read access alone does not prove immutable payload geometry.

use dope_core::io::fd::outbound;
use o3::{
    alloc,
    buffer::pool::{GrowingError, LayoutError},
    depot::{heap, queue::pool},
};

pub mod link;
pub mod tcp;
pub mod wire;

use std::{net, result};

use dope_core::{
    driver::{
        self,
        retained::flight,
        route::table::{self, bounds},
    },
    io::{
        fd::handles,
        socket::{self, install::Error, option},
    },
};

use crate::link::egress::create;

/// Failure to construct retained network resources before a route is bound.

#[derive(Debug)]
pub enum Resource {
    Config(ConfigError),
    Descriptor(outbound::Error),
    Binding(BindingError),
    BufferLayout(BufferLayout),
    Pool(GrowingError),
    Allocation(alloc::Error),
    Queue(alloc::Error),
    Heap(heap::Error),
    Exhausted(alloc::Exhausted),
    Credit(alloc::Error),
    Egress(create::Error),
}

type Result<T> = result::Result<T, Resource>;

/// Construction input which violates a relationship not already encoded by
/// its component types.

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum ConfigError {
    ReceiveLayout(pool::Error),
    ReceiveCapacity {
        entries: usize,
        lanes: usize,
    },
    RearmCapacity {
        entries: usize,
        lanes: usize,
    },
    PhysicalBelowLogical {
        logical: table::Capacity,
        physical: table::Capacity,
    },
    RouteSegment(bounds::SegmentError),
    FlightCapacity(flight::ScaleError),
}

/// Failure while binding a network resource to driver ownership.

#[derive(PartialEq, Eq, Debug)]
pub enum BindingError {
    AlreadyBound,
    Bootstrap(Error),
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[repr(u8)]
pub enum BufferKind {
    Receive,
    Send,
}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct BufferLayout {
    kind: BufferKind,
    cause: LayoutError,
}

impl BufferLayout {
    pub const fn new(kind: BufferKind, cause: LayoutError) -> Self {
        Self { kind, cause }
    }

    pub const fn kind(self) -> BufferKind {
        self.kind
    }

    pub const fn cause(self) -> LayoutError {
        self.cause
    }
}

pub trait Transport: Sized {
    type Addr;
    /// Retained kernel storage converted from an already validated address.
    type Prepared: socket::Prepared + for<'a> From<&'a Self::Addr>;
    type StreamConfig: Default + Copy;

    /// Resolves stream tuning into an owned, allocation-free kernel plan.
    fn options(config: Self::StreamConfig) -> option::Set;
}

pub trait Listen: Transport {
    type ListenerConfig: Default + Clone;
    type BoundListener;

    fn bind<'d>(
        driver: &mut driver::Context<'_, 'd>,
        addr: &Self::Addr,
        cap: socket::Backlog,
        config: &Self::ListenerConfig,
    ) -> result::Result<(handles::Descriptor<'d>, net::SocketAddr), BindingError>;

    fn adopt<'d>(
        driver: &mut driver::Context<'_, 'd>,
        bound: Self::BoundListener,
    ) -> result::Result<(handles::Descriptor<'d>, net::SocketAddr), BindingError>;
}