Skip to main content

day_part_http/
testing.rs

1// Copyright © The Daybrite Project
2// SPDX-License-Identifier: MPL-2.0
3
4//! A local HTTP/1.1 and WebSocket server for tests and demonstrations (docs/http.md "Testing").
5//!
6//! It binds a loopback port and answers each connection on its own thread, with no network
7//! needed. The crate's tests, the Showcase's Networking page and an app's own tests use it to
8//! exercise redirects, challenges, cookies, caching, ranges, drip-fed bodies, uploads and a
9//! WebSocket echo the same way on every platform that allows a listening socket.
10//!
11//! | route | answer |
12//! |---|---|
13//! | `/` | `day-http-ok` for GET and HEAD, `day-http-ok:<METHOD>` otherwise |
14//! | `/headers` | the request headers, one per line |
15//! | `/echo` | the request body, with `X-Day-Method` |
16//! | `/status/<code>` | that status |
17//! | `/delay/<ms>` | `waited <ms>` after the delay |
18//! | `/redirect/<n>` | a chain of `n` 302s ending in `redirected` |
19//! | `/redirect-to?url=<url>&status=<code>` | one redirect to `url` |
20//! | `/basic-auth/<user>/<password>` | a Basic challenge, then `authenticated <user>` |
21//! | `/digest-auth/<user>/<password>` | a Digest challenge (MD5, `qop=auth`), then `authenticated <user>` |
22//! | `/bearer/<token>` | a Bearer challenge, then `authenticated` |
23//! | `/cookies` | the `Cookie` header received, or `none` |
24//! | `/cookies/set?<name>=<value>&…` | `Set-Cookie` for each pair, then a 302 to `/cookies` |
25//! | `/cookies/delete?<name>&…` | each cookie expired, then a 302 to `/cookies` |
26//! | `/cache/<seconds>` | `max-age=<seconds>` and `generated <n>`, where `n` counts real hits |
27//! | `/drip?chunks=<n>&size=<bytes>&delay_ms=<ms>` | a chunked body fed over time |
28//! | `/bytes/<n>?rate=<bytes per second>` | `n` deterministic bytes, honoring `Range` and `If-Range` |
29//! | `/bytes/<n>/sha256` | the hex SHA-256 of those bytes |
30//! | `/upload` | `<bytes> <hex SHA-256>` of the request body |
31//! | `/ws/echo` | a WebSocket that echoes text and binary messages, answers pings, and echoes the close; the text `close:<code>:<reason>` makes the server close first |
32
33use std::collections::HashMap;
34use std::io::{self, BufRead, BufReader, Read, Write};
35use std::net::{Shutdown, SocketAddr, TcpListener, TcpStream};
36use std::sync::atomic::{AtomicBool, Ordering};
37use std::sync::{Arc, Mutex};
38use std::time::{Duration, Instant, SystemTime};
39
40use sha2::{Digest, Sha256};
41
42use crate::client::{base64_encode, basic_authorization, hex, sha256, verify_digest};
43
44const REALM: &str = "Day test";
45const HEAD_LIMIT: usize = 64 << 10;
46const FRAME_LIMIT: u64 = 16 << 20;
47
48/// A running test server. Dropping it stops accepting connections; connections already open
49/// finish what they are doing.
50pub struct Server {
51    addr: SocketAddr,
52    shared: Arc<Shared>,
53}
54
55struct Shared {
56    stop: AtomicBool,
57    nonce: String,
58    hits: Mutex<HashMap<String, u64>>,
59    digests: Mutex<HashMap<u64, String>>,
60}
61
62impl std::fmt::Debug for Server {
63    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
64        f.debug_struct("Server")
65            .field("addr", &self.addr)
66            .finish_non_exhaustive()
67    }
68}
69
70impl Server {
71    /// Bind a free loopback port and start serving.
72    ///
73    /// # Errors
74    ///
75    /// The I/O error when the loopback port cannot be bound or the accept thread cannot start.
76    pub fn start() -> io::Result<Server> {
77        let listener = TcpListener::bind("127.0.0.1:0")?;
78        let addr = listener.local_addr()?;
79        let seed = SystemTime::now()
80            .duration_since(SystemTime::UNIX_EPOCH)
81            .map_or(0, |d| d.as_nanos());
82        let shared = Arc::new(Shared {
83            stop: AtomicBool::new(false),
84            nonce: hex(&sha256(format!("{addr}:{seed}").as_bytes())[..12]),
85            hits: Mutex::new(HashMap::new()),
86            digests: Mutex::new(HashMap::new()),
87        });
88        let accept = shared.clone();
89        std::thread::Builder::new()
90            .name("day-http-test-server".into())
91            .spawn(move || {
92                for stream in listener.incoming() {
93                    if accept.stop.load(Ordering::Relaxed) {
94                        break;
95                    }
96                    let Ok(stream) = stream else {
97                        continue;
98                    };
99                    let conn = accept.clone();
100                    let _ = std::thread::Builder::new()
101                        .name("day-http-test-connection".into())
102                        .spawn(move || {
103                            let _ = serve(stream, &conn);
104                        });
105                }
106            })?;
107        Ok(Server { addr, shared })
108    }
109
110    /// The port the server listens on.
111    #[must_use]
112    pub fn port(&self) -> u16 {
113        self.addr.port()
114    }
115
116    /// An `http://` URL for `path` on this server.
117    #[must_use]
118    pub fn url(&self, path: &str) -> String {
119        format!("http://{}/{}", self.addr, path.trim_start_matches('/'))
120    }
121
122    /// A `ws://` URL for `path` on this server.
123    #[must_use]
124    pub fn ws_url(&self, path: &str) -> String {
125        format!("ws://{}/{}", self.addr, path.trim_start_matches('/'))
126    }
127
128    /// How many requests reached `path`, query excluded.
129    #[must_use]
130    pub fn hits(&self, path: &str) -> u64 {
131        let key = format!("/{}", path.trim_start_matches('/'));
132        lock(&self.shared.hits).get(&key).copied().unwrap_or(0)
133    }
134}
135
136impl Drop for Server {
137    fn drop(&mut self) {
138        self.shared.stop.store(true, Ordering::Relaxed);
139        // Wake the accept loop so it sees the flag.
140        let _ = TcpStream::connect_timeout(&self.addr, Duration::from_millis(200));
141    }
142}
143
144fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
145    m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
146}
147
148struct Incoming {
149    method: String,
150    path: String,
151    query: Vec<(String, String)>,
152    headers: Vec<(String, String)>,
153    http11: bool,
154}
155
156impl Incoming {
157    fn header(&self, name: &str) -> Option<&str> {
158        self.headers
159            .iter()
160            .find(|(k, _)| k.eq_ignore_ascii_case(name))
161            .map(|(_, v)| v.as_str())
162    }
163
164    fn query(&self, name: &str) -> Option<&str> {
165        self.query
166            .iter()
167            .find(|(k, _)| k == name)
168            .map(|(_, v)| v.as_str())
169    }
170
171    fn query_u64(&self, name: &str, default: u64) -> u64 {
172        self.query(name)
173            .and_then(|v| v.parse().ok())
174            .unwrap_or(default)
175    }
176}
177
178fn serve(stream: TcpStream, shared: &Shared) -> io::Result<()> {
179    let _ = stream.set_nodelay(true);
180    let mut reader = BufReader::new(stream.try_clone()?);
181    let mut out = stream;
182    loop {
183        let Some(request) = read_head(&mut reader)? else {
184            return Ok(());
185        };
186        *lock(&shared.hits).entry(request.path.clone()).or_insert(0) += 1;
187        if request
188            .header("expect")
189            .is_some_and(|v| v.eq_ignore_ascii_case("100-continue"))
190        {
191            out.write_all(b"HTTP/1.1 100 Continue\r\n\r\n")?;
192        }
193        if request.path.starts_with("/ws/")
194            && request
195                .header("upgrade")
196                .is_some_and(|v| v.eq_ignore_ascii_case("websocket"))
197        {
198            return websocket(reader, out, &request);
199        }
200        let keep = request.http11
201            && !request
202                .header("connection")
203                .is_some_and(|v| v.eq_ignore_ascii_case("close"));
204        route(&mut reader, &mut out, &request, shared, keep)?;
205        out.flush()?;
206        if !keep {
207            let _ = out.shutdown(Shutdown::Both);
208            return Ok(());
209        }
210    }
211}
212
213fn read_head(reader: &mut BufReader<TcpStream>) -> io::Result<Option<Incoming>> {
214    let mut lines = Vec::new();
215    let mut total = 0;
216    loop {
217        let mut line = String::new();
218        let n = reader.read_line(&mut line)?;
219        if n == 0 {
220            return Ok(None);
221        }
222        total += n;
223        if total > HEAD_LIMIT {
224            return Err(io::Error::other("request head too large"));
225        }
226        let line = line.trim_end_matches(['\r', '\n']).to_string();
227        if line.is_empty() {
228            if lines.is_empty() {
229                continue;
230            }
231            break;
232        }
233        lines.push(line);
234    }
235    let mut first = lines[0].split_whitespace();
236    let method = first.next().unwrap_or("GET").to_string();
237    let target = first.next().unwrap_or("/").to_string();
238    let http11 = first.next() != Some("HTTP/1.0");
239    let (path, query) = match target.split_once('?') {
240        Some((p, q)) => (
241            p.to_string(),
242            url::form_urlencoded::parse(q.as_bytes())
243                .map(|(k, v)| (k.into_owned(), v.into_owned()))
244                .collect(),
245        ),
246        None => (target, Vec::new()),
247    };
248    let headers = lines[1..]
249        .iter()
250        .filter_map(|l| l.split_once(':'))
251        .map(|(k, v)| (k.trim().to_string(), v.trim().to_string()))
252        .collect();
253    Ok(Some(Incoming {
254        method,
255        path,
256        query,
257        headers,
258        http11,
259    }))
260}
261
262/// Read the request body block by block, by `Content-Length` or chunked framing.
263fn read_body(
264    reader: &mut BufReader<TcpStream>,
265    request: &Incoming,
266    mut block: impl FnMut(&[u8]),
267) -> io::Result<()> {
268    let mut buf = vec![0u8; 64 << 10];
269    if request
270        .header("transfer-encoding")
271        .is_some_and(|v| v.to_ascii_lowercase().contains("chunked"))
272    {
273        loop {
274            let mut size_line = String::new();
275            reader.read_line(&mut size_line)?;
276            let size_text = size_line.trim().split(';').next().unwrap_or("0");
277            let mut left = u64::from_str_radix(size_text, 16)
278                .map_err(|_| io::Error::other("bad chunk size"))?;
279            if left == 0 {
280                let mut trailer = String::new();
281                while reader.read_line(&mut trailer)? > 2 {
282                    trailer.clear();
283                }
284                return Ok(());
285            }
286            while left > 0 {
287                let want = left.min(buf.len() as u64) as usize;
288                let n = reader.read(&mut buf[..want])?;
289                if n == 0 {
290                    return Err(io::ErrorKind::UnexpectedEof.into());
291                }
292                block(&buf[..n]);
293                left -= n as u64;
294            }
295            let mut crlf = [0u8; 2];
296            reader.read_exact(&mut crlf)?;
297        }
298    }
299    let mut left: u64 = request
300        .header("content-length")
301        .and_then(|v| v.parse().ok())
302        .unwrap_or(0);
303    while left > 0 {
304        let want = left.min(buf.len() as u64) as usize;
305        let n = reader.read(&mut buf[..want])?;
306        if n == 0 {
307            return Err(io::ErrorKind::UnexpectedEof.into());
308        }
309        block(&buf[..n]);
310        left -= n as u64;
311    }
312    Ok(())
313}
314
315fn reason(status: u16) -> &'static str {
316    match status {
317        101 => "Switching Protocols",
318        200 => "OK",
319        201 => "Created",
320        204 => "No Content",
321        206 => "Partial Content",
322        301 => "Moved Permanently",
323        302 => "Found",
324        303 => "See Other",
325        304 => "Not Modified",
326        307 => "Temporary Redirect",
327        308 => "Permanent Redirect",
328        400 => "Bad Request",
329        401 => "Unauthorized",
330        403 => "Forbidden",
331        404 => "Not Found",
332        407 => "Proxy Authentication Required",
333        416 => "Range Not Satisfiable",
334        500 => "Internal Server Error",
335        503 => "Service Unavailable",
336        _ => "Status",
337    }
338}
339
340fn write_head(
341    out: &mut TcpStream,
342    status: u16,
343    headers: &[(&str, String)],
344    len: Option<u64>,
345    keep: bool,
346) -> io::Result<()> {
347    use std::fmt::Write as _;
348    let mut head = format!("HTTP/1.1 {status} {}\r\n", reason(status));
349    let _ = write!(
350        head,
351        "Date: {}\r\nServer: day-part-http test server\r\n",
352        httpdate::fmt_http_date(SystemTime::now())
353    );
354    for (k, v) in headers {
355        let _ = write!(head, "{k}: {v}\r\n");
356    }
357    match len {
358        Some(n) => {
359            let _ = write!(head, "Content-Length: {n}\r\n");
360        }
361        None => head.push_str("Transfer-Encoding: chunked\r\n"),
362    }
363    if !keep {
364        head.push_str("Connection: close\r\n");
365    }
366    head.push_str("\r\n");
367    out.write_all(head.as_bytes())
368}
369
370fn respond(
371    out: &mut TcpStream,
372    request: &Incoming,
373    status: u16,
374    headers: &[(&str, String)],
375    body: &[u8],
376    keep: bool,
377) -> io::Result<()> {
378    write_head(out, status, headers, Some(body.len() as u64), keep)?;
379    if request.method != "HEAD" {
380        out.write_all(body)?;
381    }
382    Ok(())
383}
384
385fn text() -> (&'static str, String) {
386    ("Content-Type", "text/plain; charset=utf-8".to_string())
387}
388
389fn route(
390    reader: &mut BufReader<TcpStream>,
391    out: &mut TcpStream,
392    request: &Incoming,
393    shared: &Shared,
394    keep: bool,
395) -> io::Result<()> {
396    use std::fmt::Write as _;
397    let segments: Vec<&str> = request.path.trim_start_matches('/').split('/').collect();
398    if request.path == "/upload" {
399        let mut hasher = Sha256::new();
400        let mut len = 0u64;
401        read_body(reader, request, |block| {
402            hasher.update(block);
403            len += block.len() as u64;
404        })?;
405        let body = format!("{len} {}", hex(hasher.finalize().as_slice()));
406        return respond(out, request, 200, &[text()], body.as_bytes(), keep);
407    }
408    let mut body = Vec::new();
409    read_body(reader, request, |block| body.extend_from_slice(block))?;
410
411    match segments.as_slice() {
412        [""] => {
413            let answer = if matches!(request.method.as_str(), "GET" | "HEAD") {
414                "day-http-ok".to_string()
415            } else {
416                format!("day-http-ok:{}", request.method)
417            };
418            respond(out, request, 200, &[text()], answer.as_bytes(), keep)
419        }
420        ["headers"] => {
421            let mut lines = String::new();
422            for (k, v) in &request.headers {
423                let _ = writeln!(lines, "{k}: {v}");
424            }
425            respond(out, request, 200, &[text()], lines.as_bytes(), keep)
426        }
427        ["echo"] => {
428            let mut headers = vec![("X-Day-Method", request.method.clone())];
429            if let Some(ct) = request.header("content-type") {
430                headers.push(("Content-Type", ct.to_string()));
431            }
432            respond(out, request, 200, &headers, &body, keep)
433        }
434        ["status", code] => {
435            let status = code
436                .parse::<u16>()
437                .ok()
438                .filter(|s| (200..=599).contains(s))
439                .unwrap_or(400);
440            let answer = format!("status {status}");
441            respond(out, request, status, &[text()], answer.as_bytes(), keep)
442        }
443        ["delay", ms] => {
444            let ms = ms.parse::<u64>().unwrap_or(0).min(60_000);
445            std::thread::sleep(Duration::from_millis(ms));
446            let answer = format!("waited {ms}");
447            respond(out, request, 200, &[text()], answer.as_bytes(), keep)
448        }
449        ["redirect", n] => match n.parse::<u32>() {
450            Ok(0) => respond(out, request, 200, &[text()], b"redirected", keep),
451            Ok(n) => respond(
452                out,
453                request,
454                302,
455                &[("Location", format!("/redirect/{}", n - 1))],
456                b"",
457                keep,
458            ),
459            Err(_) => respond(out, request, 400, &[text()], b"bad count", keep),
460        },
461        ["redirect-to"] => {
462            let status = request
463                .query("status")
464                .and_then(|s| s.parse::<u16>().ok())
465                .filter(|s| matches!(s, 301 | 302 | 303 | 307 | 308))
466                .unwrap_or(302);
467            let target = request.query("url").unwrap_or("/").to_string();
468            respond(out, request, status, &[("Location", target)], b"", keep)
469        }
470        ["basic-auth", user, password] => {
471            if request.header("authorization") == Some(basic_authorization(user, password).as_str())
472            {
473                let answer = format!("authenticated {user}");
474                respond(out, request, 200, &[text()], answer.as_bytes(), keep)
475            } else {
476                let challenge = format!("Basic realm=\"{REALM}\"");
477                respond(
478                    out,
479                    request,
480                    401,
481                    &[("WWW-Authenticate", challenge), text()],
482                    b"credentials required",
483                    keep,
484                )
485            }
486        }
487        ["digest-auth", user, password] => {
488            let nonce = &shared.nonce;
489            let ok = request.header("authorization").is_some_and(|a| {
490                a.contains(&format!("nonce=\"{nonce}\""))
491                    && verify_digest(a, user, password, &request.method)
492            });
493            if ok {
494                let answer = format!("authenticated {user}");
495                respond(out, request, 200, &[text()], answer.as_bytes(), keep)
496            } else {
497                let challenge = format!(
498                    "Digest realm=\"{REALM}\", qop=\"auth\", algorithm=MD5, nonce=\"{nonce}\", \
499                     opaque=\"day\""
500                );
501                respond(
502                    out,
503                    request,
504                    401,
505                    &[("WWW-Authenticate", challenge), text()],
506                    b"credentials required",
507                    keep,
508                )
509            }
510        }
511        ["bearer", token] => {
512            if request.header("authorization") == Some(format!("Bearer {token}").as_str()) {
513                respond(out, request, 200, &[text()], b"authenticated", keep)
514            } else {
515                let challenge = format!("Bearer realm=\"{REALM}\"");
516                respond(
517                    out,
518                    request,
519                    401,
520                    &[("WWW-Authenticate", challenge), text()],
521                    b"token required",
522                    keep,
523                )
524            }
525        }
526        ["cookies"] => {
527            let answer = request.header("cookie").unwrap_or("none").to_string();
528            respond(out, request, 200, &[text()], answer.as_bytes(), keep)
529        }
530        ["cookies", "set" | "delete"] => {
531            let delete = segments[1] == "delete";
532            let mut headers: Vec<(&str, String)> = request
533                .query
534                .iter()
535                .map(|(k, v)| {
536                    let cookie = if delete {
537                        format!("{k}=; Path=/; Max-Age=0")
538                    } else {
539                        format!("{k}={v}; Path=/")
540                    };
541                    ("Set-Cookie", cookie)
542                })
543                .collect();
544            headers.push(("Location", "/cookies".to_string()));
545            respond(out, request, 302, &headers, b"", keep)
546        }
547        ["cache", seconds] => {
548            let seconds = seconds.parse::<u64>().unwrap_or(60);
549            let etag = format!("\"day-cache-{seconds}\"");
550            if request.header("if-none-match") == Some(etag.as_str()) {
551                return respond(out, request, 304, &[("ETag", etag)], b"", keep);
552            }
553            let generated = {
554                let mut hits = lock(&shared.hits);
555                let n = hits
556                    .entry(format!("generated:{}", request.path))
557                    .or_insert(0);
558                *n += 1;
559                *n
560            };
561            let answer = format!("generated {generated}");
562            respond(
563                out,
564                request,
565                200,
566                &[
567                    ("Cache-Control", format!("public, max-age={seconds}")),
568                    ("ETag", etag),
569                    text(),
570                ],
571                answer.as_bytes(),
572                keep,
573            )
574        }
575        ["drip"] => {
576            let chunks = request.query_u64("chunks", 10).min(10_000);
577            let size = request.query_u64("size", 1024).clamp(1, 1 << 20) as usize;
578            let delay = Duration::from_millis(request.query_u64("delay_ms", 100).min(10_000));
579            write_head(
580                out,
581                200,
582                &[("Content-Type", "application/octet-stream".into())],
583                None,
584                keep,
585            )?;
586            if request.method == "HEAD" {
587                return Ok(());
588            }
589            for i in 0..chunks {
590                if i > 0 {
591                    std::thread::sleep(delay);
592                }
593                let block = vec![b'a' + (i % 26) as u8; size];
594                out.write_all(format!("{size:x}\r\n").as_bytes())?;
595                out.write_all(&block)?;
596                out.write_all(b"\r\n")?;
597                out.flush()?;
598            }
599            out.write_all(b"0\r\n\r\n")
600        }
601        ["bytes", n, "sha256"] => {
602            let n = n.parse::<u64>().unwrap_or(0);
603            let digest = lock(&shared.digests).get(&n).cloned();
604            let digest = digest.unwrap_or_else(|| {
605                let d = pattern_sha256(n);
606                lock(&shared.digests).insert(n, d.clone());
607                d
608            });
609            respond(out, request, 200, &[text()], digest.as_bytes(), keep)
610        }
611        ["bytes", n] => {
612            let total = n.parse::<u64>().unwrap_or(0).min(8 << 30);
613            bytes(out, request, total, keep)
614        }
615        _ => respond(out, request, 404, &[text()], b"not found", keep),
616    }
617}
618
619/// The byte at `offset` in every `/bytes` body.
620#[must_use]
621pub fn pattern_byte(offset: u64) -> u8 {
622    (offset.wrapping_mul(0x9E37_79B9_7F4A_7C15) >> 56) as u8
623}
624
625fn fill_pattern(start: u64, buf: &mut [u8]) {
626    for (i, b) in buf.iter_mut().enumerate() {
627        *b = pattern_byte(start + i as u64);
628    }
629}
630
631/// The hex SHA-256 of the first `len` pattern bytes.
632#[must_use]
633pub fn pattern_sha256(len: u64) -> String {
634    let mut hasher = Sha256::new();
635    let mut buf = vec![0u8; 64 << 10];
636    let mut offset = 0;
637    while offset < len {
638        let n = (len - offset).min(buf.len() as u64) as usize;
639        fill_pattern(offset, &mut buf[..n]);
640        hasher.update(&buf[..n]);
641        offset += n as u64;
642    }
643    hex(hasher.finalize().as_slice())
644}
645
646fn bytes(out: &mut TcpStream, request: &Incoming, total: u64, keep: bool) -> io::Result<()> {
647    let etag = format!("\"day-bytes-{total}\"");
648    let rate = request.query_u64("rate", 0);
649    let if_range_ok = request.header("if-range").is_none_or(|v| v == etag);
650    let range = request
651        .header("range")
652        .filter(|_| if_range_ok)
653        .and_then(|r| parse_range(r, total));
654    let mut headers = vec![
655        ("Accept-Ranges", "bytes".to_string()),
656        ("ETag", etag),
657        ("Content-Type", "application/octet-stream".to_string()),
658    ];
659    let (status, start, end) = match range {
660        Some(Ok((start, end))) => {
661            headers.push(("Content-Range", format!("bytes {start}-{end}/{total}")));
662            (206, start, end + 1)
663        }
664        Some(Err(())) => {
665            headers.push(("Content-Range", format!("bytes */{total}")));
666            return respond(out, request, 416, &headers, b"", keep);
667        }
668        None => (200, 0, total),
669    };
670    write_head(out, status, &headers, Some(end - start), keep)?;
671    if request.method == "HEAD" {
672        return Ok(());
673    }
674    let began = Instant::now();
675    let mut buf = vec![0u8; 16 << 10];
676    let mut offset = start;
677    while offset < end {
678        let n = (end - offset).min(buf.len() as u64) as usize;
679        fill_pattern(offset, &mut buf[..n]);
680        out.write_all(&buf[..n])?;
681        offset += n as u64;
682        if rate > 0 {
683            let due = Duration::from_secs_f64((offset - start) as f64 / rate as f64);
684            if let Some(ahead) = due.checked_sub(began.elapsed()) {
685                std::thread::sleep(ahead);
686            }
687        }
688    }
689    Ok(())
690}
691
692/// One `bytes=` range within `total`: `Ok((first, last))` inclusive, `Err` when unsatisfiable,
693/// `None` when the header is not a single byte range.
694fn parse_range(header: &str, total: u64) -> Option<Result<(u64, u64), ()>> {
695    let spec = header.trim().strip_prefix("bytes=")?;
696    if spec.contains(',') {
697        return None;
698    }
699    let (first, last) = spec.split_once('-')?;
700    let (first, last) = match (first.trim(), last.trim()) {
701        ("", suffix) => {
702            let n: u64 = suffix.parse().ok()?;
703            if n == 0 || total == 0 {
704                return Some(Err(()));
705            }
706            (total.saturating_sub(n), total - 1)
707        }
708        (a, "") => (a.parse().ok()?, total.saturating_sub(1)),
709        (a, b) => (
710            a.parse().ok()?,
711            b.parse::<u64>().ok()?.min(total.saturating_sub(1)),
712        ),
713    };
714    if total == 0 || first >= total || first > last {
715        return Some(Err(()));
716    }
717    Some(Ok((first, last)))
718}
719
720fn websocket(
721    mut reader: BufReader<TcpStream>,
722    mut out: TcpStream,
723    request: &Incoming,
724) -> io::Result<()> {
725    use std::fmt::Write as _;
726    if request.path != "/ws/echo" {
727        return respond(&mut out, request, 404, &[text()], b"not found", false);
728    }
729    let key = request.header("sec-websocket-key").unwrap_or("");
730    let accept = base64_encode(&sha1(
731        format!("{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11").as_bytes(),
732    ));
733    let mut head = format!(
734        "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\
735         Sec-WebSocket-Accept: {accept}\r\n"
736    );
737    if let Some(protocol) = request
738        .header("sec-websocket-protocol")
739        .and_then(|p| p.split(',').next())
740        .map(str::trim)
741        .filter(|p| !p.is_empty())
742    {
743        let _ = write!(head, "Sec-WebSocket-Protocol: {protocol}\r\n");
744    }
745    head.push_str("\r\n");
746    out.write_all(head.as_bytes())?;
747
748    let mut partial: Option<(u8, Vec<u8>)> = None;
749    loop {
750        let (fin, opcode, payload) = read_frame(&mut reader)?;
751        match opcode {
752            0x0 => {
753                if let Some((_, data)) = partial.as_mut() {
754                    data.extend_from_slice(&payload);
755                }
756                if fin && let Some((op, data)) = partial.take() {
757                    write_frame(&mut out, op, &data)?;
758                }
759            }
760            0x1 if fin => {
761                if let Some(command) = std::str::from_utf8(&payload)
762                    .ok()
763                    .and_then(|t| t.strip_prefix("close:"))
764                {
765                    let (code, reason) = command.split_once(':').unwrap_or((command, ""));
766                    let code = code.parse::<u16>().unwrap_or(1000);
767                    let mut close = code.to_be_bytes().to_vec();
768                    close.extend_from_slice(reason.as_bytes());
769                    write_frame(&mut out, 0x8, &close)?;
770                } else {
771                    write_frame(&mut out, 0x1, &payload)?;
772                }
773            }
774            0x1 | 0x2 if !fin => partial = Some((opcode, payload)),
775            0x2 => write_frame(&mut out, 0x2, &payload)?,
776            0x8 => {
777                write_frame(&mut out, 0x8, &payload)?;
778                let _ = out.shutdown(Shutdown::Both);
779                return Ok(());
780            }
781            0x9 => write_frame(&mut out, 0xA, &payload)?,
782            0xA => {}
783            _ => return Ok(()),
784        }
785    }
786}
787
788fn read_frame(reader: &mut impl Read) -> io::Result<(bool, u8, Vec<u8>)> {
789    let mut two = [0u8; 2];
790    reader.read_exact(&mut two)?;
791    let fin = two[0] & 0x80 != 0;
792    let opcode = two[0] & 0x0F;
793    let masked = two[1] & 0x80 != 0;
794    let len = match two[1] & 0x7F {
795        126 => {
796            let mut b = [0u8; 2];
797            reader.read_exact(&mut b)?;
798            u64::from(u16::from_be_bytes(b))
799        }
800        127 => {
801            let mut b = [0u8; 8];
802            reader.read_exact(&mut b)?;
803            u64::from_be_bytes(b)
804        }
805        n => u64::from(n),
806    };
807    if len > FRAME_LIMIT {
808        return Err(io::Error::other("frame too large"));
809    }
810    let mut mask = [0u8; 4];
811    if masked {
812        reader.read_exact(&mut mask)?;
813    }
814    let mut payload = vec![0u8; len as usize];
815    reader.read_exact(&mut payload)?;
816    if masked {
817        for (i, b) in payload.iter_mut().enumerate() {
818            *b ^= mask[i % 4];
819        }
820    }
821    Ok((fin, opcode, payload))
822}
823
824fn write_frame(out: &mut impl Write, opcode: u8, payload: &[u8]) -> io::Result<()> {
825    let mut frame = vec![0x80 | opcode];
826    match payload.len() {
827        n if n < 126 => frame.push(n as u8),
828        n if n <= 0xFFFF => {
829            frame.push(126);
830            frame.extend_from_slice(&(n as u16).to_be_bytes());
831        }
832        n => {
833            frame.push(127);
834            frame.extend_from_slice(&(n as u64).to_be_bytes());
835        }
836    }
837    frame.extend_from_slice(payload);
838    out.write_all(&frame)?;
839    out.flush()
840}
841
842/// SHA-1, for the WebSocket handshake's accept key only (RFC 6455 §4.2.2).
843fn sha1(data: &[u8]) -> [u8; 20] {
844    let mut h: [u32; 5] = [
845        0x6745_2301,
846        0xEFCD_AB89,
847        0x98BA_DCFE,
848        0x1032_5476,
849        0xC3D2_E1F0,
850    ];
851    let mut message = data.to_vec();
852    message.push(0x80);
853    while message.len() % 64 != 56 {
854        message.push(0);
855    }
856    message.extend_from_slice(&((data.len() as u64) * 8).to_be_bytes());
857    for block in message.as_chunks::<64>().0 {
858        let mut w = [0u32; 80];
859        for (slot, word) in w.iter_mut().zip(block.as_chunks::<4>().0) {
860            *slot = u32::from_be_bytes(*word);
861        }
862        for i in 16..80 {
863            w[i] = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]).rotate_left(1);
864        }
865        let [mut a, mut b, mut c, mut d, mut e] = h;
866        for (i, word) in w.iter().enumerate() {
867            let (f, k) = match i {
868                0..=19 => ((b & c) | (!b & d), 0x5A82_7999),
869                20..=39 => (b ^ c ^ d, 0x6ED9_EBA1),
870                40..=59 => ((b & c) | (b & d) | (c & d), 0x8F1B_BCDC),
871                _ => (b ^ c ^ d, 0xCA62_C1D6),
872            };
873            let t = a
874                .rotate_left(5)
875                .wrapping_add(f)
876                .wrapping_add(e)
877                .wrapping_add(k)
878                .wrapping_add(*word);
879            e = d;
880            d = c;
881            c = b.rotate_left(30);
882            b = a;
883            a = t;
884        }
885        for (slot, v) in h.iter_mut().zip([a, b, c, d, e]) {
886            *slot = slot.wrapping_add(v);
887        }
888    }
889    let mut out = [0u8; 20];
890    for (chunk, v) in out.as_chunks_mut::<4>().0.iter_mut().zip(h) {
891        *chunk = v.to_be_bytes();
892    }
893    out
894}
895
896#[cfg(test)]
897mod tests {
898    use super::*;
899
900    #[test]
901    fn sha1_matches_the_reference_vectors() {
902        assert_eq!(
903            hex(&sha1(b"abc")),
904            "a9993e364706816aba3e25717850c26c9cd0d89d"
905        );
906        let accept = base64_encode(&sha1(
907            b"dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
908        ));
909        assert_eq!(accept, "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
910    }
911
912    #[test]
913    fn ranges_parse_within_the_total() {
914        assert_eq!(parse_range("bytes=0-9", 100), Some(Ok((0, 9))));
915        assert_eq!(parse_range("bytes=90-", 100), Some(Ok((90, 99))));
916        assert_eq!(parse_range("bytes=-10", 100), Some(Ok((90, 99))));
917        assert_eq!(parse_range("bytes=95-200", 100), Some(Ok((95, 99))));
918        assert_eq!(parse_range("bytes=100-", 100), Some(Err(())));
919        assert_eq!(parse_range("bytes=0-1,5-6", 100), None);
920    }
921}