git.scottworley.com Git - voter/blame_incremental - src/main.rs

// voter: A simple CGI vote recorder, approval-voting-style
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, version 3.

use rand::prelude::*;
use std::collections::{HashMap, HashSet};
use std::io::prelude::*;
use std::path::{Path, PathBuf};

const DATA_PATH: &str = "/var/lib/voter";
const COOKIE_NAME: &[u8] = b"__Secure-id";
const COOKIE_LENGTH: usize = 12;

fn validate_path(path: &str) -> Result<PathBuf, cgi::Response> {
    let invalid_path = || cgi::text_response(404, "Invalid path");
    if path == "/" {
        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.)"));
    }
    if path.contains("..") || !path.starts_with('/') {
        return Err(invalid_path());
    }
    let dir = Path::new(&format!("{DATA_PATH}{path}")).to_path_buf();
    if !dir
        .canonicalize()
        .map_err(|_| invalid_path())?
        .starts_with(DATA_PATH)
    {
        return Err(invalid_path());
    }
    if !dir.is_dir() {
        return Err(invalid_path());
    }
    Ok(dir)
}

fn get_voter(request: &cgi::Request) -> Result<&[u8], cgi::Response> {
    // Expect exactly one cookie, exactly as we generate it.
    let cookie = request
        .headers()
        .get(cgi::http::header::COOKIE)
        .map(cgi::http::HeaderValue::as_bytes)
        .and_then(|c| c.strip_prefix(COOKIE_NAME))
        .and_then(|c| c.strip_prefix(b"="))
        .ok_or_else(|| cgi::text_response(400, "Invalid cookie"))?;
    if cookie.len() != COOKIE_LENGTH || cookie.contains(&b' ') || cookie.contains(&b';') {
        Err(cgi::text_response(400, "Invalid cookie"))
    } else {
        Ok(cookie)
    }
}

fn tally_votes(dir: &Path) -> std::io::Result<HashMap<String, HashSet<String>>> {
    let mut tally: HashMap<String, HashSet<String>> = HashMap::new();
    match std::fs::File::open(dir.to_owned().join("votes")) {
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(tally),
        Err(e) => Err(e),
        Ok(vfile) => {
            for liner in std::io::BufReader::new(vfile).lines() {
                let line = liner?;
                if let Some((voter, datum)) = line.split_once(' ') {
                    if voter.len() == COOKIE_LENGTH {
                        if let Some((vote, candidate)) = datum.split_once(' ') {
                            if vote == "0" {
                                if let Some(entry) = tally.get_mut(candidate) {
                                    entry.remove(voter);
                                }
                            } else if vote == "1" {
                                tally
                                    .entry(candidate.to_owned())
                                    .or_default()
                                    .insert(voter.to_owned());
                            }
                        }
                    }
                }
            }
            Ok(tally)
        }
    }
}

fn read_elim_list(dir: &Path) -> std::io::Result<HashSet<String>> {
    match std::fs::File::open(dir.join("eliminated")) {
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(HashSet::new()),
        Err(e) => Err(e),
        Ok(elimfile) => std::io::BufReader::new(elimfile).lines().collect(),
    }
}

fn valid_id_char(c: u8) -> bool {
    c.is_ascii_alphanumeric()
}

fn make_random_id() -> [u8; COOKIE_LENGTH] {
    let mut id = [0; COOKIE_LENGTH];
    for c in &mut id {
        while !valid_id_char(*c) {
            *c = random();
        }
    }
    id
}

fn set_cookie(mut response: cgi::Response, path: &str) -> Result<cgi::Response, cgi::Response> {
    response.headers_mut().append(
        cgi::http::header::SET_COOKIE,
        cgi::http::header::HeaderValue::from_bytes(
            &[
                COOKIE_NAME,
                b"=",
                &make_random_id(),
                b"; Secure; HttpOnly; SameSite=Strict; Max-Age=30000000; Path=",
                path.as_bytes(),
            ]
            .concat(),
        )
        .map_err(|_| cgi::text_response(503, "Couldn't make cookie"))?,
    );
    Ok(response)
}

