368 lines
13 KiB
Rust
368 lines
13 KiB
Rust
use clap::Parser;
|
|
use std::{
|
|
fs::File,
|
|
io,
|
|
path::{Path, PathBuf},
|
|
sync::mpsc::{channel, Sender},
|
|
thread,
|
|
};
|
|
|
|
use anyhow::Result;
|
|
use ax25::frame::{Ax25Frame, CommandResponse, FrameContent};
|
|
use pcap_file::{
|
|
pcap::{PcapHeader, PcapPacket, PcapWriter},
|
|
DataLink,
|
|
};
|
|
use std::io::Read;
|
|
use std::net::TcpStream;
|
|
use std::time::Duration;
|
|
use std::time::SystemTime;
|
|
|
|
struct KissPkt {
|
|
timestamp: Duration,
|
|
orig_len: u32,
|
|
data: Vec<u8>,
|
|
}
|
|
|
|
fn tnc_loop<T: Read>(tx: Sender<KissPkt>, mut stream: T) -> Result<()> {
|
|
let mut buffer = [0_u8; 4096];
|
|
let mut frame = vec![];
|
|
let mut escaped = false;
|
|
let mut timestamp = SystemTime::now()
|
|
.duration_since(SystemTime::UNIX_EPOCH)
|
|
.unwrap();
|
|
let mut orig_len = 0;
|
|
loop {
|
|
let n = stream.read(&mut buffer)?;
|
|
if n == 0 {
|
|
return Ok(());
|
|
}
|
|
for byte in buffer[..n].iter() {
|
|
orig_len += 1;
|
|
if escaped {
|
|
match *byte {
|
|
0xDC => frame.push(0xC0),
|
|
0xDD => frame.push(0xDB),
|
|
_ => { /* ERROR: invalid escape sequence */ }
|
|
}
|
|
escaped = false;
|
|
} else {
|
|
match *byte {
|
|
0xDB => escaped = true,
|
|
0xC0 => {
|
|
//TODO send and clear frame if not empty
|
|
if frame.len() == 0 {
|
|
orig_len = 1;
|
|
timestamp = SystemTime::now()
|
|
.duration_since(SystemTime::UNIX_EPOCH)
|
|
.unwrap();
|
|
continue;
|
|
};
|
|
tx.send(KissPkt {
|
|
timestamp,
|
|
orig_len,
|
|
data: frame.clone(),
|
|
})?;
|
|
frame.clear();
|
|
}
|
|
b => frame.push(b),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[derive(Parser)]
|
|
#[command(author, version, about, long_about = None)]
|
|
struct Arg {
|
|
#[arg(short, long, default_value_t = false)]
|
|
verbose: bool,
|
|
#[arg(short, long, value_name = "FILE")]
|
|
output: Option<PathBuf>,
|
|
input: String,
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
let arg = Arg::parse();
|
|
let mut file = arg.output.map(|path| {
|
|
//TODO automatically add file extension
|
|
let file_out = File::create(path).expect("Error opening file for writing");
|
|
let header = PcapHeader {
|
|
datalink: DataLink::AX25_KISS,
|
|
..Default::default()
|
|
};
|
|
PcapWriter::with_header(file_out, header).expect("Error writing file")
|
|
});
|
|
|
|
let (tx, rx) = channel();
|
|
match arg.input.as_str() {
|
|
"-" => {
|
|
let file = io::BufReader::new(io::stdin());
|
|
thread::spawn(move || tnc_loop(tx, file).unwrap());
|
|
}
|
|
s if Path::new(s).exists() => {
|
|
let file = io::BufReader::new(File::open(s)?);
|
|
thread::spawn(move || tnc_loop(tx, file).unwrap());
|
|
}
|
|
addr => {
|
|
let stream = TcpStream::connect(addr)?;
|
|
let strm = stream.try_clone()?;
|
|
thread::spawn(move || tnc_loop(tx, strm).unwrap());
|
|
}
|
|
}
|
|
|
|
while let Ok(pkt) = rx.recv() {
|
|
//let time = SystemTime::now();
|
|
//let timestamp = time.duration_since(SystemTime::UNIX_EPOCH);
|
|
let mut s = String::new();
|
|
for byte in pkt.data.iter() {
|
|
//if byte >= ' '.into() && byte <= '~'.into() {
|
|
if *byte >= 32 && *byte <= 126 {
|
|
s.push((*byte).into());
|
|
} else {
|
|
s.push_str(&format!("\\{:x?} ", *byte));
|
|
}
|
|
}
|
|
|
|
if arg.verbose {
|
|
if let Ok(frame) = Ax25Frame::from_bytes(&pkt.data[1..]) {
|
|
frame.print_long();
|
|
} else {
|
|
//TODO print time stamp
|
|
println!("{}", s);
|
|
}
|
|
} else {
|
|
if let Ok(frame) = Ax25Frame::from_bytes(&pkt.data[1..]) {
|
|
frame.print_short();
|
|
} else {
|
|
//TODO print time stamp
|
|
println!("{}", s);
|
|
}
|
|
}
|
|
|
|
if let Some(ref mut writer) = file {
|
|
let pkt = PcapPacket::new_owned(pkt.timestamp, pkt.orig_len, pkt.data);
|
|
writer.write_packet(&pkt).unwrap();
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
trait PrintData {
|
|
fn type_str_short(&self) -> &'static str;
|
|
fn print_short(&self);
|
|
fn print_long(&self);
|
|
}
|
|
impl PrintData for Ax25Frame {
|
|
fn type_str_short(&self) -> &'static str {
|
|
match self.content {
|
|
FrameContent::Information(_) => "Info",
|
|
FrameContent::ReceiveReady(_) => "RecvRdy",
|
|
FrameContent::ReceiveNotReady(_) => "RecvNotRdy",
|
|
FrameContent::Reject(_) => "Reject",
|
|
FrameContent::SetAsynchronousBalancedMode(_) => "AsyncBalMode", //12 long
|
|
FrameContent::Disconnect(_) => "Disconnect",
|
|
FrameContent::DisconnectedMode(_) => "DisconMode",
|
|
FrameContent::UnnumberedAcknowledge(_) => "UnNumAck",
|
|
FrameContent::FrameReject(_) => "FrameReject",
|
|
FrameContent::UnnumberedInformation(_) => "UnNumInfo",
|
|
FrameContent::UnknownContent(_) => "Unknown",
|
|
}
|
|
}
|
|
fn print_short(&self) {
|
|
//Format: "[source] -> [dest] via [..] [CMD/RSP/NIL] [frameType]: [DATA str rep]"
|
|
let src = self.source.to_string();
|
|
let dst = self.destination.to_string();
|
|
//let via: String = self.route.iter().map(|re| format!(" {} ", re.repeater.to_string())).collect(); //todo
|
|
let rsp = match self.command_or_response {
|
|
Some(CommandResponse::Command) => "CMD",
|
|
Some(CommandResponse::Response) => "RSP",
|
|
None => "NIL",
|
|
};
|
|
let ftype = self.type_str_short();
|
|
let mut routed = false;
|
|
for route in self.route.iter() {
|
|
if route.has_repeated {
|
|
routed = true;
|
|
break;
|
|
}
|
|
}
|
|
let arrow_shaft = if routed { "=" } else { "-" };
|
|
|
|
//let mut rawdata;
|
|
let (rawdata, finfo) = match &self.content {
|
|
FrameContent::Information(_i) => (
|
|
_i.info.clone(),
|
|
format!(
|
|
"pid: {:?}, seq: {}/{}, info: ",
|
|
_i.pid, _i.send_sequence, _i.receive_sequence
|
|
),
|
|
),
|
|
FrameContent::ReceiveReady(rr) => (
|
|
vec![],
|
|
format!(
|
|
"seq: {}, poll/final: {}",
|
|
rr.receive_sequence, rr.poll_or_final
|
|
),
|
|
),
|
|
FrameContent::ReceiveNotReady(rnr) => (
|
|
vec![],
|
|
format!(
|
|
"seq: {}, poll/final: {}",
|
|
rnr.receive_sequence, rnr.poll_or_final
|
|
),
|
|
),
|
|
FrameContent::Reject(rnr) => (
|
|
vec![],
|
|
format!(
|
|
"seq: {}, poll/final: {}",
|
|
rnr.receive_sequence, rnr.poll_or_final
|
|
),
|
|
),
|
|
FrameContent::SetAsynchronousBalancedMode(abm) => {
|
|
(vec![], format!("poll: {}", abm.poll))
|
|
}
|
|
FrameContent::Disconnect(abm) => (vec![], format!("poll: {}", abm.poll)),
|
|
FrameContent::DisconnectedMode(abm) => {
|
|
(vec![], format!("final bit: {}", abm.final_bit))
|
|
}
|
|
FrameContent::UnnumberedAcknowledge(abm) => {
|
|
(vec![], format!("final bit: {}", abm.final_bit))
|
|
}
|
|
FrameContent::FrameReject(fr) => (
|
|
vec![],
|
|
format!(
|
|
"[{}{}{}{}], seq: {}/{}, raw: {}, cmdRsp: {}, final: {}",
|
|
if fr.z { "Z" } else { "" },
|
|
if fr.y { "Y" } else { "" },
|
|
if fr.x { "X" } else { "" },
|
|
if fr.w { "W" } else { "" },
|
|
fr.send_sequence,
|
|
fr.receive_sequence,
|
|
fr.rejected_control_field_raw,
|
|
match fr.command_response {
|
|
CommandResponse::Command => "CMD",
|
|
CommandResponse::Response => "RSP",
|
|
},
|
|
fr.final_bit
|
|
),
|
|
),
|
|
FrameContent::UnnumberedInformation(ui) => {
|
|
(ui.info.clone(), format!("pid: {:?} info:", ui.pid))
|
|
}
|
|
FrameContent::UnknownContent(ukn) => (ukn.raw.clone(), format!("")),
|
|
};
|
|
let mut data = String::new();
|
|
for byte in rawdata.iter() {
|
|
//if byte >= ' '.into() && byte <= '~'.into() {
|
|
if *byte >= 32 && *byte <= 126 {
|
|
data.push((*byte).into());
|
|
} else {
|
|
data.push_str(&format!("\\{:x?} ", *byte));
|
|
}
|
|
}
|
|
println!(
|
|
"AX.25 {:12} {} {:9} {}> {:9} {}",
|
|
ftype,
|
|
rsp,
|
|
src,
|
|
arrow_shaft,
|
|
dst,
|
|
if !data.is_empty() { data } else { finfo }
|
|
);
|
|
}
|
|
fn print_long(&self) {
|
|
//Format: "[source] -> [dest] via [..] [CMD/RSP/NIL] [frameType]: [DATA str rep]"
|
|
let src = self.source.to_string();
|
|
let dst = self.destination.to_string();
|
|
let via: String = self
|
|
.route
|
|
.iter()
|
|
.map(|re| format!(" {} ", re.repeater.to_string()))
|
|
.collect(); //todo
|
|
let rsp = match self.command_or_response {
|
|
Some(CommandResponse::Command) => "CMD",
|
|
Some(CommandResponse::Response) => "RSP",
|
|
None => "NIL",
|
|
};
|
|
let ftype = self.type_str_short();
|
|
|
|
//let mut rawdata;
|
|
let (rawdata, finfo) = match &self.content {
|
|
FrameContent::Information(_i) => (
|
|
_i.info.clone(),
|
|
format!(
|
|
"pid: {:?}, seq: {}/{}, info: ",
|
|
_i.pid, _i.send_sequence, _i.receive_sequence
|
|
),
|
|
),
|
|
FrameContent::ReceiveReady(rr) => (
|
|
vec![],
|
|
format!(
|
|
"seq: {}, poll/final: {}",
|
|
rr.receive_sequence, rr.poll_or_final
|
|
),
|
|
),
|
|
FrameContent::ReceiveNotReady(rnr) => (
|
|
vec![],
|
|
format!(
|
|
"seq: {}, poll/final: {}",
|
|
rnr.receive_sequence, rnr.poll_or_final
|
|
),
|
|
),
|
|
FrameContent::Reject(rnr) => (
|
|
vec![],
|
|
format!(
|
|
"seq: {}, poll/final: {}",
|
|
rnr.receive_sequence, rnr.poll_or_final
|
|
),
|
|
),
|
|
FrameContent::SetAsynchronousBalancedMode(abm) => {
|
|
(vec![], format!("poll: {}", abm.poll))
|
|
}
|
|
FrameContent::Disconnect(abm) => (vec![], format!("poll: {}", abm.poll)),
|
|
FrameContent::DisconnectedMode(abm) => {
|
|
(vec![], format!("final bit: {}", abm.final_bit))
|
|
}
|
|
FrameContent::UnnumberedAcknowledge(abm) => {
|
|
(vec![], format!("final bit: {}", abm.final_bit))
|
|
}
|
|
FrameContent::FrameReject(fr) => (
|
|
vec![],
|
|
format!(
|
|
"[{}{}{}{}], seq: {}/{}, raw: {}, cmdRsp: {}, final: {}",
|
|
if fr.z { "Z" } else { "" },
|
|
if fr.y { "Y" } else { "" },
|
|
if fr.x { "X" } else { "" },
|
|
if fr.w { "W" } else { "" },
|
|
fr.send_sequence,
|
|
fr.receive_sequence,
|
|
fr.rejected_control_field_raw,
|
|
match fr.command_response {
|
|
CommandResponse::Command => "CMD",
|
|
CommandResponse::Response => "RSP",
|
|
},
|
|
fr.final_bit
|
|
),
|
|
),
|
|
FrameContent::UnnumberedInformation(ui) => {
|
|
(ui.info.clone(), format!("pid: {:?} info:", ui.pid))
|
|
}
|
|
FrameContent::UnknownContent(ukn) => (ukn.raw.clone(), format!("")),
|
|
};
|
|
let mut data = String::new();
|
|
for byte in rawdata.iter() {
|
|
//if byte >= ' '.into() && byte <= '~'.into() {
|
|
if *byte >= 32 && *byte <= 126 {
|
|
data.push((*byte).into());
|
|
} else {
|
|
data.push_str(&format!("\\{:x?} ", *byte));
|
|
}
|
|
}
|
|
println!(
|
|
"AX.25 {:12} {} {:9} -> {:9} via [{}] {} {}",
|
|
ftype, rsp, src, dst, via, finfo, data
|
|
);
|
|
}
|
|
}
|