rawsock 0.3.0

Library for receiving and sending raw packets. While most crate wrap just one library, rawsock allows you to use pcap, wpcap, npcap and pf_ring (pfring) using a consistent API for all of them.
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

use time::Timespec;
use std::ops::Deref;
use std::fmt::{Display, Formatter, Error as FmtError, LowerHex};

///Trait for obtained packets - common part between borrowed and owned versions.
pub trait Packet : Deref<Target=[u8]> + Display{
    ///Returns the time when this packet was received.
    fn when(&self) -> Timespec;
}

///Structure representing obtained raw packet - borrowed version.
#[derive(Debug)]
pub struct BorrowedPacket<'a> {
    when_received: Timespec,
    packet: &'a[u8],
    //_marker: PhantomData<&'a mut u32>
}

impl<'a> BorrowedPacket<'a> {
    ///Creates a new Packet instance.
    pub fn new(when_received: Timespec, data: &'a[u8]) -> BorrowedPacket<'a> {
        BorrowedPacket{
            when_received,
            packet: data,
            //_marker: PhantomData
        }
    }
    ///Converts Borrowed packet into owned version.
    pub fn as_owned(&self) -> OwnedPacket {
        OwnedPacket::new(self.packet, self.when_received)
    }
    ///Converts Borrowed packet into owned version.
    pub fn into_owned(self) -> OwnedPacket {
        OwnedPacket::new(self.packet, self.when_received)
    }
}

impl<'a> Deref for BorrowedPacket<'a> {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        self.packet
    }
}

impl<'a> Packet for BorrowedPacket<'a> {

    fn when(&self) -> Timespec {
        self.when_received
    }
}

impl<'a> Display for BorrowedPacket<'a> {
    fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
        for b in self.packet {
            LowerHex::fmt(b, f)?;
        }
        Ok(())
    }
}

///Structure representing obtained raw packet - owned version.
pub struct OwnedPacket {
    when_received: Timespec,
    packet: Vec<u8>
}

impl Packet for OwnedPacket{

    fn when(&self) -> Timespec {
        self.when_received
    }
}

impl Deref for OwnedPacket {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.packet
    }
}

impl Display for OwnedPacket {
    fn fmt(&self, f: &mut Formatter) -> Result<(), FmtError> {
        for b in &self.packet {
            LowerHex::fmt(b, f)?;
        }
        Ok(())
    }
}

impl OwnedPacket {
    ///Creates owned packet from provided data.
    pub fn new (data: &[u8], when: Timespec) -> Self{
        OwnedPacket {
            packet: data.into(),
            when_received: when
        }
    }

    ///Returns its borrowed version.
    pub fn as_borrowed(&self) -> BorrowedPacket {
        BorrowedPacket::new(self.when_received, &self.packet)
    }
}