const HTML_HEADER: &str = "<!DOCTYPE html>
<html>
  <head>
    <meta charset=\"utf-8\">
    <title>Vote!</title>
    <style>
      th { font-size: 70%; text-align: left }
      input { transform: scale(1.5) }
      .eliminated { text-decoration: line-through; }
      div { animation: 2s infinite linear spin }
      @keyframes spin {
        from { transform:rotate(0) }
        to { transform:rotate(1turn) }
      }
    </style>
    <script>
      window.onload = function() {
        for (cb of document.getElementsByTagName('input')) {
          if (cb.parentElement.parentElement.classList.contains('eliminated'))
            continue;
          cb.addEventListener('click', (function(cb) {
            return function() {
              cb.style.display = 'none'
              const spin = document.createElement('div')
              spin.appendChild(document.createTextNode('⏳'))
              cb.parentElement.insertBefore(spin, cb)

              const req = new XMLHttpRequest()
              req.addEventListener('load', function(e) {
                cb.parentElement.removeChild(cb.previousElementSibling)
                if (req.status == 200) {
                    cb.style.display = ''
                    const delta = cb.checked ? 1 : -1
                    const count_td = cb.parentElement.previousElementSibling
                    count_td.textContent = parseInt(count_td.textContent) + delta
                } else {
                   cb.parentElement.insertBefore(document.createTextNode('❗'), cb)
                }
              })
              req.open('PUT', window.location.href)
              req.send((cb.checked ? 1 : 0) + ' ' + cb.parentElement.nextElementSibling.innerHTML)
            }
          })(cb))
          cb.disabled = false
        }
      }
      function num_cmp(a, b) {
        return parseInt(b.textContent) - parseInt(a.textContent)
      }
      function str_cmp(a, b) {
        if (a.textContent < b.textContent) return -1
        if (a.textContent > b.textContent) return 1
        return 0
      }
      function checked_cmp(a, b) {
        vs = [a, b].map(x => {
          const v = x.children[0].checked + 0
          return isNaN(v) ? -1 : v
        })
        return vs[1] - vs[0]
      }
      function sort_table(col, cmp) {
        const rows = Array.from(document.getElementsByTagName('tr'))
        rows.shift()
        rows.sort((a, b) => cmp(a.children[col], b.children[col]))
        for (row of rows) {
          row.parentElement.appendChild(row)
        }
      }
    </script>
  </head>
  <body>
    <table>
      <tr>
        <th onclick='sort_table(0, num_cmp)'>Count</th>
        <th onclick='sort_table(1, checked_cmp)'>Vote</th>
        <th onclick='sort_table(2, str_cmp)'>Candidate</th>
      </tr>";
const HTML_FOOTER: &str = "
    </table>
  </body>
</html>";

fn supports(tally: &HashMap<String, HashSet<String>>, me: &str, candidate: &str) -> bool {
    tally
        .get(candidate)
        .map_or(false, |supporters| supporters.contains(me))
}

fn prompt_for_vote(dir: &Path, request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
    let voter = get_voter(request);
    let me = if let Ok(id) = voter {
        std::str::from_utf8(id).ok()
    } else {
        None
    };
    let tally = tally_votes(dir).map_err(|_| cgi::text_response(503, "Couldn't tally votes"))?;
    let elim =
        read_elim_list(dir).map_err(|_| cgi::text_response(503, "Couldn't read eliminations"))?;
    let cfile = std::fs::File::open(dir.join("candidates"))
        .map_err(|_| cgi::text_response(503, "No candidates"))?;
    let mut response = cgi::html_response(
        200,
        std::iter::once(Ok(HTML_HEADER.to_owned()))
            .chain(std::io::BufReader::new(cfile).lines().map(|rc| {
                rc.map(|c| {
                    let count = tally.get(&c).map_or(0, std::collections::HashSet::len);
                    let checked = if me.map_or(false, |me| supports(&tally, me, &c)) {
                        "checked"
                    } else {
                        ""
                    };
                    let class = if elim.contains(&c) { "eliminated" } else { "" };
                    format!(
                        "<tr class=\"{class}\">
                        <td>{count}</td>
                        <td><input type=\"checkbox\" autocomplete=\"off\" {checked} disabled></td>
                        <td>{c}</td>
                        </tr>"
                    )
                })
            }))
            .chain(std::iter::once(Ok(HTML_FOOTER.to_owned())))
            .collect::<std::io::Result<String>>()
            .map_err(|_| cgi::text_response(503, "Missing candidates"))?,
    );
    if voter.is_err() {
        response = set_cookie(response, request.uri().path())?;
    }
    Ok(response)
}

