Merge pull request 'Filter out callsign-SSID combinations' (#32) from filter into dev

Reviewed-on: https://gitea.farpn.net/w1cdn/mwtchahrd/pulls/32

Cargo.toml

@@ -8,6 +8,10 @@ authors = ["Chris, N6CTA  <mail@n6cta.com>"]
 anyhow = "1.0"
 chrono = "0.4"
 clap = { version = "4", features = ["derive"] }
+rand = "0.9.2"
+regex = "1.12.2"
+reqwest = { version = "0.12.24", features = ["json", "blocking"] }
+serde_json = "1.0.145"
 socket2 = "0.5"
 
 [profile.release]

Cross.toml

@@ -1,11 +0,0 @@
-[target.aarch64-unknown-linux-gnu]
-image = "ghcr.io/cross-rs/aarch64-unknown-linux-gnu:edge@sha256:168fa652629cedcd9549e85258be8f83fa008625b187c004d6ea439cf16f6a41"
-
-[target.x86_64-unknown-linux-gnu]
-image = "ghcr.io/cross-rs/x86_64-unknown-linux-gnu:edge@sha256:3542b427c3f7d0d2976d7add025c5ba997499411f408b3b26803ccc70fc431da"
-
-[target.armv7-unknown-linux-gnueabihf]
-image = "ghcr.io/cross-rs/armv7-unknown-linux-gnueabihf:edge@sha256:3e1def581eb9c9f11cfff85745802f2de5cf9cdeeb5a8495048f393a0993b99b"
-
-[target.arm-unknown-linux-gnueabihf]
-image = "ghcr.io/cross-rs/arm-unknown-linux-gnueabihf:edge@sha256:28e7aaae8301506f4f1b3394c8bc23f958d1717043e06f816045e7b8df57e173"

README.md

@@ -37,7 +37,7 @@ The compiled executable will be located in the `target/release` directory.
 Run the executable with the required arguments:
 
 ```bash
-mwtchahrd -i <IP> -p <PORT> [-c <CHANNEL>] [-d] [-u]
+mwtchahrd -i <IP> -p <PORT> [-c <CHANNEL>] [-d] [-u] 
 ```
 
 ### Command‑Line Arguments
@@ -56,6 +56,39 @@ mwtchahrd -i <IP> -p <PORT> [-c <CHANNEL>] [-d] [-u]
 
 - `-u, --ui_only`  
   Only display frames with a UI payload. When this flag is set, frames that are not UI are skipped.
+  
+- `-b, --uip <UIP>`
+  Send UDP to what IP address (e.g. 127.0.0.1) [default: 127.0.0.1].
+  
+- `-k, --uport <UPORT>`
+  Send UDP to what port (e.g. 8000; 55555 disables UDP) [default: 55555].
+  
+- `-s, --spotter <SPOTTER>`            
+  Spotter callsign (e.g. W1CDN).
+  
+- `-o, --spothole`                     
+  Spot UI frames to a Spothole server.
+  
+- `-O, --spothole-alt <SPOTHOLE_ALT>` 
+  Provide a different URL than https://spothole.app/api/v1/spot.
+  
+- `-f, --freq <FREQ>`                 
+  Spotting frequency [default: 14105000].
+  
+- `-y, --my-lat <MY_LAT>`                 
+  Spotter latitude, DD.dddd.
+  
+- `-x, --my-lon <MY_LON>`                 
+  Spotter longitude, DD.dddd.
+
+- `-t, --filter <CALL-SSID,CALL-SSID,...>`                 
+  Filter out spots from these callsign-UUID combinations (self spots, for example), comma-separated. This is not regex, just full matches.
+
+- `-h, --help`                         
+  Print help.
+  
+- `-V, --version`                      
+  Print version.
 
 ## Examples
 
@@ -83,6 +116,14 @@ Monitor only UI frames:
 mwtchahrd -i 127.0.0.1 -p 8000 -u
 ```
 
+### Spotting to [Spothole.app](https://spothole.app) API
+
+Sends only UI frames and mode is hardcoded as `PKT`. Spot from callsign `W1CDN` and report fixed frequency 14.105 MHz. Report your location as spotter and don't spot your own beacons.
+
+```bash
+mwtchahrd --ip 192.168.0.6 --port 8000 --spotter W1CDN --spothole --freq 14105000 --my-lat 47.01 --my-lon -97.01 --filter W1CDN-1,W1CDN-7
+```
+
 ## Code Overview
 
 - **Validation Functions:**  

src/main.rs

@@ -7,7 +7,14 @@ use std::convert::TryInto;
 use std::io::{Read, Write};
 use std::net::TcpStream;
 use std::thread::sleep;
-use std::time::Duration;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::net::UdpSocket;
+use std::net::Ipv4Addr;
+use serde_json::{json};
+use reqwest;
+use regex::Regex;
+use rand::Rng;
+
 
 /// Validate that the provided port string can be parsed into a u16 and is nonzero.
 fn validate_port(port: &str) -> Result<u16, String> {
@@ -31,7 +38,7 @@ struct Cli {
     /// AGWPE server IP address (e.g. 127.0.0.1)
     #[arg(short = 'i', long)]
     ip: std::net::IpAddr,
-
+    
     /// AGWPE server TCP port (e.g. 8000)
     #[arg(short = 'p', long, value_parser = validate_port)]
     port: u16,
@@ -47,6 +54,43 @@ struct Cli {
     /// Only monitor UI frames
     #[arg(short = 'u', long, default_value_t = false)]
     ui_only: bool,
+    
+    /// Send UDP to what IP address (e.g. 127.0.0.1)
+    #[arg(short = 'b', long, default_value_t = std::net::IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)))]
+    uip: std::net::IpAddr,
+    
+    /// Send UDP to what port (e.g. 8000; 55555 disables UDP)
+    #[arg(short = 'k', long, value_parser = validate_port, default_value_t = 55555)]
+    uport: u16,
+    
+    /// Spotter callsign (e.g. W1CDN)
+    #[arg(short = 's', long)]
+    my_call: Option<String>,
+    
+    /// Spot UI frames to a Spothole server
+    #[arg(short = 'o', long, default_value_t = false)]
+    spothole: bool,
+    
+    /// Provide a different URL than https://spothole.app/api/v1/spot
+    #[arg(short = 'O', long)]
+    spothole_alt: Option<String>,
+    
+    /// Spotting frequency
+    #[arg(short = 'f', long, default_value_t = 14105000)]
+    freq: u32,
+    
+    /// Spotter latitude DD.dddd
+    #[arg(short = 'y', long, allow_negative_numbers = true)]
+    my_lat: Option<f64>,
+    
+    /// Spotter longitude DD.dddd
+    #[arg(short = 'x', long, allow_negative_numbers = true)]
+    my_lon: Option<f64>,
+    
+    /// Filter out spots from these callsign-UUID combinations (self spots, for example), comma-separated
+    #[arg(short = 't', long, value_delimiter = ',', num_args = 1..,)]
+    filter: Vec<String>,
+    
 }
 
 /// Convert a byte slice into a hex-dump string for debugging purposes.
@@ -338,7 +382,7 @@ impl BufferManager {
 /// - Filters out frames destined for "NODES" and frames with an XID payload.
 /// - Optionally filters to only UI frames if requested.
 /// - Buffers multi-line frames and prints a formatted session line.
-fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager) {
+fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager, loc_store: &mut HashMap<String, Vec<String>>) {
     let hdr = &frame.header;
     // Process only frames on the specified channel.
     if hdr.port != cli.channel as i32 {
@@ -347,6 +391,33 @@ fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager) {
     let source = hdr.callfrom_str();
     let basic_destination = hdr.callto_str();
     let timestamp = Local::now().format("%H:%M:%S").to_string();
+    let my_call = &cli.my_call;
+    let freq = &cli.freq;
+    let my_lat = &cli.my_lat;
+    let my_lon = &cli.my_lon;
+    
+    // Split callsign and SSID if there are both
+    let (source_call, source_ssid): (&String, Option<&String>) = if source.contains("-") {
+        let re_source = Regex::new(r"(?P<call>.*)-(?P<ssid>[\d])").unwrap();
+        // Break captures into named values
+        let callssid = re_source.captures(&source).unwrap();
+        
+        (&callssid["call"].to_string(), Some(&callssid["ssid"].to_string()))  
+    // Otherwise there is just the call and no SSID
+    } else {
+        (&source, None)  
+        //(&source, &String::new())
+    };
+    //println!("{:?}",(source_call, source_ssid));
+    
+    
+    //println!("{} - {}", source_call, source_ssid);
+    
+    // If user provides an alternate Spothole URL, use that one
+    let spothole_url = match &cli.spothole_alt {
+        Some(spothole_alt) => spothole_alt,
+        None => &"https://spothole.app/api/v1/spot".to_string(),
+    };
 
     // Filter and compute the text from the payload only once.
     let text = filter_text(&frame.payload);
@@ -393,6 +464,125 @@ fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager) {
             }
         }
     }
+    
+    // Extract location from APRS format
+    let (lat, lon) = aprs_loc(&text);
+    
+   // Store the location
+   // Only update location store if there is a real location
+    if lat > -9999.0_f64 && lon > -9999.0_f64 {
+        let loc = vec![lat.to_string(), lon.to_string()];
+        loc_store.insert(source.clone(), loc);
+    }
+      
+    // Look up a stored location
+    // If it doesn't exist, set to empty
+    let stored_loc = match loc_store.get(&source) {
+        Some(loc_value) => loc_value,
+        None => &vec!["".to_string(), "".to_string()],
+    };
+    
+    // Only send good locations on
+    let json_lat = stored_loc[0].clone() ; 
+    let json_lon = stored_loc[1].clone() ; 
+    
+    //println!("Stored location: {} {}", stored_loc[0].clone(), stored_loc[1].clone());
+    
+    // If Spothole is enabled and this is a UI frame and the source is not filtered
+    if summary == "UI" && cli.spothole  && !cli.filter.contains(&source){
+        // POST JSON
+        let packet = json!({
+            "dx_call": &source_call,
+            "dx_ssid": &source_ssid,
+            "de_call": &my_call,
+            "de_latitude": &my_lat,
+            "de_longitude": &my_lon,
+            "freq": &freq,
+            "comment": &text,
+            "dx_latitude": &json_lat,
+            "dx_longitude": &json_lon,
+            "mode": "PKT",
+            "mode_type": "DATA",
+            "mode_source": "SPOT",
+            "time": SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+        });
+        let client = reqwest::blocking::Client::new();
+        let res = client.post(spothole_url)
+                .json(&packet)
+                .send();
+        println!("sent to {} = {}", spothole_url, packet);
+        println!("res = {res:?}");
+    // If it's filtered, send a note about that
+    } else if summary == "UI" && cli.spothole  && cli.filter.contains(&source) {
+        println!("Filter {:?} applied, not spotted", cli.filter)
+    }
+
+    // Send UDP
+    if cli.uport != 55555 {
+        let uaddr = format!("{}:{}", cli.uip, cli.uport);
+        let socket = UdpSocket::bind("0.0.0.0:0");
+        
+        let packet = json!({
+            "final_destination": &final_destination,
+            "source": &source,
+            "spotter": &my_call,
+            "spotter_latitude": &my_lat,
+            "spotter_longitude": &my_lon,
+            "summary": &summary,
+            "text": &text,            
+            "dx_latitude": &json_lat,
+            "dx_longitude": &json_lon,
+            "freq": &freq,
+            "timestamp": SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+            "type": "data"
+        });
+        let _ = socket.expect("REASON").send_to(packet.to_string().as_bytes(), uaddr);
+    }
+}
+
+
+fn aprs_loc(packet: &str) -> (f64, f64) {
+    // Capture different pieces of the location string
+    let re_loc = Regex::new(r"(?P<latd>\d{2})(?P<latm>[\d ]{2}\.[\d ]{2})(?P<ns>[nsNS])/(?P<lond>\d{3})(?P<lonm>[\d ]{2}\.[\d ]{2})(?P<ew>[ewEW])").unwrap();
+    
+    // Only proceed if there were captures
+    match re_loc.captures(&packet) {
+    Some(_caps) => {
+        
+        // Break captures into named values
+        let loc = re_loc.captures(&packet).unwrap();
+                        
+        // Initiate randomness for ambiguity..
+        let mut rng = rand::rng();
+        
+        // Convert to decimal degrees. If ambiguity spaces are included (see APRS spec), replace them with random digits.
+        let mut lat_dec: f64 = &loc["latd"].trim().parse().expect("Expects a number!") + (&loc["latm"].replace(" ", &rng.random_range(0..9).to_string()).trim().parse().expect("Expects a number!") / 60.0);
+        // If south, make negative
+        if &loc["ns"] == "S" {
+            lat_dec = lat_dec * -1.0
+        }
+        
+        // TODO if there are spaces in loc["latm"], the same spaces need to be in loc["lonm"] for proper ambiguity according to APRS spec
+        
+        let mut lon_dec: f64 = &loc["lond"].trim().parse().expect("Expects a number!") + (&loc["lonm"].replace(" ", &rng.random_range(0..9).to_string()).trim().parse().expect("Expects a number!") / 60.0);
+        // If west, make negative
+        if &loc["ew"] == "W" {
+            lon_dec = lon_dec * -1.0
+        }
+        
+        // String to paste into map for testing
+        //println!("{}, {}", lat_dec, lon_dec);
+      
+        // Return
+       (lat_dec, lon_dec)
+        
+    }
+    // Otherwise if there were no captures, return bad data
+    None => {
+        // The regex did not match. Deal with it here!
+        (-9999.0_f64, -9999.0_f64)
+    }
+}
 }
 
 /// Main entry point:
@@ -403,7 +593,26 @@ fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager) {
 fn main() -> Result<()> {
     let cli = Cli::parse();
     let addr = format!("{}:{}", cli.ip, cli.port);
+    let uaddr = format!("{}:{}", cli.uip, cli.uport);
     let reconnect_delay_ms = 5000;
+    
+    // Set up the location store
+    //let mut loc_store = HashMap:: new();
+    let mut loc_store: HashMap<String, Vec<String>> = HashMap::new();
+    
+    if cli.uport != 55555 {
+        // Bind the client socket to any available address and port
+        let socket = UdpSocket::bind("0.0.0.0:0")?;
+        println!("UDP client started at {}:{}", cli.uip, cli.uport);
+        // Send a message to the server
+        let packet = json!({
+            "text": "UDP client connected",
+            "timestamp": SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
+            "type": "status"
+        });
+        //let message = "UDP client connected";
+        socket.send_to(packet.to_string().as_bytes(), uaddr)?;
+    }
 
     loop {
         println!("Connecting to AGWPE server at {addr}");
@@ -438,7 +647,7 @@ fn main() -> Result<()> {
                             while buffer.len() >= 36 {
                                 match parse_frame(&buffer, cli.debug) {
                                     Ok((consumed, frame)) => {
-                                        handle_frame(&frame, &cli, &mut buffers);
+                                        handle_frame(&frame, &cli, &mut buffers, &mut loc_store);
                                         // Remove the processed frame from the buffer.
                                         buffer.drain(0..consumed);
                                     }