etherparse 0.20.0

A library for parsing & writing a bunch of packet based protocols (EthernetII, IPv4, IPv6, UDP, TCP ...).
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

use crate::err::{ipv4_exts, ipv6_exts, ValueTooBigError};
use core::convert::Infallible;

/// Error while serializing a packet into a [`alloc::vec::Vec`].
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub enum BuildVecWriteError {
    /// Error if the length of the payload is too
    /// big to be representable by the length fields.
    PayloadLen(ValueTooBigError<usize>),

    /// Error if the IPv4 extensions can not be serialized
    /// because of internal consistency errors.
    Ipv4Exts(ipv4_exts::ExtsWalkError),

    /// Error if the IPv6 extensions can not be serialized
    /// because of internal consistency errors.
    Ipv6Exts(ipv6_exts::ExtsWalkError),

    /// Error if ICMPv6 is packaged in an IPv4 packet (it is undefined
    /// how to calculate the checksum).
    Icmpv6InIpv4,

    /// Address size defined in the ARP header does not match the actual size.
    ArpHeaderNotMatch,
}

impl From<Infallible> for BuildVecWriteError {
    fn from(value: Infallible) -> Self {
        match value {}
    }
}

impl From<ValueTooBigError<usize>> for BuildVecWriteError {
    fn from(value: ValueTooBigError<usize>) -> Self {
        BuildVecWriteError::PayloadLen(value)
    }
}

impl From<super::TransportChecksumError> for BuildVecWriteError {
    fn from(value: super::TransportChecksumError) -> Self {
        match value {
            super::TransportChecksumError::PayloadLen(err) => BuildVecWriteError::PayloadLen(err),
            super::TransportChecksumError::Icmpv6InIpv4 => BuildVecWriteError::Icmpv6InIpv4,
        }
    }
}

impl From<crate::WriteError<Infallible, ipv4_exts::ExtsWalkError>> for BuildVecWriteError {
    fn from(value: crate::WriteError<Infallible, ipv4_exts::ExtsWalkError>) -> Self {
        match value {
            crate::WriteError::Io(err) => match err {},
            crate::WriteError::Content(err) => BuildVecWriteError::Ipv4Exts(err),
        }
    }
}

impl From<crate::WriteError<Infallible, ipv6_exts::ExtsWalkError>> for BuildVecWriteError {
    fn from(value: crate::WriteError<Infallible, ipv6_exts::ExtsWalkError>) -> Self {
        match value {
            crate::WriteError::Io(err) => match err {},
            crate::WriteError::Content(err) => BuildVecWriteError::Ipv6Exts(err),
        }
    }
}

impl core::fmt::Display for BuildVecWriteError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        use BuildVecWriteError::*;
        match self {
            PayloadLen(err) => err.fmt(f),
            Ipv4Exts(err) => err.fmt(f),
            Ipv6Exts(err) => err.fmt(f),
            ArpHeaderNotMatch => write!(
                f,
                "address size defined in the ARP header does not match the actual size"
            ),
            Icmpv6InIpv4 => write!(
                f,
                "Error: ICMPv6 can not be combined with an IPv4 headers (checksum can not be calculated)."
            ),
        }
    }
}

impl core::error::Error for BuildVecWriteError {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        use BuildVecWriteError::*;
        match self {
            PayloadLen(err) => Some(err),
            Ipv4Exts(err) => Some(err),
            Ipv6Exts(err) => Some(err),
            Icmpv6InIpv4 => None,
            ArpHeaderNotMatch => None,
        }
    }
}