fn write_vote(dir: &Path, voter: &[u8], vote: &[u8]) -> std::io::Result<()> {
    let datum = [voter, b" ", vote, b"\n"].concat();
    let vpath = dir.join("votes");
    let vfile = std::fs::File::options()
        .append(true)
        .create(true)
        .open(vpath)?;
    let mut vlock = fd_lock::RwLock::new(vfile);
    vlock.write()?.write_all(&datum)?;
    Ok(())
}

fn record_vote(dir: &Path, request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
    let body = request.body();
    // Valid votes look like "0 foo" or "1 bar"
    if body.len() < 3
        || (body[0] != b'0' && body[0] != b'1')
        || body[1] != b' '
        || body.contains(&b'\n')
    {
        return Err(cgi::text_response(415, "Invalid vote"));
    }
    let elim =
        read_elim_list(dir).map_err(|_| cgi::text_response(503, "Couldn't read eliminations"))?;
    if elim.contains(
        std::str::from_utf8(&body[2..]).map_err(|_| cgi::text_response(415, "Vote not UTF-8"))?,
    ) {
        return Err(cgi::text_response(403, "Candidate eliminated"));
    }
    write_vote(dir, get_voter(request)?, body)
        .map_err(|_| cgi::text_response(503, "Couldn't record vote"))?;
    Ok(cgi::text_response(200, "Vote recorded"))
}

fn strip_body(mut response: cgi::Response) -> cgi::Response {
    response.body_mut().clear();
    response
}

fn respond(request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
    let dir = validate_path(request.uri().path())?;
    match *request.method() {
        cgi::http::Method::HEAD => prompt_for_vote(&dir, request).map(strip_body),
        cgi::http::Method::GET => prompt_for_vote(&dir, request),
        cgi::http::Method::PUT => record_vote(&dir, request),
        _ => Err(cgi::text_response(405, "Huh?")),
    }
}

fn respond_or_report_error(request: cgi::Request) -> cgi::Response {
    match respond(&request) {
        Ok(result) => result,
        Err(error) => error,
    }
}

cgi::cgi_main! { respond_or_report_error }
Commit	Line	Data
	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
	7	use rand::prelude::*;
	8	use std::collections::{HashMap, HashSet};
	9	use std::io::prelude::*;
	10	use std::path::{Path, PathBuf};
	11
	12	const DATA_PATH: &str = "/var/lib/voter";
	13	const COOKIE_NAME: &[u8] = b"__Secure-id";
	14	const COOKIE_LENGTH: usize = 12;
	15
	16	fn 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
	38	fn 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
	54	fn 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
	84	fn 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
	92	fn valid_id_char(c: u8) -> bool {
	93	c.is_ascii_alphanumeric()
	94	}
	95
	96	fn 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
	106	fn 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
	124	const 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>";
	202	const HTML_FOOTER: &str = "
	203	</table>
	204	</body>
	205	</html>";
	206
	207	fn 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
	213	fn 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
	256	fn 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
	268	fn 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	let elim =
	279	read_elim_list(dir).map_err(\|_\| cgi::text_response(503, "Couldn't read eliminations"))?;
	280	if elim.contains(
	281	std::str::from_utf8(&body[2..]).map_err(\|_\| cgi::text_response(415, "Vote not UTF-8"))?,
	282	) {
	283	return Err(cgi::text_response(403, "Candidate eliminated"));
	284	}
	285	write_vote(dir, get_voter(request)?, body)
	286	.map_err(\|_\| cgi::text_response(503, "Couldn't record vote"))?;
	287	Ok(cgi::text_response(200, "Vote recorded"))
	288	}
	289
	290	fn strip_body(mut response: cgi::Response) -> cgi::Response {
	291	response.body_mut().clear();
	292	response
	293	}
	294
	295	fn respond(request: &cgi::Request) -> Result<cgi::Response, cgi::Response> {
	296	let dir = validate_path(request.uri().path())?;
	297	match *request.method() {
	298	cgi::http::Method::HEAD => prompt_for_vote(&dir, request).map(strip_body),
	299	cgi::http::Method::GET => prompt_for_vote(&dir, request),
	300	cgi::http::Method::PUT => record_vote(&dir, request),
	301	_ => Err(cgi::text_response(405, "Huh?")),
	302	}
	303	}
	304
	305	fn respond_or_report_error(request: cgi::Request) -> cgi::Response {
	306	match respond(&request) {
	307	Ok(result) => result,
	308	Err(error) => error,
	309	}
	310	}
	311
	312	cgi::cgi_main! { respond_or_report_error }