dope-core 0.15.1

The manifold runtime
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

use std::{mem, num};

use crate::{
    io::{datagram, socket::msg},
    platform,
};

#[repr(C, align(8))]
pub(crate) struct Control {
    buffer: Buffer,
    segment_size: num::NonZeroU16,
}

pub(crate) struct Capability;

impl platform::GsoMode for Control {
    type Capability = super::Capability;
    type Control = Self;

    const LIMITS: Option<datagram::GsoLimits> = Some(super::LIMITS);

    fn acquire() -> Option<Self::Capability> {
        Some(Capability)
    }

    fn limits(_: &Self::Capability) -> datagram::GsoLimits {
        super::LIMITS
    }

    fn control(_: Self::Capability, segment_size: num::NonZeroU16) -> Self::Control {
        Self {
            buffer: Buffer::new(),
            segment_size,
        }
    }

    fn release(control: Self::Control) -> (Self::Capability, num::NonZeroU16) {
        (Capability, control.segment_size)
    }

    fn attach<'a>(control: &'a mut Self::Control, msg: &mut msg::Builder<'a>) {
        let segment_size = control.segment_size.get();
        control.buffer.attach(msg, segment_size);
    }
}

struct Buffer([u8; 32]);

impl Buffer {
    const fn new() -> Self {
        Self([0; 32])
    }

    fn attach<'a>(&'a mut self, msg: &mut msg::Builder<'a>, segment_size: u16) {
        const DATA_LEN: u32 = mem::size_of::<u16>() as u32;
        let (buf, cap) = (self.0.as_mut_ptr(), self.0.len());
        unsafe {
            use std::ptr::{addr_of, copy_nonoverlapping};

            use libc::{CMSG_DATA, CMSG_LEN, CMSG_SPACE, SOL_UDP, UDP_SEGMENT};
            let controllen = CMSG_SPACE(DATA_LEN) as usize;
            debug_assert!(controllen <= cap);
            let hdr = buf.cast::<libc::cmsghdr>();
            (*hdr).cmsg_level = SOL_UDP;
            (*hdr).cmsg_type = UDP_SEGMENT;
            (*hdr).cmsg_len = CMSG_LEN(DATA_LEN) as _;
            copy_nonoverlapping(
                addr_of!(segment_size).cast::<u8>(),
                CMSG_DATA(hdr),
                DATA_LEN as usize,
            );
            msg.control(&self.0[..controllen]);
        }
    }
}