ezpkt 0.4.0

A packet construction library
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

use std::cmp::min;

use pkt::eth::{eth_hdr, ethertype};
use pkt::ipv4::ip_hdr;
use pkt::{Hdr, Packet};

const IPH_LEN: usize = std::mem::size_of::<ip_hdr>();
const IP_DGRAM_OVERHEAD: usize = std::mem::size_of::<eth_hdr>() + IPH_LEN;

/// Helper for creating IP datagrams
pub struct IpDgram {
    pkt: Packet,
    ip: Hdr<ip_hdr>,
}

impl IpDgram {
    #[must_use]
    pub fn new(mut iph: ip_hdr, payload: &[u8], raw: bool) -> Self {
        let pkt = Packet::with_capacity(IP_DGRAM_OVERHEAD + payload.len());

        if !raw {
            pkt.push(eth_hdr::new(
                iph.get_saddr().into(),
                iph.get_saddr().into(),
                ethertype::IPV4,
            ));
        }

        iph.set_tot_len(payload.len() as u16 + IPH_LEN as u16);

        let ip = pkt.push(iph);

        pkt.push_bytes(payload);

        Self { pkt, ip }
    }

    #[must_use]
    pub fn frag(self, frag_off: u16, mf: bool) -> Self {
        {
            let mut iph = self.ip.get_mut(&self.pkt);

            iph.set_frag_off(frag_off).set_mf(mf).calc_csum();
        }

        self
    }
}

impl From<IpDgram> for Packet {
    fn from(seg: IpDgram) -> Self {
        seg.pkt
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct IpFrag {
    hdr: ip_hdr,
    payload: Vec<u8>,
}

impl IpFrag {
    pub fn new(hdr: ip_hdr, payload: Vec<u8>) -> Self {
        //println!("trace: udp:flow({:?}, {:?})", cl, sv);
        Self { hdr, payload }
    }

    /// Offset is in 8-byte blocks, len is in bytes
    pub fn fragment(&self, off: u16, len: u16, raw: bool) -> Packet {
        let byte_off = (off as usize) << 3;
        let byte_len = (len as usize) << 3;
        let byte_end = byte_off + byte_len;
        let end = min(byte_end, self.payload.len());
        let content = &self.payload[byte_off..end];

        IpDgram::new(self.hdr, content, raw)
            .frag(off, end != self.payload.len())
            .into()
    }

    /// Offset is in 8-byte blocks, include all bytes until the end
    pub fn tail(&self, off: u16, raw: bool) -> Packet {
        self.fragment(off, self.payload.len() as u16, raw)
    }

    /// The whole payload in one unfragmented datagram
    pub fn datagram(&self, raw: bool) -> Packet {
        IpDgram::new(self.hdr, &self.payload[..], raw)
            .frag(0, false)
            .into()
    }
}