n6cta/baecun
2
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Initial commit of source for v0.1.0

Browse Source
This commit is contained in:
Chris 2025-03-01 00:31:28 -08:00
parent 67d961aef3
commit 248e1f0a1c
4 changed files with 318 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.gitignore vendored
View File

@ -5,7 +5,8 @@
.LSOverride
# Icon must end with two \r
Icon
Icon
# Thumbnails
._*
@ -36,6 +37,9 @@ target/
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock
#Cross config
Cross.toml
# These are backup files generated by rustfmt
**/*.rs.bk

11
Cargo.toml Normal file
View File

@ -0,0 +1,11 @@
[package]
name = "baecun"
version = "0.1.0"
edition = "2021"
authors = ["Chris, N6CTA <mail@n6cta.com>"]
[dependencies]
clap = { version = "4.1", features = ["derive"] }
[profile.release]
lto = "thin"

125
README.md
View File

@ -1,2 +1,127 @@
# baecun
baecun is a Rust-based command-line tool that constructs and sends specially formatted frames to an AGWPE server over TCP. It supports unproto frames with and without digipeaters and provides some validation for IP addresses, ports, callsigns, and channel numbers. This tool was written as an exercise to both learn and be able to teach the building blocks of both rust idomatic programming and writing a simple unproto AGWPE TX client.
## Features
- IP and Port Validation:
Ensures the provided IP address is valid and the port is greater than zero.
- Callsign Validation:
Validates that callsigns are 9 characters or less and contain only alphanumeric characters or dashes.
- Channel Support:
Verifies that the AGWPE channel number is within the valid range (0–255).
- Flexible Message Input:
Accepts the message to send either via a command-line flag or from standard input (stdin).
- Frame Construction:
Builds either an 'M' frame (without digipeaters) or a 'V' frame (with digipeaters) based on the provided arguments.
- TCP Transmission:
Sends the constructed frame to the AGWPE server over a TCP connection.
## Prerequisites
- Rusthttps://www.rust-lang.org/tools/install (version 1.XX or later)
- Cargo package manager (included with Rust)
## Installation
Clone the repository:
```bash
git clone https://gitea.farpn.net/n6cta/baecun.git
cd baecun
```
Build the project in release mode:
```bash
cargo build –-release
```
The compiled executable will be located in the `target/release` directory.
## Usage
Run the executable with the required arguments:
```bash
baecun -i <IP_ADDRESS> -p -f <FROM_CALL> -t <TO_CALL> -m \"<MESSAGE>\" [OPTIONS]
```
### Command-Line Arguments
- `-i, –ip <IP_ADDRESS>`
The IP address of the AGWPE server.
Example: `192.168.1.100`
- `-p, –port `
The port number of the AGWPE server (must be greater than 0).
Example: `8000`
- `-f, –from_call <FROM_CALL>`
The sender's callsign (up to 9 alphanumeric characters or dashes).
Example: `N0CALL`
- `-t, –to_call <TO_CALL>`
The recipient's callsign (up to 9 alphanumeric characters or dashes).
Example: `DEST`
- `-m, –message `
The message to be sent. If omitted, the message is read from standard input (stdin).
- `-c, –channel `
The AGWPE channel number (default is `0`). Must be between `0` and `255`.
- `-d, –digis …`
A list of digipeater callsigns (up to 7). If provided, a 'V' frame is constructed. Each callsign must follow the same rules as `from_call` and `to_call`.
## Examples
### Sending a Simple Message
Send a message directly from the command line:
```bash
baecun -i 127.0.0.1 -p 8000 -f N0CALL -t DEST -m “Hello, world!”
```
### Sending a Message with Digipeaters
Send a message that includes two digipeaters by piping the message through stdin:
```bash
echo “Test message via digipeaters” | baecun -i 127.0.0.1 -p 8000 -f N0CALL -t DEST -d DIGI1 DIGI2
```
## Code Overview
- Validation Functions:
- `validate_ip` checks that the provided IP address is in a correct format.
- `validate_port` ensures that the port number is non-zero.
- `validate_callsign` and `validate_channel` enforce the proper format and length for callsigns and channel numbers.
- Frame Construction:
- M Frame: Used when no digipeaters are provided.
- V Frame: Used when one or more digipeater callsigns are provided.
Both frames include necessary fields like reserved bytes, data kind, and encoded callsigns.
- TCP Communication:
The function `send_frame` connects to the AGWPE server and transmits the constructed frame over TCP.
## Binary Releases
Binary releases are provided for the following targets for your convinience. They were generated using using Cross.
- aarch64-unknown-linux-gnu
- aarch64-apple-darwin
- x86_64-unknown-linux-gnu
- armv7-unknown-linux-gnueabihf
- arm-unknown-linux-gnueabihf
## Contributing
Contributions are welcome! Feel free to fork this repository and submit pull requests. For major changes, please open an issue first to discuss your ideas.

177
src/main.rs Normal file
View File

@ -0,0 +1,177 @@
use clap::{Parser, ArgGroup};
use std::io::{self, Read, Write};
use std::net::{IpAddr, TcpStream};
/// Validate IP address.
fn validate_ip(ip: &str) -> Result<IpAddr, String> {
ip.parse::<IpAddr>()
.map_err(|_| format!("Invalid IP address format: {}", ip))
}
/// Validate the port number (reject 0).
fn validate_port(port: &str) -> Result<u16, String> {
match port.parse::<u16>() {
Ok(p) if p != 0 => Ok(p),
_ => Err(format!("Invalid port number: {}. Port must be greater than 0.", port)),
}
}
/// Validate callsigns (no more than 9 characters, alphanumeric, and dashes).
fn validate_callsign(call: &str) -> Result<String, String> {
if call.len() <= 9 && call.chars().all(|c| c.is_alphanumeric() || c == '-') {
Ok(call.to_string())
} else {
Err("Callsign must be 9 characters or less and can only contain alphanumeric characters and dashes".to_string())
}
}
/// Validate AGWPE channel (must be between 0 and 255).
fn validate_channel(channel: &str) -> Result<u8, String> {
match channel.parse::<u8>() {
Ok(c) => Ok(c),
Err(_) => Err(format!("Invalid channel: {}. Channel must be between 0 and 255.", channel)),
}
}
/// Constants for frame construction.
const RESERVED_3: [u8; 3] = [0x00, 0x00, 0x00];
const DATA_KIND_M: u8 = 0x4D;
const DATA_KIND_V: u8 = 0x56;
const RESERVED_1: u8 = 0x00;
const PID_AX25: u8 = 0xF0;
const USER_RESERVED: [u8; 4] = [0x00, 0x00, 0x00, 0x00];
/// Helper to encode a callsign into a fixed 10-byte field.
fn encode_callsign(call: &str) -> [u8; 10] {
let mut buf = [0u8; 10];
let bytes = call.as_bytes();
let len = bytes.len().min(9);
buf[..len].copy_from_slice(&bytes[..len]);
buf
}
/// Command-line arguments parser.
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
#[clap(group(
ArgGroup::new("input")
.required(false)
.args(&["message"])
))]
struct Cli {
#[arg(short = 'i', long, value_parser = validate_ip)]
ip: IpAddr,
#[arg(short = 'p', long, value_parser = validate_port)]
port: u16,
#[arg(short = 'f', long, value_parser = validate_callsign)]
from_call: String,
#[arg(short = 't', long, value_parser = validate_callsign)]
to_call: String,
#[arg(short = 'm', long)]
message: Option<String>,
#[arg(short = 'c', long, value_parser = validate_channel, default_value_t = 0)]
channel: u8,
#[arg(short = 'd', long, value_parser = validate_callsign, num_args(1..=7))]
digis: Vec<String>,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
// Parse the command-line arguments.
let cli = Cli::parse();
// Get the message either from the '-m' flag or from stdin.
let message = if let Some(msg) = cli.message {
let trimmed = msg.trim_end();
if trimmed.as_bytes().len() > 255 {
return Err("Message must be 255 bytes or less".into());
}
trimmed.as_bytes().to_vec()
} else {
let mut buffer = String::new();
io::stdin().read_to_string(&mut buffer)?;
let trimmed = buffer.trim_end();
trimmed.as_bytes().to_vec()
};
// Build the frame based on whether digipeaters are provided.
let frame = if cli.digis.is_empty() {
build_m_frame(cli.channel, &cli.from_call, &cli.to_call, &message)
} else {
let digipeaters: Vec<&str> = cli.digis.iter().map(String::as_str).collect();
build_v_frame(cli.channel, &cli.from_call, &cli.to_call, &digipeaters, &message)
};
// Send the frame.
send_frame(&frame, &cli.ip.to_string(), cli.port)?;
Ok(())
}
/// Build 'M' frame (unproto without digipeaters).
fn build_m_frame(port: u8, source_call: &str, destination_call: &str, message: &[u8]) -> Vec<u8> {
let mut frame = Vec::new();
frame.push(port); // AGWPE Port.
frame.extend_from_slice(&RESERVED_3);
frame.push(DATA_KIND_M); // DataKind 'M'.
frame.push(RESERVED_1);
frame.push(PID_AX25); // PID for AX.25.
frame.push(RESERVED_1);
frame.extend_from_slice(&encode_callsign(source_call));
frame.extend_from_slice(&encode_callsign(destination_call));
frame.extend_from_slice(&(message.len() as u32).to_le_bytes());
frame.extend_from_slice(&USER_RESERVED);
frame.extend_from_slice(message);
frame
}
/// Build 'V' frame (unproto with digipeaters).
fn build_v_frame(
port: u8,
source_call: &str,
destination_call: &str,
digipeaters: &[&str],
message: &[u8],
) -> Vec<u8> {
let mut frame = Vec::new();
frame.push(port);
frame.extend_from_slice(&RESERVED_3);
frame.push(DATA_KIND_V); // DataKind 'V'.
frame.push(RESERVED_1);
frame.push(PID_AX25);
frame.push(RESERVED_1);
frame.extend_from_slice(&encode_callsign(source_call));
frame.extend_from_slice(&encode_callsign(destination_call));
let data_len = 1 + digipeaters.len() * 10 + message.len();
frame.extend_from_slice(&(data_len as u32).to_le_bytes());
frame.extend_from_slice(&USER_RESERVED);
frame.push(digipeaters.len() as u8);
for digipeater in digipeaters {
frame.extend_from_slice(&encode_callsign(digipeater));
}
frame.extend_from_slice(message);
frame
}
/// Send the frame over TCP to the AGWPE server.
fn send_frame(frame: &[u8], host: &str, port: u16) -> io::Result<()> {
let addr = format!("{}:{}", host, port);
let mut stream = TcpStream::connect(addr)?;
stream.write_all(frame)?;
Ok(())
}