]> git.scottworley.com Git - voter/blame_incremental - src/main.rs
Eliminated candidates UI
[voter] / src / main.rs
... / ...
CommitLineData
1// voter: A simple CGI vote recorder, approval-voting-style
2//
3// This program is free software: you can redistribute it and/or modify it
4// under the terms of the GNU Affero General Public License as published
5// by the Free Software Foundation, version 3.
6
7use rand::prelude::*;
8use std::collections::{HashMap, HashSet};
9use std::io::prelude::*;
10use std::path::{Path, PathBuf};
11
12const DATA_PATH: &str = "/var/lib/voter";
13const COOKIE_NAME: &[u8] = b"__Secure-id";
14const COOKIE_LENGTH: usize = 12;
15
16fn validate_path(path: &str) -> Result<PathBuf, cgi::Response> {
17 let invalid_path = || cgi::text_response(404, "Invalid path");
18 if path == "/" {
19 return Err(cgi::text_response(404, "(This is the voting place. You should have been given a more specific URL for the specific thing you've been invited to vote on.)"));
20 }
21 if path.contains("..") || !path.starts_with('/') {
22 return Err(invalid_path());
23 }
24 let dir = Path::new(&format!("{DATA_PATH}{path}")).to_path_buf();
25 if !dir
26 .canonicalize()
27 .map_err(|_| invalid_path())?
28 .starts_with(DATA_PATH)
29 {
30 return Err(invalid_path());
31 }
32 if !dir.is_dir() {
33 return Err(invalid_path());
34 }
35 Ok(dir)
36}
37
38fn get_voter(request: &cgi::Request) -> Result<&[u8], cgi::Response> {
39 // Expect exactly one cookie, exactly as we generate it.
40 let cookie = request
41 .headers()
42 .get(cgi::http::header::COOKIE)
43 .map(cgi::http::HeaderValue::as_bytes)
44 .and_then(|c| c.strip_prefix(COOKIE_NAME))
45 .and_then(|c| c.strip_prefix(b"="))
46 .ok_or_else(|| cgi::text_response(400, "Invalid cookie"))?;
47 if cookie.len() != COOKIE_LENGTH || cookie.contains(&b' ') || cookie.contains(&b';') {
48 Err(cgi::text_response(400, "Invalid cookie"))
49 } else {
50 Ok(cookie)
51 }
52}
53
54fn tally_votes(dir: &Path) -> std::io::Result<HashMap<String, HashSet<String>>> {
55 let mut tally: HashMap<String, HashSet<String>> = HashMap::new();
56 match std::fs::File::open(dir.to_owned().join("votes")) {
57 Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(tally),
58 Err(e) => Err(e),
59 Ok(vfile) => {
60 for liner in std::io::BufReader::new(vfile).lines() {
61 let line = liner?;
62 if let Some((voter, datum)) = line.split_once(' ') {
63 if voter.len() == COOKIE_LENGTH {
64 if let Some((vote, candidate)) = datum.split_once(' ') {
65 if vote == "0" {
66 if let Some(entry) = tally.get_mut(candidate) {
67 entry.remove(voter);
68 }
69 } else if vote == "1" {
70 tally
71 .entry(candidate.to_owned())
72 .or_default()
73 .insert(voter.to_owned());
74 }
75 }
76 }
77 }
78 }
79 Ok(tally)
80 }
81 }
82}
83
84fn read_elim_list(dir: &Path) -> std::io::Result<HashSet<String>> {
85 match std::fs::File::open(dir.join("eliminated")) {
86 Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(HashSet::new()),
87 Err(e) => Err(e),
88 Ok(elimfile) => std::io::BufReader::new(elimfile).lines().collect(),
89 }
90}
91
92fn valid_id_char(c: u8) -> bool {
93 c.is_ascii_alphanumeric()
94}
95
96fn make_random_id() -> [u8; COOKIE_LENGTH] {
97 let mut id = [0; COOKIE_LENGTH];
98 for c in &mut id {
99 while !valid_id_char(*c) {
100 *c = random();
101 }
102 }
103 id
104}
105
106fn set_cookie(mut response: cgi::Response, path: &str) -> Result<cgi::Response, cgi::Response> {
107 response.headers_mut().append(
108 cgi::http::header::SET_COOKIE,
109 cgi::http::header::HeaderValue::from_bytes(
110 &[
111 COOKIE_NAME,
112 b"=",
113 &make_random_id(),
114 b"; Secure; HttpOnly; SameSite=Strict; Max-Age=30000000; Path=",
115 path.as_bytes(),
116 ]
117 .concat(),
118 )
119 .map_err(|_| cgi::text_response(503, "Couldn't make cookie"))?,
120 );
121 Ok(response)
122}
123
124const HTML_HEADER: &str = "<!DOCTYPE html>
125<html>
126 <head>
127 <meta charset=\"utf-8\">
128 <title>Vote!</title>
129 <style>
130 th { font-size: 70%; text-align: left }
131 input { transform: scale(1.5) }
132 .eliminated { text-decoration: line-through; }
133 div { animation: 2s infinite linear spin }
134 @keyframes spin {
135 from { transform:rotate(0) }
136 to { transform:rotate(1turn) }
137 }
138 </style>
139 <script>
140 window.onload = function() {
141 for (cb of document.getElementsByTagName('input')) {
142 if (cb.parentElement.parentElement.classList.contains('eliminated'))
143 continue;
144 cb.addEventListener('click', (function(cb) {
145 return function() {
146 cb.style.display = 'none'
147 const spin = document.createElement('div')
148 spin.appendChild(document.createTextNode('⏳'))
149 cb.parentElement.insertBefore(spin, cb)
150
151 const req = new XMLHttpRequest()
152 req.addEventListener('load', function(e) {
153 cb.parentElement.removeChild(cb.previousElementSibling)
154 if (req.status == 200) {
155 cb.style.display = ''
156 const delta = cb.checked ? 1 : -1
157 const count_td = cb.parentElement.previousElementSibling
158 count_td.textContent = parseInt(count_td.textContent) + delta
159 } else {
160 cb.parentElement.insertBefore(document.createTextNode('❗'), cb)
161 }
162 })
163 req.open('PUT', window.location.href)
164 req.send((cb.checked ? 1 : 0) + ' ' + cb.parentElement.nextElementSibling.innerHTML)
165 }
166 })(cb))
167 cb.disabled = false
168 }
169 }
170 function num_cmp(a, b) {
171 return parseInt(b.textContent) - parseInt(a.textContent)
172 }
173 function str_cmp(a, b) {
174 if (a.textContent < b.textContent) return -1
175 if (a.textContent > b.textContent) return 1
176 return 0
177 }
178 function checked_cmp(a, b) {
179 vs = [a, b].map(x => {
180 const v = x.children[0].checked + 0
181 return isNaN(v) ? -1 : v
182 })
183 return vs[1] - vs[0]
184 }
185 function sort_table(col, cmp) {
186 const rows = Array.from(document.getElementsByTagName('tr'))
187 rows.shift()
188 rows.sort((a, b) => cmp(a.children[col], b.children[col]))
189 for (row of rows) {
190 row.parentElement.appendChild(row)
191 }
192 }
193 </script>
194 </head>
195 <body>
196 <table>
197 <tr>
198 <th onclick='sort_table(0, num_cmp)'>Count</th>
199 <th onclick='sort_table(1, checked_cmp)'>Vote</th>
200 <th onclick='sort_table(2, str_cmp)'>Candidate</th>
201 </tr>";
202const HTML_FOOTER: &str = "
203 </table>
204 </body>
205</html>";
206
207fn supports(tally: &HashMap<String, HashSet<String>>, me: &str, candidate: &str) -> bool {
208 tally
209 .get(candidate)
210 .map_or(false, |supporters| supporters.contains(me))
211}
212
213fn prompt_for_vote(dir: &Path, request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
214 let voter = get_voter(request);
215 let me = if let Ok(id) = voter {
216 std::str::from_utf8(id).ok()
217 } else {
218 None
219 };
220 let tally = tally_votes(dir).map_err(|_| cgi::text_response(503, "Couldn't tally votes"))?;
221 let elim =
222 read_elim_list(dir).map_err(|_| cgi::text_response(503, "Couldn't read eliminations"))?;
223 let cfile = std::fs::File::open(dir.join("candidates"))
224 .map_err(|_| cgi::text_response(503, "No candidates"))?;
225 let mut response = cgi::html_response(
226 200,
227 std::iter::once(Ok(HTML_HEADER.to_owned()))
228 .chain(std::io::BufReader::new(cfile).lines().map(|rc| {
229 rc.map(|c| {
230 let count = tally.get(&c).map_or(0, std::collections::HashSet::len);
231 let checked = if me.map_or(false, |me| supports(&tally, me, &c)) {
232 "checked"
233 } else {
234 ""
235 };
236 let class = if elim.contains(&c) { "eliminated" } else { "" };
237 format!(
238 "<tr class=\"{class}\">
239 <td>{count}</td>
240 <td><input type=\"checkbox\" autocomplete=\"off\" {checked} disabled></td>
241 <td>{c}</td>
242 </tr>"
243 )
244 })
245 }))
246 .chain(std::iter::once(Ok(HTML_FOOTER.to_owned())))
247 .collect::<std::io::Result<String>>()
248 .map_err(|_| cgi::text_response(503, "Missing candidates"))?,
249 );
250 if voter.is_err() {
251 response = set_cookie(response, request.uri().path())?;
252 }
253 Ok(response)
254}
255
256fn write_vote(dir: &Path, voter: &[u8], vote: &[u8]) -> std::io::Result<()> {
257 let datum = [voter, b" ", vote, b"\n"].concat();
258 let vpath = dir.join("votes");
259 let vfile = std::fs::File::options()
260 .append(true)
261 .create(true)
262 .open(vpath)?;
263 let mut vlock = fd_lock::RwLock::new(vfile);
264 vlock.write()?.write_all(&datum)?;
265 Ok(())
266}
267
268fn record_vote(dir: &Path, request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
269 let body = request.body();
270 // Valid votes look like "0 foo" or "1 bar"
271 if body.len() < 3
272 || (body[0] != b'0' && body[0] != b'1')
273 || body[1] != b' '
274 || body.contains(&b'\n')
275 {
276 return Err(cgi::text_response(415, "Invalid vote"));
277 }
278 write_vote(dir, get_voter(request)?, body)
279 .map_err(|_| cgi::text_response(503, "Couldn't record vote"))?;
280 Ok(cgi::text_response(200, "Vote recorded"))
281}
282
283fn strip_body(mut response: cgi::Response) -> cgi::Response {
284 response.body_mut().clear();
285 response
286}
287
288fn respond(request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
289 let dir = validate_path(request.uri().path())?;
290 match *request.method() {
291 cgi::http::Method::HEAD => prompt_for_vote(&dir, request).map(strip_body),
292 cgi::http::Method::GET => prompt_for_vote(&dir, request),
293 cgi::http::Method::PUT => record_vote(&dir, request),
294 _ => Err(cgi::text_response(405, "Huh?")),
295 }
296}
297
298fn respond_or_report_error(request: cgi::Request) -> cgi::Response {
299 match respond(&request) {
300 Ok(result) => result,
301 Err(error) => error,
302 }
303}
304
305cgi::cgi_main! { respond_or_report_error }