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
118
119
120
121
use dlt_parse::{error::ReadError, storage::DltStorageReader};
use std::{fs::File, io::BufReader, path::PathBuf};
use structopt::StructOpt;
/// Expected command line arguments
#[derive(StructOpt, Debug)]
#[structopt(name = "print_dlt_file")]
struct CommandLineArguments {
/// Path to pcap file.
#[structopt(parse(from_os_str))]
dlt_file: PathBuf,
}
fn main() -> Result<(), ReadError> {
let args = CommandLineArguments::from_args();
let dlt_file = File::open(args.dlt_file)?;
let mut reader = DltStorageReader::new(BufReader::new(dlt_file));
while let Some(msg) = reader.next_packet() {
let msg = msg?;
println!("{:?}", msg.storage_header);
if let Some(extended_header) = msg.packet.extended_header() {
use core::str::from_utf8;
println!(
"application_id: {:?}, context_id: {:?}",
from_utf8(&extended_header.application_id),
from_utf8(&extended_header.context_id)
);
}
// check what type of message was received
match msg.packet.typed_payload() {
Ok(typed_payload) => {
use dlt_parse::DltTypedPayload::*;
match typed_payload {
UnknownNv(p) => {
println!(
"non verbose message 0x{:x} (unknown) with {} bytes of payload.",
p.msg_id,
p.payload.len(),
);
}
LogNv(p) => {
println!(
"non verbose log message 0x{:x} with log level {:?} and {} bytes of payload.",
p.msg_id,
p.log_level,
p.payload.len(),
);
}
LogV(p) => {
println!(
"verbose log message with log level {:?} and values:",
p.log_level
);
for value in p.iter {
println!(" {:?}", value);
}
}
TraceNv(p) => {
println!(
"non verbose trace message 0x{:x} of type {:?} and {} bytes of payload.",
p.msg_id,
p.trace_type,
p.payload.len(),
);
}
TraceV(p) => {
println!(
"verbose trace message with of type {:?} and values:",
p.trace_type
);
for value in p.iter {
println!(" {:?}", value);
}
}
NetworkNv(p) => {
println!(
"non verbose network message 0x{:x} of type {:?} and {} bytes of payload.",
p.msg_id,
p.net_type,
p.payload.len(),
);
}
NetworkV(p) => {
println!(
"verbose network message with of type {:?} and values:",
p.net_type
);
for value in p.iter {
println!(" {:?}", value);
}
}
ControlNv(p) => {
println!(
"non verbose control message {:?} with service id: {} and {} bytes of payload.",
p.msg_type,
p.service_id,
p.payload.len(),
);
}
ControlV(p) => {
println!("verbose control message {:?} with values:", p.msg_type);
for value in p.iter {
println!(" {:?}", value);
}
}
}
}
Err(err) => {
println!("message with payload error received: {}", err);
}
}
}
Ok(())
}