1use 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
48pub 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 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 #[must_use]
112 pub fn port(&self) -> u16 {
113 self.addr.port()
114 }
115
116 #[must_use]
118 pub fn url(&self, path: &str) -> String {
119 format!("http://{}/{}", self.addr, path.trim_start_matches('/'))
120 }
121
122 #[must_use]
124 pub fn ws_url(&self, path: &str) -> String {
125 format!("ws://{}/{}", self.addr, path.trim_start_matches('/'))
126 }
127
128 #[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 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
262fn 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#[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#[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
692fn 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
842fn 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}