diff --git a/Cargo.toml b/Cargo.toml index 4516ff0..bdc2fac 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,8 @@ authors = ["Chris, N6CTA "] 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" diff --git a/src/main.rs b/src/main.rs index a4e3fa8..77f1e27 100644 --- a/src/main.rs +++ b/src/main.rs @@ -10,8 +10,11 @@ use std::thread::sleep; use std::time::{Duration, SystemTime, UNIX_EPOCH}; use std::net::UdpSocket; use std::net::Ipv4Addr; -use serde_json::json; +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 { @@ -62,7 +65,7 @@ struct Cli { /// Spotter callsign (e.g. W1CDN) #[arg(short = 's', long)] - spotter: Option, + my_call: Option, /// Spot UI frames to a Spothole server #[arg(short = 'o', long, default_value_t = false)] @@ -76,6 +79,14 @@ struct Cli { #[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, + + /// Spotter longitude DD.dddd; to send negaitve (W or S), use = e.g. --my-lon=-97.1 + #[arg(short = 'x', long, allow_negative_numbers = true)] + my_lon: Option, + } /// Convert a byte slice into a hex-dump string for debugging purposes. @@ -367,7 +378,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>) { let hdr = &frame.header; // Process only frames on the specified channel. if hdr.port != cli.channel as i32 { @@ -376,9 +387,27 @@ 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 spotter = &cli.spotter; + let my_call = &cli.my_call; let freq = &cli.freq; - //let spothole_alt = &cli.spothole_alt; + 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.*)-(?P[\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 { @@ -422,33 +451,63 @@ fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager) { return; } + // In non-debug mode, print the session line and any additional lines. + if !cli.debug { + print_session_line(×tamp, &source, &final_destination, &summary); + if lines.len() > 1 { + for line in &lines[1..] { + println!("{}", line); + } + } + } + + // 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 if summary == "UI" && cli.spothole { - // curl --request POST --header "Content-Type: application/json" - // --data '{"dx_call":"M0TRT","time":1760019539, "freq":14200000, - // "comment":"Test spot please ignore", "de_call":"M0TRT"}' https://spothole.app/api/v1/spot - - println!("spothole_url: {}", spothole_url); - - - // POST JSON - let packet = json!({ - "dx_call": &source, - "de_call": &spotter, - "freq": &freq, - "comment": &text, - "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) + // 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!("res = {res:?}"); - - + println!("sent to {} = {}", spothole_url, packet); + println!("res = {res:?}"); } // Send UDP @@ -459,25 +518,64 @@ fn handle_frame(frame: &AgwFrame, cli: &Cli, buffers: &mut BufferManager) { let packet = json!({ "final_destination": &final_destination, "source": &source, - "spotter": &spotter, + "spotter": &my_call, + "spotter_latitude": &my_lat, + "spotter_longitude": &my_lon, "summary": &summary, - "text": &text, + "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); } +} - // In non-debug mode, print the session line and any additional lines. - if !cli.debug { - print_session_line(×tamp, &source, &final_destination, &summary); - if lines.len() > 1 { - for line in &lines[1..] { - println!("{}", line); - } + +fn aprs_loc(packet: &str) -> (f64, f64) { + // Capture different pieces of the location string + let re_loc = Regex::new(r"(?P\d{2})(?P[\d ]{2}\.[\d ]{2})(?P[nsNS])/(?P\d{3})(?P[\d ]{2}\.[\d ]{2})(?P[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: @@ -491,6 +589,10 @@ fn main() -> Result<()> { 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> = 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")?; @@ -538,7 +640,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); }