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
use std::io::Read;
use byteorder::{BigEndian, LittleEndian};
use crate::errors::PcapError;
use crate::pcapng::blocks::{Block, ParsedBlock, EnhancedPacketBlock, InterfaceDescriptionBlock};
use crate::Endianness;
use crate::peek_reader::PeekReader;
pub struct PcapNgReader<R: Read> {
reader: PeekReader<R>,
section: Block<'static>,
interfaces: Vec<Block<'static>>
}
impl<R: Read> PcapNgReader<R> {
pub fn new(mut reader: R) -> Result<PcapNgReader<R>, PcapError> {
let section = Block::from_reader::<_, BigEndian>(&mut reader)?;
match section.parsed {
ParsedBlock::SectionHeader(_) => {},
_ => return Err(PcapError::InvalidField("SectionHeader missing"))
}
Ok(
PcapNgReader {
reader: PeekReader::new(reader),
section,
interfaces: vec![]
}
)
}
pub fn section(&self) -> &Block<'static> {
&self.section
}
pub fn interfaces(&self) -> &[Block] {
&self.interfaces[..]
}
pub fn packet_interface(&self, packet: &EnhancedPacketBlock) -> Option<&InterfaceDescriptionBlock> {
self.interfaces.get(packet.interface_id as usize).map(|block| block.interface_description().unwrap())
}
}
impl<R: Read> Iterator for PcapNgReader<R> {
type Item = Result<Block<'static>, PcapError>;
fn next(&mut self) -> Option<Self::Item> {
match self.reader.is_empty() {
Ok(is_empty) if is_empty => return None,
Err(err) => return Some(Err(err.into())),
_ => {}
}
let endianess = self.section.section_header().unwrap().endianness();
let block_res = if endianess == Endianness::Big {
Block::from_reader::<_, BigEndian>(&mut self.reader)
}
else {
Block::from_reader::<_, LittleEndian>(&mut self.reader)
};
if let Ok(block) = block_res {
if block.section_header().is_some() {
self.section = block.clone();
self.interfaces.clear();
}
else if block.interface_description().is_some() {
self.interfaces.push(block.clone());
}
Some(Ok(block))
}
else {
Some(block_res)
}
}
}