use crate::err::*;
#[derive(Debug)]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub enum ReadError {
Io(std::io::Error),
Len(LenError),
DoubleVlan(double_vlan::HeaderError),
Ip(ip::HeaderError),
IpAuth(ip_auth::HeaderError),
Ipv4(ipv4::HeaderError),
Ipv6(ipv6::HeaderError),
Ipv6Exts(ipv6_exts::HeaderError),
LinuxSll(linux_sll::HeaderError),
Tcp(tcp::HeaderError),
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl ReadError {
pub fn io(&self) -> Option<&std::io::Error> {
match self {
ReadError::Io(err) => Some(err),
_ => None,
}
}
pub fn len(&self) -> Option<&LenError> {
match self {
ReadError::Len(err) => Some(err),
_ => None,
}
}
pub fn double_vlan(&self) -> Option<&double_vlan::HeaderError> {
match self {
ReadError::DoubleVlan(err) => Some(err),
_ => None,
}
}
pub fn ip(&self) -> Option<&ip::HeaderError> {
match self {
ReadError::Ip(err) => Some(err),
_ => None,
}
}
pub fn ip_auth(&self) -> Option<&ip_auth::HeaderError> {
match self {
ReadError::IpAuth(err) => Some(err),
_ => None,
}
}
pub fn ipv4(&self) -> Option<&ipv4::HeaderError> {
match self {
ReadError::Ipv4(err) => Some(err),
_ => None,
}
}
pub fn ipv6(&self) -> Option<&ipv6::HeaderError> {
match self {
ReadError::Ipv6(err) => Some(err),
_ => None,
}
}
pub fn ipv6_exts(&self) -> Option<&ipv6_exts::HeaderError> {
match self {
ReadError::Ipv6Exts(err) => Some(err),
_ => None,
}
}
pub fn linux_sll(&self) -> Option<&linux_sll::HeaderError> {
match self {
ReadError::LinuxSll(err) => Some(err),
_ => None,
}
}
pub fn tcp(&self) -> Option<&tcp::HeaderError> {
match self {
ReadError::Tcp(err) => Some(err),
_ => None,
}
}
}
impl core::fmt::Display for ReadError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
use crate::err::ReadError::*;
match self {
Io(err) => err.fmt(f),
Len(err) => err.fmt(f),
DoubleVlan(err) => err.fmt(f),
Ip(err) => err.fmt(f),
IpAuth(err) => err.fmt(f),
Ipv4(err) => err.fmt(f),
Ipv6(err) => err.fmt(f),
Ipv6Exts(err) => err.fmt(f),
LinuxSll(err) => err.fmt(f),
Tcp(err) => err.fmt(f),
}
}
}
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl std::error::Error for ReadError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
ReadError::Io(err) => Some(err),
ReadError::Len(err) => Some(err),
ReadError::DoubleVlan(err) => Some(err),
ReadError::Ip(err) => Some(err),
ReadError::IpAuth(err) => Some(err),
ReadError::Ipv4(err) => Some(err),
ReadError::Ipv6(err) => Some(err),
ReadError::Ipv6Exts(err) => Some(err),
ReadError::LinuxSll(err) => Some(err),
ReadError::Tcp(err) => Some(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<std::io::Error> for ReadError {
fn from(value: std::io::Error) -> Self {
ReadError::Io(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<LenError> for ReadError {
fn from(value: LenError) -> Self {
ReadError::Len(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<double_vlan::HeaderError> for ReadError {
fn from(value: double_vlan::HeaderError) -> Self {
ReadError::DoubleVlan(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<double_vlan::HeaderReadError> for ReadError {
fn from(value: double_vlan::HeaderReadError) -> Self {
use double_vlan::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::DoubleVlan(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<double_vlan::HeaderSliceError> for ReadError {
fn from(value: double_vlan::HeaderSliceError) -> Self {
use double_vlan::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::DoubleVlan(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip::HeaderError> for ReadError {
fn from(value: ip::HeaderError) -> Self {
ReadError::Ip(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip::HeadersError> for ReadError {
fn from(value: ip::HeadersError) -> Self {
match value {
ip::HeadersError::Ip(err) => ReadError::Ip(err),
ip::HeadersError::Ipv4Ext(err) => ReadError::IpAuth(err),
ip::HeadersError::Ipv6Ext(err) => ReadError::Ipv6Exts(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip::HeaderReadError> for ReadError {
fn from(value: ip::HeaderReadError) -> Self {
use ip::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Len(err) => ReadError::Len(err),
Content(err) => err.into(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip::HeadersSliceError> for ReadError {
fn from(value: ip::HeadersSliceError) -> Self {
use ip::HeadersSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => err.into(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip::SliceError> for ReadError {
fn from(value: ip::SliceError) -> Self {
use ip::SliceError::*;
match value {
Len(err) => ReadError::Len(err),
IpHeaders(err) => err.into(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip_auth::HeaderError> for ReadError {
fn from(value: ip_auth::HeaderError) -> Self {
ReadError::IpAuth(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip_auth::HeaderReadError> for ReadError {
fn from(value: ip_auth::HeaderReadError) -> Self {
use ip_auth::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::IpAuth(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ip_auth::HeaderSliceError> for ReadError {
fn from(value: ip_auth::HeaderSliceError) -> Self {
use ip_auth::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::IpAuth(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv4::HeaderError> for ReadError {
fn from(value: ipv4::HeaderError) -> Self {
ReadError::Ipv4(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv4::HeaderReadError> for ReadError {
fn from(value: ipv4::HeaderReadError) -> Self {
use ipv4::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::Ipv4(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv4::HeaderSliceError> for ReadError {
fn from(value: ipv4::HeaderSliceError) -> Self {
use ipv4::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::Ipv4(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv4::SliceError> for ReadError {
fn from(value: ipv4::SliceError) -> Self {
use ipv4::SliceError::*;
match value {
Len(err) => ReadError::Len(err),
Header(err) => ReadError::Ipv4(err),
Exts(err) => ReadError::IpAuth(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6::HeaderError> for ReadError {
fn from(value: ipv6::HeaderError) -> Self {
ReadError::Ipv6(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6::HeaderReadError> for ReadError {
fn from(value: ipv6::HeaderReadError) -> Self {
use ipv6::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::Ipv6(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6::HeaderSliceError> for ReadError {
fn from(value: ipv6::HeaderSliceError) -> Self {
use ipv6::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::Ipv6(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6::SliceError> for ReadError {
fn from(value: ipv6::SliceError) -> Self {
use ipv6::SliceError::*;
match value {
Len(err) => ReadError::Len(err),
Header(err) => ReadError::Ipv6(err),
Exts(err) => ReadError::Ipv6Exts(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6_exts::HeaderError> for ReadError {
fn from(value: ipv6_exts::HeaderError) -> Self {
ReadError::Ipv6Exts(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6_exts::HeaderReadError> for ReadError {
fn from(value: ipv6_exts::HeaderReadError) -> Self {
use ipv6_exts::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::Ipv6Exts(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<ipv6_exts::HeaderSliceError> for ReadError {
fn from(value: ipv6_exts::HeaderSliceError) -> Self {
use ipv6_exts::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::Ipv6Exts(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<linux_sll::HeaderError> for ReadError {
fn from(value: linux_sll::HeaderError) -> Self {
ReadError::LinuxSll(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<linux_sll::HeaderReadError> for ReadError {
fn from(value: linux_sll::HeaderReadError) -> Self {
use linux_sll::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::LinuxSll(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<linux_sll::HeaderSliceError> for ReadError {
fn from(value: linux_sll::HeaderSliceError) -> Self {
use linux_sll::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::LinuxSll(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<packet::SliceError> for ReadError {
fn from(value: packet::SliceError) -> Self {
use packet::SliceError::*;
match value {
Len(err) => ReadError::Len(err),
LinuxSll(err) => ReadError::LinuxSll(err),
Ip(err) => ReadError::Ip(err),
Ipv4(err) => ReadError::Ipv4(err),
Ipv6(err) => ReadError::Ipv6(err),
Ipv4Exts(err) => ReadError::IpAuth(err),
Ipv6Exts(err) => ReadError::Ipv6Exts(err),
Tcp(err) => ReadError::Tcp(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<tcp::HeaderError> for ReadError {
fn from(value: tcp::HeaderError) -> Self {
ReadError::Tcp(value)
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<tcp::HeaderReadError> for ReadError {
fn from(value: tcp::HeaderReadError) -> Self {
use tcp::HeaderReadError::*;
match value {
Io(err) => ReadError::Io(err),
Content(err) => ReadError::Tcp(err),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl From<tcp::HeaderSliceError> for ReadError {
fn from(value: tcp::HeaderSliceError) -> Self {
use tcp::HeaderSliceError::*;
match value {
Len(err) => ReadError::Len(err),
Content(err) => ReadError::Tcp(err),
}
}
}
#[cfg(test)]
mod tests {
use crate::{
err::{ReadError::*, *},
LenSource,
};
use crate::{ArpHardwareId, EtherType};
use std::error::Error;
use std::format;
#[test]
fn debug_source() {
let test_values: [(&str, ReadError); 10] = [
(
"Len",
Len(LenError {
required_len: 0,
len: 0,
len_source: LenSource::Slice,
layer: Layer::Icmpv4,
layer_start_offset: 0,
}),
),
(
"LinuxSll",
LinuxSll(linux_sll::HeaderError::UnsupportedArpHardwareId {
arp_hardware_type: ArpHardwareId::ETHER,
}),
),
(
"DoubleVlan",
DoubleVlan(double_vlan::HeaderError::NonVlanEtherType {
unexpected_ether_type: EtherType(123),
}),
),
(
"Ip",
Ip(ip::HeaderError::UnsupportedIpVersion {
version_number: 123,
}),
),
("IpAuth", IpAuth(ip_auth::HeaderError::ZeroPayloadLen)),
(
"Ipv4",
Ipv4(ipv4::HeaderError::UnexpectedVersion { version_number: 1 }),
),
(
"Ipv6",
Ipv6(ipv6::HeaderError::UnexpectedVersion { version_number: 1 }),
),
(
"Ipv6Exts",
Ipv6Exts(ipv6_exts::HeaderError::HopByHopNotAtStart),
),
(
"LinuxSll",
LinuxSll(linux_sll::HeaderError::UnsupportedPacketTypeField { packet_type: 123 }),
),
(
"Tcp",
Tcp(tcp::HeaderError::DataOffsetTooSmall { data_offset: 1 }),
),
];
for (prefix, value) in &test_values {
assert_eq!(
format!("{:?}", value),
format!("{}({:?})", prefix, value.source().unwrap())
);
}
{
let io_error = || std::io::Error::new(std::io::ErrorKind::Other, "some error");
assert_eq!(
format!("Io({:?})", io_error()),
format!("{:?}", Io(io_error()))
);
}
}
#[test]
fn display_source() {
let test_values: [ReadError; 10] = [
Len(LenError {
required_len: 0,
len: 0,
len_source: LenSource::Slice,
layer: Layer::Icmpv4,
layer_start_offset: 0,
}),
LinuxSll(linux_sll::HeaderError::UnsupportedArpHardwareId {
arp_hardware_type: ArpHardwareId::ETHER,
}),
DoubleVlan(double_vlan::HeaderError::NonVlanEtherType {
unexpected_ether_type: EtherType(123),
}),
Ip(ip::HeaderError::UnsupportedIpVersion {
version_number: 123,
}),
IpAuth(ip_auth::HeaderError::ZeroPayloadLen),
Ipv4(ipv4::HeaderError::UnexpectedVersion { version_number: 1 }),
Ipv6(ipv6::HeaderError::UnexpectedVersion { version_number: 1 }),
Ipv6Exts(ipv6_exts::HeaderError::HopByHopNotAtStart),
LinuxSll(linux_sll::HeaderError::UnsupportedPacketTypeField { packet_type: 123 }),
Tcp(tcp::HeaderError::DataOffsetTooSmall { data_offset: 1 }),
];
for value in &test_values {
assert_eq!(format!("{}", value), format!("{}", value.source().unwrap()));
}
{
let io_error = || std::io::Error::new(std::io::ErrorKind::Other, "some error");
assert_eq!(format!("{}", io_error()), format!("{}", Io(io_error())));
assert!(Io(io_error()).source().is_some());
}
}
#[test]
fn accessors() {
use ReadError::*;
let io_error = || std::io::Error::new(std::io::ErrorKind::Other, "some error");
let len_error = || LenError {
required_len: 0,
len: 0,
len_source: LenSource::Slice,
layer: Layer::Icmpv4,
layer_start_offset: 0,
};
let double_vlan_error = || double_vlan::HeaderError::NonVlanEtherType {
unexpected_ether_type: EtherType(1),
};
let ip_error = || ip::HeaderError::UnsupportedIpVersion { version_number: 0 };
let ipv4_error = || ipv4::HeaderError::UnexpectedVersion { version_number: 1 };
let ipv6_error = || ipv6::HeaderError::UnexpectedVersion { version_number: 1 };
let ip_auth_error = || ip_auth::HeaderError::ZeroPayloadLen;
let ipv6_exts_error = || ipv6_exts::HeaderError::HopByHopNotAtStart;
let linux_sll_error =
|| linux_sll::HeaderError::UnsupportedPacketTypeField { packet_type: 123 };
let tcp_error = || tcp::HeaderError::DataOffsetTooSmall { data_offset: 1 };
assert!(Io(io_error()).io().is_some());
assert!(Ipv4(ipv4_error()).io().is_none());
assert_eq!(Len(len_error()).len(), Some(&len_error()));
assert_eq!(Ipv4(ipv4_error()).len(), None);
assert_eq!(
LinuxSll(linux_sll_error()).linux_sll(),
Some(&linux_sll_error())
);
assert_eq!(Ipv4(ipv4_error()).linux_sll(), None);
assert_eq!(
DoubleVlan(double_vlan_error()).double_vlan(),
Some(&double_vlan_error())
);
assert_eq!(Ipv4(ipv4_error()).double_vlan(), None);
assert_eq!(Ip(ip_error()).ip(), Some(&ip_error()));
assert_eq!(Ipv4(ipv4_error()).ip(), None);
assert_eq!(IpAuth(ip_auth_error()).ip_auth(), Some(&ip_auth_error()));
assert_eq!(Ipv4(ipv4_error()).ip_auth(), None);
assert_eq!(Ipv4(ipv4_error()).ipv4(), Some(&ipv4_error()));
assert_eq!(IpAuth(ip_auth_error()).ipv4(), None);
assert_eq!(Ipv6(ipv6_error()).ipv6(), Some(&ipv6_error()));
assert_eq!(IpAuth(ip_auth_error()).ipv6(), None);
assert_eq!(
Ipv6Exts(ipv6_exts_error()).ipv6_exts(),
Some(&ipv6_exts_error())
);
assert_eq!(IpAuth(ip_auth_error()).ipv6_exts(), None);
assert_eq!(
LinuxSll(linux_sll_error()).linux_sll(),
Some(&linux_sll_error())
);
assert_eq!(IpAuth(ip_auth_error()).linux_sll(), None);
assert_eq!(Tcp(tcp_error()).tcp(), Some(&tcp_error()));
assert_eq!(IpAuth(ip_auth_error()).tcp(), None);
}
#[test]
fn from() {
let io_error =
|| -> std::io::Error { std::io::Error::new(std::io::ErrorKind::Other, "some error") };
let len_error = || -> LenError {
LenError {
required_len: 0,
len: 0,
len_source: LenSource::Slice,
layer: Layer::Icmpv4,
layer_start_offset: 0,
}
};
assert!(ReadError::from(io_error()).io().is_some());
assert_eq!(&len_error(), ReadError::from(len_error()).len().unwrap());
{
let header_error = || linux_sll::HeaderError::UnsupportedArpHardwareId {
arp_hardware_type: ArpHardwareId::ETHER,
};
assert_eq!(
&header_error(),
ReadError::from(header_error()).linux_sll().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(linux_sll::HeaderReadError::Content(header_error()))
.linux_sll()
.unwrap()
);
assert!(ReadError::from(linux_sll::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(linux_sll::HeaderSliceError::Content(header_error()))
.linux_sll()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(linux_sll::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(linux_sll::HeaderSliceError::Content(header_error()))
.linux_sll()
.unwrap()
);
}
{
let header_error = || double_vlan::HeaderError::NonVlanEtherType {
unexpected_ether_type: EtherType(123),
};
assert_eq!(
&header_error(),
ReadError::from(header_error()).double_vlan().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(double_vlan::HeaderReadError::Content(header_error()))
.double_vlan()
.unwrap()
);
assert!(
ReadError::from(double_vlan::HeaderReadError::Io(io_error()))
.io()
.is_some()
);
assert_eq!(
&header_error(),
ReadError::from(double_vlan::HeaderSliceError::Content(header_error()))
.double_vlan()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(double_vlan::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(double_vlan::HeaderSliceError::Content(header_error()))
.double_vlan()
.unwrap()
);
}
{
let header_error = || ip::HeaderError::UnsupportedIpVersion {
version_number: 123,
};
assert_eq!(
&header_error(),
ReadError::from(header_error()).ip().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ip::HeaderReadError::Content(ip::HeadersError::Ip(
header_error()
)))
.ip()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ip::HeaderReadError::Len(len_error()))
.len()
.unwrap()
);
assert!(ReadError::from(ip::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(ip::HeadersSliceError::Content(ip::HeadersError::Ip(
header_error()
)))
.ip()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ip::HeadersSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ip::HeadersSliceError::Content(ip::HeadersError::Ip(
header_error()
)))
.ip()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ip::SliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ip::SliceError::IpHeaders(ip::HeadersError::Ip(
header_error()
)))
.ip()
.unwrap()
);
}
{
let header_error = || ip_auth::HeaderError::ZeroPayloadLen;
assert_eq!(
&header_error(),
ReadError::from(header_error()).ip_auth().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ip_auth::HeaderReadError::Content(header_error()))
.ip_auth()
.unwrap()
);
assert!(ReadError::from(ip_auth::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(ip_auth::HeaderSliceError::Content(header_error()))
.ip_auth()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ip_auth::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ip_auth::HeaderSliceError::Content(header_error()))
.ip_auth()
.unwrap()
);
}
{
let header_error = || ipv4::HeaderError::UnexpectedVersion {
version_number: 123,
};
let exts_error = || ip_auth::HeaderError::ZeroPayloadLen;
assert_eq!(
&header_error(),
ReadError::from(header_error()).ipv4().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv4::HeaderReadError::Content(header_error()))
.ipv4()
.unwrap()
);
assert!(ReadError::from(ipv4::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(ipv4::HeaderSliceError::Content(header_error()))
.ipv4()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ipv4::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv4::HeaderSliceError::Content(header_error()))
.ipv4()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ipv4::SliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv4::SliceError::Header(header_error()))
.ipv4()
.unwrap()
);
assert_eq!(
&exts_error(),
ReadError::from(ipv4::SliceError::Exts(exts_error()))
.ip_auth()
.unwrap()
);
}
{
let header_error = || ipv6::HeaderError::UnexpectedVersion {
version_number: 123,
};
let exts_error = || ipv6_exts::HeaderError::HopByHopNotAtStart;
assert_eq!(
&header_error(),
ReadError::from(header_error()).ipv6().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv6::HeaderReadError::Content(header_error()))
.ipv6()
.unwrap()
);
assert!(ReadError::from(ipv6::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(ipv6::HeaderSliceError::Content(header_error()))
.ipv6()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ipv6::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv6::HeaderSliceError::Content(header_error()))
.ipv6()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ipv6::SliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv6::SliceError::Header(header_error()))
.ipv6()
.unwrap()
);
assert_eq!(
&exts_error(),
ReadError::from(ipv6::SliceError::Exts(exts_error()))
.ipv6_exts()
.unwrap()
);
}
{
let header_error = || ipv6_exts::HeaderError::HopByHopNotAtStart;
assert_eq!(
&header_error(),
ReadError::from(header_error()).ipv6_exts().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv6_exts::HeaderReadError::Content(header_error()))
.ipv6_exts()
.unwrap()
);
assert!(ReadError::from(ipv6_exts::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(ipv6_exts::HeaderSliceError::Content(header_error()))
.ipv6_exts()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(ipv6_exts::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(ipv6_exts::HeaderSliceError::Content(header_error()))
.ipv6_exts()
.unwrap()
);
}
{
let header_error =
|| linux_sll::HeaderError::UnsupportedPacketTypeField { packet_type: 123 };
assert_eq!(
&header_error(),
ReadError::from(header_error()).linux_sll().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(linux_sll::HeaderReadError::Content(header_error()))
.linux_sll()
.unwrap()
);
assert!(ReadError::from(linux_sll::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(linux_sll::HeaderSliceError::Content(header_error()))
.linux_sll()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(linux_sll::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(linux_sll::HeaderSliceError::Content(header_error()))
.linux_sll()
.unwrap()
);
}
{
let ip_error = || ip::HeaderError::UnsupportedIpVersion { version_number: 0 };
let ipv4_error = || ipv4::HeaderError::UnexpectedVersion { version_number: 1 };
let ipv6_error = || ipv6::HeaderError::UnexpectedVersion { version_number: 1 };
let ip_auth_error = || ip_auth::HeaderError::ZeroPayloadLen;
let ipv6_exts_error = || ipv6_exts::HeaderError::HopByHopNotAtStart;
let tcp_error = || tcp::HeaderError::DataOffsetTooSmall { data_offset: 1 };
assert_eq!(
&len_error(),
ReadError::from(packet::SliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&ip_error(),
ReadError::from(packet::SliceError::Ip(ip_error()))
.ip()
.unwrap()
);
assert_eq!(
&ipv4_error(),
ReadError::from(packet::SliceError::Ipv4(ipv4_error()))
.ipv4()
.unwrap()
);
assert_eq!(
&ipv6_error(),
ReadError::from(packet::SliceError::Ipv6(ipv6_error()))
.ipv6()
.unwrap()
);
assert_eq!(
&ip_auth_error(),
ReadError::from(packet::SliceError::Ipv4Exts(ip_auth_error()))
.ip_auth()
.unwrap()
);
assert_eq!(
&ipv6_exts_error(),
ReadError::from(packet::SliceError::Ipv6Exts(ipv6_exts_error()))
.ipv6_exts()
.unwrap()
);
assert_eq!(
&tcp_error(),
ReadError::from(packet::SliceError::Tcp(tcp_error()))
.tcp()
.unwrap()
);
}
{
let header_error = || tcp::HeaderError::DataOffsetTooSmall { data_offset: 1 };
assert_eq!(
&header_error(),
ReadError::from(header_error()).tcp().unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(tcp::HeaderReadError::Content(header_error()))
.tcp()
.unwrap()
);
assert!(ReadError::from(tcp::HeaderReadError::Io(io_error()))
.io()
.is_some());
assert_eq!(
&header_error(),
ReadError::from(tcp::HeaderSliceError::Content(header_error()))
.tcp()
.unwrap()
);
assert_eq!(
&len_error(),
ReadError::from(tcp::HeaderSliceError::Len(len_error()))
.len()
.unwrap()
);
assert_eq!(
&header_error(),
ReadError::from(tcp::HeaderSliceError::Content(header_error()))
.tcp()
.unwrap()
);
}
}
}