s2n-quic-platform 0.88.0

Internal crate used by s2n-quic
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

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use crate::features;
use s2n_quic_core::inet::{ExplicitCongestionNotification, SocketAddress};

#[derive(Clone, Copy, Debug)]
pub struct Error;

pub trait Encoder {
    /// Encodes the given value as a control message in the cmsg buffer.
    ///
    /// The msghdr.msg_control should be zero-initialized and aligned and contain enough
    /// room for the value to be written.
    fn encode_cmsg<T: Copy>(
        &mut self,
        level: libc::c_int,
        ty: libc::c_int,
        value: T,
    ) -> Result<usize, Error>;

    /// Encodes ECN markings into the cmsg encoder
    #[inline]
    fn encode_ecn(
        &mut self,
        ecn: ExplicitCongestionNotification,
        remote_address: &SocketAddress,
    ) -> Result<usize, Error> {
        // no need to encode for the default case
        if ecn == ExplicitCongestionNotification::NotEct {
            return Ok(0);
        }

        // the remote address needs to be unmapped in order to set the appropriate cmsg
        match remote_address.unmap() {
            SocketAddress::IpV4(_) => {
                if let (Some(level), Some(ty)) = (features::tos_v4::LEVEL, features::tos_v4::TYPE) {
                    return self.encode_cmsg(level, ty, ecn as u8 as features::tos_v4::Cmsg);
                }
            }
            SocketAddress::IpV6(_) => {
                if let (Some(level), Some(ty)) = (features::tos_v6::LEVEL, features::tos_v6::TYPE) {
                    return self.encode_cmsg(level, ty, ecn as u8 as features::tos_v6::Cmsg);
                }
            }
        }

        Ok(0)
    }

    /// Encodes GSO segment_size into the cmsg encoder
    #[inline]
    fn encode_gso(&mut self, segment_size: u16) -> Result<usize, Error> {
        if let (Some(level), Some(ty)) = (features::gso::LEVEL, features::gso::TYPE) {
            let segment_size = segment_size as features::gso::Cmsg;
            self.encode_cmsg(level, ty, segment_size)
        } else {
            panic!("platform does not support GSO");
        }
    }

    #[inline]
    fn encode_local_address(&mut self, address: &SocketAddress) -> Result<usize, Error> {
        use s2n_quic_core::inet::Unspecified;

        match address {
            SocketAddress::IpV4(addr) => {
                use features::pktinfo_v4 as pktinfo;
                if let (Some(level), Some(ty)) = (pktinfo::LEVEL, pktinfo::TYPE) {
                    let ip = addr.ip();

                    if ip.is_unspecified() {
                        return Ok(0);
                    }

                    let value = pktinfo::encode(ip, None);
                    return self.encode_cmsg(level, ty, value);
                }
            }
            SocketAddress::IpV6(addr) => {
                use features::pktinfo_v6 as pktinfo;
                if let (Some(level), Some(ty)) = (pktinfo::LEVEL, pktinfo::TYPE) {
                    let ip = addr.ip();

                    if ip.is_unspecified() {
                        return Ok(0);
                    }

                    let value = pktinfo::encode(ip, None);
                    return self.encode_cmsg(level, ty, value);
                }
            }
        }

        Ok(0)
    }
}