parse-tcp 0.1.0

tcp reassembler
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
106
107
108
109
110
111
112
113
114
115
116
117

use std::net::IpAddr;

use serde::{Serialize, Deserialize};
use uuid::Uuid;

use crate::flow_table::Flow;
use crate::stream::{SegmentInfo, SegmentType};

/// extra information that may be associated with the packet
#[derive(Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PacketExtra {
    None,
    LegacyPcap {
        /// packet number
        index: u64,
        /// timestamp (seconds)
        ts_sec: u32,
        /// timestamp (microseconds)
        ts_usec: u32,
    },
}

#[derive(Serialize, Deserialize)]
pub struct ConnInfo {
    pub id: Uuid,
    pub src_addr: IpAddr,
    pub src_port: u16,
    pub dst_addr: IpAddr,
    pub dst_port: u16,
}

impl ConnInfo {
    pub fn new(uuid: Uuid, flow: &Flow) -> Self {
        ConnInfo {
            id: uuid,
            src_addr: flow.src_addr,
            src_port: flow.src_port,
            dst_addr: flow.dst_addr,
            dst_port: flow.dst_port,
        }
    }
}

#[derive(Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SerializedSegment {
    #[serde(rename = "data")]
    Data {
        offset: u64,
        len: usize,
        is_retransmit: bool,
        reverse_acked: u64,
        #[serde(flatten)]
        extra: PacketExtra,
    },
    #[serde(rename = "ack")]
    Ack {
        offset: u64,
        window: usize,
        reverse_acked: u64,
        #[serde(flatten)]
        extra: PacketExtra,
    },
    #[serde(rename = "fin")]
    Fin {
        offset: u64,
        reverse_acked: u64,
        #[serde(flatten)]
        extra: PacketExtra,
    },
    #[serde(rename = "rst")]
    Rst {
        offset: u64,
        reverse_acked: u64,
        #[serde(flatten)]
        extra: PacketExtra,
    },
    #[serde(rename = "gap")]
    Gap { offset: u64, len: u64 },
}

impl SerializedSegment {
    pub fn new_gap(offset: u64, len: u64) -> Self {
        Self::Gap { offset, len }
    }
}

impl From<&SegmentInfo> for SerializedSegment {
    fn from(info: &SegmentInfo) -> Self {
        match info.data {
            SegmentType::Data { len, is_retransmit } => Self::Data {
                offset: info.offset,
                len,
                is_retransmit,
                reverse_acked: info.reverse_acked,
                extra: info.extra.clone(),
            },
            SegmentType::Ack { window } => Self::Ack {
                offset: info.offset,
                window,
                reverse_acked: info.reverse_acked,
                extra: info.extra.clone(),
            },
            SegmentType::Fin { end_offset } => Self::Fin {
                offset: end_offset,
                reverse_acked: info.reverse_acked,
                extra: info.extra.clone(),
            },
            SegmentType::Rst => Self::Rst {
                offset: info.offset,
                reverse_acked: info.reverse_acked,
                extra: info.extra.clone(),
            },
        }
    }
}