sciparse 0.5.2

Zero-copy SCION packet parsing, serialization and control plane components
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
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
135
136

// Copyright 2026 Anapaya Systems
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

pub mod encode;
pub mod scmp;
pub mod udp;

/// SCION protocol numbers for payloads.
///
/// See the [IETF SCION-dataplane RFC draft][rfc] for possible values.
///
///[rfc]: https://www.ietf.org/archive/id/draft-dekater-scion-dataplane-00.html#protnum
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum ProtocolNumber {
    /// SCION/TCP next-header protocol number.
    Tcp  = 6,
    /// SCION/UDP next-header protocol number.
    Udp  = 17,
    /// SCION/Hop-by-hop options.
    Hbh  = 43,
    /// SCION End-to-End Options.
    E2e  = 201,
    /// SCION protocol number for SCMP.
    Scmp = 202,
    /// SCION/BFD next-header protocol number.
    Bfd  = 203,
    /// Other, unrecognized protocol numbers.
    Other(u8),
}

impl From<u8> for ProtocolNumber {
    fn from(value: u8) -> Self {
        match value {
            6 => ProtocolNumber::Tcp,
            43 => ProtocolNumber::Hbh,
            201 => ProtocolNumber::E2e,
            17 => ProtocolNumber::Udp,
            202 => ProtocolNumber::Scmp,
            203 => ProtocolNumber::Bfd,
            other => ProtocolNumber::Other(other),
        }
    }
}
impl From<ProtocolNumber> for u8 {
    fn from(value: ProtocolNumber) -> Self {
        match value {
            ProtocolNumber::Tcp => 6,
            ProtocolNumber::Udp => 17,
            ProtocolNumber::Hbh => 43,
            ProtocolNumber::E2e => 201,
            ProtocolNumber::Scmp => 202,
            ProtocolNumber::Bfd => 203,
            ProtocolNumber::Other(other) => other,
        }
    }
}

/// Support for [`proptest::arbitrary`].
#[cfg(feature = "proptest")]
pub mod ptest {
    use ::proptest::prelude::*;

    use super::*;

    /// Configuration for generating arbitrary [`ProtocolNumber`] values.
    ///
    /// Controls the relative probability of each protocol number variant being generated.
    ///
    /// Default weights: all variants = 1.
    #[derive(Debug, Clone)]
    pub struct ArbitraryProtocolNumberParams {
        /// Weight for TCP protocol.
        pub tcp: u32,
        /// Weight for UDP protocol.
        pub udp: u32,
        /// Weight for Hop-by-hop options.
        pub hbh: u32,
        /// Weight for End-to-End options.
        pub e2e: u32,
        /// Weight for SCMP protocol.
        pub scmp: u32,
        /// Weight for BFD protocol.
        pub bfd: u32,
        /// Weight for other (unknown) protocol numbers.
        pub other: u32,
    }
    impl Default for ArbitraryProtocolNumberParams {
        fn default() -> Self {
            Self {
                tcp: 1,
                udp: 1,
                hbh: 1,
                e2e: 1,
                scmp: 1,
                bfd: 1,
                other: 1,
            }
        }
    }

    impl Arbitrary for ProtocolNumber {
        type Parameters = ArbitraryProtocolNumberParams;
        type Strategy = BoxedStrategy<Self>;

        fn arbitrary_with(params: Self::Parameters) -> Self::Strategy {
            prop_oneof![
                params.tcp => Just(ProtocolNumber::Tcp),
                params.udp => Just(ProtocolNumber::Udp),
                params.hbh => Just(ProtocolNumber::Hbh),
                params.e2e => Just(ProtocolNumber::E2e),
                params.scmp => Just(ProtocolNumber::Scmp),
                params.bfd => Just(ProtocolNumber::Bfd),
                params.other => any::<u8>().prop_map(|v| {
                    let mut v = v;
                    while !matches!(ProtocolNumber::from(v), ProtocolNumber::Other(_)) {
                        v = v.wrapping_add(1);
                    }
                    ProtocolNumber::Other(v)
                }),
            ]
            .boxed()
        }
    }
}