]> git.scottworley.com Git - tattlekey/blob - server/src/main.rs
500c2f55f9fba7296c4eb17d68be5a7d75e86e8b
[tattlekey] / server / src / main.rs
1 // tattlekey: A one-key UDP keyboard
2 // Copyright (C) 2023 Scott Worley <scottworley@scottworley.com>
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with this program. If not, see <https://www.gnu.org/licenses/>.
16
17 use serde::ser::{Serialize, SerializeStruct, Serializer};
18 use std::collections::HashMap;
19 use std::net::UdpSocket;
20 use std::time::{Duration, SystemTime, UNIX_EPOCH};
21
22 const MESSAGE_SIZE: usize = 12;
23 const LOGFILENAME: &str = "log.csv";
24
25 #[derive(Eq, Debug, Hash, PartialEq)]
26 struct MessageKey {
27 epoch: u32,
28 device: u16,
29 seq: u16,
30 }
31
32 #[derive(Debug)]
33 struct Message {
34 key: MessageKey,
35 t: u64,
36 }
37 impl Serialize for Message {
38 // https://github.com/BurntSushi/rust-csv/issues/155
39 // https://github.com/BurntSushi/rust-csv/issues/98
40 // https://github.com/BurntSushi/rust-csv/pull/223
41 // csv doesn't support #[serde(flatten)], so we implement this directly. :(
42 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
43 let mut row = serializer.serialize_struct("Message", 4)?;
44 row.serialize_field("epoch", &self.key.epoch)?;
45 row.serialize_field("device", &self.key.device)?;
46 row.serialize_field("seq", &self.key.seq)?;
47 row.serialize_field("t", &self.t)?;
48 row.end()
49 }
50 }
51
52 impl From<&[u8; MESSAGE_SIZE]> for Message {
53 fn from(value: &[u8; MESSAGE_SIZE]) -> Self {
54 let ago = u32::from_be_bytes(value[8..=11].try_into().expect("I can't count"));
55 let press_time = SystemTime::now() - Duration::new(ago.into(), 0);
56 Self {
57 key: MessageKey {
58 epoch: u32::from_be_bytes(value[0..=3].try_into().expect("I can't count")),
59 device: u16::from_be_bytes(value[4..=5].try_into().expect("I can't count")),
60 seq: u16::from_be_bytes(value[6..=7].try_into().expect("I can't count")),
61 },
62 t: press_time
63 .duration_since(UNIX_EPOCH)
64 .expect("Bad time?")
65 .as_secs(),
66 }
67 }
68 }
69 impl TryFrom<&[u8]> for Message {
70 type Error = std::array::TryFromSliceError;
71 fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
72 match <[u8; MESSAGE_SIZE]>::try_from(value) {
73 Ok(correct_size) => Ok(Message::from(&correct_size)),
74 Err(e) => Err(e),
75 }
76 }
77 }
78
79 #[derive(Debug)]
80 struct Range {
81 start: u64,
82 end: u64,
83 }
84 impl Range {
85 fn new(t: &u64) -> Self {
86 Self { start: *t, end: *t }
87 }
88 fn contains(&self, t: &u64) -> bool {
89 t > &self.start && t < &self.end
90 }
91 fn extend(&mut self, t: &u64) {
92 if t < &self.start {
93 self.start = *t;
94 }
95 if t > &self.end {
96 self.end = *t;
97 }
98 }
99 }
100
101 fn merge_message(presses: &mut HashMap<MessageKey, Range>, message: Message) {
102 if let Some(r) = presses.get_mut(&message.key) {
103 if !r.contains(&message.t) {
104 r.extend(&message.t);
105 }
106 } else {
107 presses.insert(message.key, Range::new(&message.t));
108 }
109 }
110
111 fn open_log_for_writing() -> csv::Writer<std::fs::File> {
112 let log_file_exists = std::path::Path::new(LOGFILENAME).exists();
113 let logfile = std::fs::OpenOptions::new()
114 .create_new(!log_file_exists)
115 .append(true)
116 .open(LOGFILENAME)
117 .expect("Coudln't open log file");
118 csv::WriterBuilder::new()
119 .has_headers(!log_file_exists)
120 .from_writer(logfile)
121 }
122
123 fn main() {
124 let socket = UdpSocket::bind("0.0.0.0:29803").expect("couldn't bind to address");
125 let mut presses = HashMap::<MessageKey, Range>::new();
126 let mut log = open_log_for_writing();
127 loop {
128 let mut buf = [0; MESSAGE_SIZE];
129 match socket.recv_from(&mut buf) {
130 Err(e) => eprintln!("Didn't receive data: {e}"),
131 Ok((number_of_bytes, src_addr)) => {
132 let filled_buf = &buf[..number_of_bytes];
133 if number_of_bytes != MESSAGE_SIZE {
134 eprintln!("Ignoring short message ({number_of_bytes}) from {src_addr}");
135 continue;
136 }
137 let message = Message::try_from(filled_buf).expect("I can't count");
138 log.serialize(&message).expect("Couldn't write log");
139 log.flush().expect("Couldn't flush log");
140 merge_message(&mut presses, message);
141 }
142 }
143 }
144 }