// tattlekey: A one-key UDP keyboard // Copyright (C) 2023 Scott Worley // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see . use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::net::UdpSocket; use std::time::{Duration, SystemTime, UNIX_EPOCH}; const MESSAGE_SIZE: usize = 12; const LOGFILENAME: &str = "log.csv"; #[derive(Eq, Debug, Hash, PartialEq)] struct MessageKey { epoch: u32, device: u16, seq: u16, } #[derive(Debug, Deserialize, Serialize)] struct Message { epoch: u32, device: u16, seq: u16, t: u64, } impl Message { fn key(&self) -> MessageKey { MessageKey { epoch: self.epoch, device: self.device, seq: self.seq, } } } impl From<&[u8; MESSAGE_SIZE]> for Message { fn from(value: &[u8; MESSAGE_SIZE]) -> Self { let ago = u32::from_be_bytes(value[8..=11].try_into().expect("I can't count")); let press_time = SystemTime::now() - Duration::new(ago.into(), 0); Self { epoch: u32::from_be_bytes(value[0..=3].try_into().expect("I can't count")), device: u16::from_be_bytes(value[4..=5].try_into().expect("I can't count")), seq: u16::from_be_bytes(value[6..=7].try_into().expect("I can't count")), t: press_time .duration_since(UNIX_EPOCH) .expect("Bad time?") .as_secs(), } } } impl TryFrom<&[u8]> for Message { type Error = std::array::TryFromSliceError; fn try_from(value: &[u8]) -> Result { match <[u8; MESSAGE_SIZE]>::try_from(value) { Ok(correct_size) => Ok(Message::from(&correct_size)), Err(e) => Err(e), } } } #[derive(Debug)] struct Range { start: u64, end: u64, } impl Range { fn new(t: &u64) -> Self { Self { start: *t, end: *t } } fn contains(&self, t: &u64) -> bool { t > &self.start && t < &self.end } fn extend(&mut self, t: &u64) { if t < &self.start { self.start = *t; } if t > &self.end { self.end = *t; } } } fn merge_message(presses: &mut HashMap, message: Message) { let key = message.key(); if let Some(r) = presses.get_mut(&key) { if !r.contains(&message.t) { r.extend(&message.t); } } else { presses.insert(key, Range::new(&message.t)); } } fn replay_log() -> HashMap { let mut presses = HashMap::new(); if std::path::Path::new(LOGFILENAME).exists() { let mut log = csv::Reader::from_path(LOGFILENAME).expect("Couldn't open log for replay"); for message in log.deserialize() { merge_message( &mut presses, message.expect("Error reading log during replay"), ); } } presses } fn open_log_for_writing() -> csv::Writer { let log_file_exists = std::path::Path::new(LOGFILENAME).exists(); let logfile = std::fs::OpenOptions::new() .create_new(!log_file_exists) .append(true) .open(LOGFILENAME) .expect("Coudln't open log file"); csv::WriterBuilder::new() .has_headers(!log_file_exists) .from_writer(logfile) } fn main() { let socket = UdpSocket::bind("0.0.0.0:29803").expect("couldn't bind to address"); let mut presses = replay_log(); let mut log = open_log_for_writing(); loop { let mut buf = [0; MESSAGE_SIZE]; match socket.recv_from(&mut buf) { Err(e) => eprintln!("Didn't receive data: {e}"), Ok((number_of_bytes, src_addr)) => { let filled_buf = &buf[..number_of_bytes]; if number_of_bytes != MESSAGE_SIZE { eprintln!("Ignoring short message ({number_of_bytes}) from {src_addr}"); continue; } let message = Message::try_from(filled_buf).expect("I can't count"); log.serialize(&message).expect("Couldn't write log"); log.flush().expect("Couldn't flush log"); merge_message(&mut presses, message); } } } }