p2sh 0.4.3

The p2sh Programming language interpreter
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use std::fmt;

/// Packet object property type
/// To be kept in sync with 'PACKET_PROP_MAP'
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum PacketPropType {
    Magic,
    Major,
    Minor,
    ThisZone,
    SigFigs,
    Snaplen,
    LinkType,
    Sec,
    USec,
    Caplen,
    Wirelen,
    Payload,
    Eth,
    Src,
    Dst,
    EtherType,
    Vlan,
    Id,
    Priority,
    Dei,
    Ipv4,
    Version,
    Ihl,
    TotalLength,
    Dscp,
    Ecn,
    Flags,
    FragmentOffset,
    Ttl,
    Protocol,
    Checksum,
    Udp,
    SrcPort,
    DstPort,
    Length,
    Tcp,
    Sequence,
    Ack,
    DataOffset,
    WindowSize,
    Urgent,
    Ipv6,
    TrafficClass,
    FlowLabel,
    NextHeader,
    HopLimit,
    #[default]
    Invalid,
}

impl From<u8> for PacketPropType {
    fn from(code: u8) -> Self {
        match code {
            0 => Self::Magic,
            1 => Self::Major,
            2 => Self::Minor,
            3 => Self::ThisZone,
            4 => Self::SigFigs,
            5 => Self::Snaplen,
            6 => Self::LinkType,
            7 => Self::Sec,
            8 => Self::USec,
            9 => Self::Caplen,
            10 => Self::Wirelen,
            11 => Self::Payload,
            12 => Self::Eth,
            13 => Self::Src,
            14 => Self::Dst,
            15 => Self::EtherType,
            16 => Self::Vlan,
            17 => Self::Id,
            18 => Self::Priority,
            19 => Self::Dei,
            20 => Self::Ipv4,
            21 => Self::Version,
            22 => Self::Ihl,
            23 => Self::TotalLength,
            24 => Self::Dscp,
            25 => Self::Ecn,
            26 => Self::Flags,
            27 => Self::FragmentOffset,
            28 => Self::Ttl,
            29 => Self::Protocol,
            30 => Self::Checksum,
            31 => Self::Udp,
            32 => Self::SrcPort,
            33 => Self::DstPort,
            34 => Self::Length,
            35 => Self::Tcp,
            36 => Self::Sequence,
            37 => Self::Ack,
            38 => Self::DataOffset,
            39 => Self::WindowSize,
            40 => Self::Urgent,
            41 => Self::Ipv6,
            42 => Self::TrafficClass,
            43 => Self::FlowLabel,
            44 => Self::NextHeader,
            45 => Self::HopLimit,
            _ => Self::Invalid,
        }
    }
}

impl From<PacketPropType> for u8 {
    fn from(code: PacketPropType) -> Self {
        code as u8
    }
}

impl fmt::Display for PacketPropType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let string_representation = match self {
            PacketPropType::Magic => "magic",
            PacketPropType::Major => "major",
            PacketPropType::Minor => "minor",
            PacketPropType::ThisZone => "thiszone",
            PacketPropType::SigFigs => "sigfigs",
            PacketPropType::Snaplen => "snaplen",
            PacketPropType::LinkType => "linktype",
            PacketPropType::Sec => "sec",
            PacketPropType::USec => "usec",
            PacketPropType::Caplen => "caplen",
            PacketPropType::Wirelen => "wirelen",
            PacketPropType::Payload => "payload",
            PacketPropType::Eth => "eth",
            PacketPropType::Src => "src",
            PacketPropType::Dst => "dst",
            PacketPropType::EtherType => "type",
            PacketPropType::Vlan => "vlan",
            PacketPropType::Id => "id",
            PacketPropType::Priority => "priority",
            PacketPropType::Dei => "dei",
            PacketPropType::Ipv4 => "ipv4",
            PacketPropType::Version => "version",
            PacketPropType::Ihl => "ihl",
            PacketPropType::TotalLength => "totlen",
            PacketPropType::Dscp => "dscp",
            PacketPropType::Ecn => "ecn",
            PacketPropType::Flags => "flags",
            PacketPropType::FragmentOffset => "fragoff",
            PacketPropType::Ttl => "ttl",
            PacketPropType::Protocol => "proto",
            PacketPropType::Checksum => "checksum",
            PacketPropType::Udp => "udp",
            PacketPropType::SrcPort => "srcport",
            PacketPropType::DstPort => "dstport",
            PacketPropType::Length => "len",
            PacketPropType::Tcp => "tcp",
            PacketPropType::Sequence => "seq",
            PacketPropType::Ack => "ack",
            PacketPropType::DataOffset => "dataoff",
            PacketPropType::WindowSize => "winsize",
            PacketPropType::Urgent => "urgent",
            PacketPropType::Ipv6 => "ipv6",
            PacketPropType::TrafficClass => "trafficclass",
            PacketPropType::FlowLabel => "flowlabel",
            PacketPropType::NextHeader => "nextheader",
            PacketPropType::HopLimit => "hoplimit",
            PacketPropType::Invalid => "invalid",
        };
        write!(f, "{}", string_representation)
    }
}