1#![cfg_attr(docsrs, feature(doc_cfg))]
2#![doc = include_str!("../README.md")]
3#![allow(renamed_and_removed_lints)] #![allow(unknown_lints)] #![warn(missing_docs)]
7#![warn(noop_method_call)]
8#![warn(unreachable_pub)]
9#![warn(clippy::all)]
10#![deny(clippy::await_holding_lock)]
11#![deny(clippy::cargo_common_metadata)]
12#![deny(clippy::cast_lossless)]
13#![deny(clippy::checked_conversions)]
14#![allow(clippy::cognitive_complexity)] #![deny(clippy::debug_assert_with_mut_call)]
16#![deny(clippy::exhaustive_enums)]
17#![deny(clippy::exhaustive_structs)]
18#![deny(clippy::expl_impl_clone_on_copy)]
19#![deny(clippy::fallible_impl_from)]
20#![deny(clippy::implicit_clone)]
21#![deny(clippy::large_stack_arrays)]
22#![warn(clippy::manual_ok_or)]
23#![deny(clippy::missing_docs_in_private_items)]
24#![warn(clippy::needless_borrow)]
25#![warn(clippy::needless_pass_by_value)]
26#![warn(clippy::option_option)]
27#![warn(clippy::or_fun_call)]
28#![deny(clippy::print_stderr)]
29#![deny(clippy::print_stdout)]
30#![warn(clippy::rc_buffer)]
31#![deny(clippy::ref_option_ref)]
32#![warn(clippy::semicolon_if_nothing_returned)]
33#![warn(clippy::trait_duplication_in_bounds)]
34#![deny(clippy::unchecked_time_subtraction)]
35#![deny(clippy::unnecessary_wraps)]
36#![warn(clippy::unseparated_literal_suffix)]
37#![deny(clippy::unwrap_used)]
38#![deny(clippy::mod_module_files)]
39#![allow(clippy::let_unit_value)] #![allow(clippy::uninlined_format_args)]
41#![allow(clippy::significant_drop_in_scrutinee)] #![allow(clippy::result_large_err)] #![allow(clippy::needless_raw_string_hashes)] #![allow(clippy::needless_lifetimes)] #![allow(mismatched_lifetime_syntaxes)] #![allow(clippy::collapsible_if)] #![deny(clippy::unused_async)]
48#![deny(clippy::string_slice)] #![allow(recursion_depth_exceeding_limit)] #![cfg_attr(
54 not(all(feature = "full", feature = "experimental")),
55 allow(unused_imports)
56)]
57
58mod body;
59mod err;
60pub mod request;
61mod response;
62mod util;
63
64use tor_circmgr::{CircMgr, DirInfo};
65use tor_error::bad_api_usage;
66use tor_rtcompat::{Runtime, SleepProvider, SleepProviderExt};
67
68#[cfg(feature = "xz")]
70use async_compression::futures::bufread::XzDecoder;
71use async_compression::futures::bufread::ZlibDecoder;
72#[cfg(feature = "zstd")]
73use async_compression::futures::bufread::ZstdDecoder;
74
75use futures::FutureExt;
76use futures::io::{
77 AsyncBufRead, AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, BufReader,
78};
79use std::sync::Arc;
80use std::time::Duration;
81use tracing::{info, instrument};
82
83pub use err::{Error, RequestError, RequestFailedError};
84pub use response::{DirResponse, SourceInfo};
85
86pub type Result<T> = std::result::Result<T, Error>;
88
89pub type RequestResult<T> = std::result::Result<T, RequestError>;
91
92#[derive(Copy, Clone, Debug, Eq, PartialEq)]
119#[non_exhaustive]
120pub enum AnonymizedRequest {
121 Anonymized,
131
132 Direct,
145}
146
147#[instrument(level = "trace", skip_all)]
160pub async fn get_resource<CR, R, SP>(
161 req: &CR,
162 dirinfo: DirInfo<'_>,
163 runtime: &SP,
164 circ_mgr: Arc<CircMgr<R>>,
165) -> Result<DirResponse>
166where
167 CR: request::Requestable + ?Sized,
168 R: Runtime,
169 SP: SleepProvider,
170{
171 let tunnel = circ_mgr.get_or_launch_dir(dirinfo).await?;
172
173 if req.anonymized() == AnonymizedRequest::Anonymized {
174 return Err(bad_api_usage!("Tried to use get_resource for an anonymized request").into());
175 }
176
177 let begin_timeout = Duration::from_secs(5);
179 let source = match SourceInfo::from_tunnel(&tunnel) {
180 Ok(source) => source,
181 Err(e) => {
182 return Err(Error::RequestFailed(RequestFailedError {
183 source: None,
184 error: e.into(),
185 }));
186 }
187 };
188
189 let wrap_err = |error| {
190 Error::RequestFailed(RequestFailedError {
191 source: source.clone(),
192 error,
193 })
194 };
195
196 req.check_circuit_skip_optimization(&tunnel)
197 .await
198 .map_err(wrap_err)?;
199
200 let mut stream = runtime
202 .timeout(begin_timeout, tunnel.begin_dir_stream())
203 .await
204 .map_err(RequestError::from)
205 .map_err(wrap_err)?
206 .map_err(RequestError::from)
207 .map_err(wrap_err)?; let r = send_request(runtime, req, &mut stream, source.clone()).await;
212
213 if should_retire_circ(&r) {
214 retire_circ(&circ_mgr, &tunnel.unique_id(), "Partial response");
215 }
216
217 r
218}
219
220fn should_retire_circ(result: &Result<DirResponse>) -> bool {
223 match result {
224 Err(e) => e.should_retire_circ(),
225 Ok(dr) => dr.error().map(RequestError::should_retire_circ) == Some(true),
226 }
227}
228
229#[deprecated(since = "0.8.1", note = "Use send_request instead.")]
231pub async fn download<R, S, SP>(
232 runtime: &SP,
233 req: &R,
234 stream: &mut S,
235 source: Option<SourceInfo>,
236) -> Result<DirResponse>
237where
238 R: request::Requestable + ?Sized,
239 S: AsyncRead + AsyncWrite + Send + Unpin,
240 SP: SleepProvider,
241{
242 send_request(runtime, req, stream, source).await
243}
244
245pub async fn send_request<R, S, SP>(
264 runtime: &SP,
265 req: &R,
266 stream: &mut S,
267 source: Option<SourceInfo>,
268) -> Result<DirResponse>
269where
270 R: request::Requestable + ?Sized,
271 S: AsyncRead + AsyncWrite + Send + Unpin,
272 SP: SleepProvider,
273{
274 let wrap_err = |error| {
275 Error::RequestFailed(RequestFailedError {
276 source: source.clone(),
277 error,
278 })
279 };
280
281 let partial_ok = req.partial_response_body_ok();
282 let maxlen = req.max_response_len();
283 let anonymized = req.anonymized();
284 let req = req.make_request().map_err(wrap_err)?;
285 let method = req.method().clone();
286 let encoded = util::encode_request(&req);
287
288 for chunk in encoded.iter() {
290 stream
291 .write_all(chunk)
292 .await
293 .map_err(RequestError::from)
294 .map_err(wrap_err)?;
295 }
296 stream
297 .flush()
298 .await
299 .map_err(RequestError::from)
300 .map_err(wrap_err)?;
301
302 let mut buffered = BufReader::new(stream);
303
304 let header = read_headers(runtime, &mut buffered)
306 .await
307 .map_err(wrap_err)?;
308 if header.status != Some(200) {
309 return Ok(DirResponse::new(
310 method,
311 header.status.unwrap_or(0),
312 header.status_message,
313 None,
314 vec![],
315 source,
316 ));
317 }
318
319 let mut decoder =
320 get_decoder(buffered, header.encoding.as_deref(), anonymized).map_err(wrap_err)?;
321
322 let mut result = Vec::new();
323 let ok = read_and_decompress(runtime, &mut decoder, maxlen, &mut result).await;
324
325 let ok = match (partial_ok, ok, result.len()) {
326 (true, Err(e), n) if n > 0 => {
327 Err(e)
329 }
330 (_, Err(e), _) => {
331 return Err(wrap_err(e));
332 }
333 (_, Ok(()), _) => Ok(()),
334 };
335
336 Ok(DirResponse::new(
337 method,
338 200,
339 None,
340 ok.err(),
341 result,
342 source,
343 ))
344}
345
346const MAX_HEADERS_LEN: usize = 16384;
350
351async fn read_headers<S, SP>(runtime: &SP, stream: &mut S) -> RequestResult<HeaderStatus>
355where
356 S: AsyncBufRead + Unpin,
357 SP: SleepProvider,
358{
359 let read_timeout = Duration::from_secs(10);
362 runtime
363 .timeout(read_timeout, read_headers_internal(stream))
364 .await
365 .map_err(|_| RequestError::DirTimeout)
366 .flatten()
367}
368
369async fn read_headers_internal<S>(stream: &mut S) -> RequestResult<HeaderStatus>
371where
372 S: AsyncBufRead + Unpin,
373{
374 let mut buf = Vec::with_capacity(1024);
375
376 let mut limited_stream = stream.take(MAX_HEADERS_LEN as u64);
379
380 loop {
381 let n = limited_stream.read_until(b'\n', &mut buf).await?;
385
386 let mut headers = [httparse::EMPTY_HEADER; 32];
388 let mut response = httparse::Response::new(&mut headers);
389
390 match response.parse(&buf[..])? {
391 httparse::Status::Partial => {
392 if n == 0 {
395 return Err(RequestError::TruncatedHeaders);
397 }
398
399 if buf.len() >= MAX_HEADERS_LEN {
400 return Err(RequestError::HeadersTooLong(buf.len()));
401 }
402 }
403 httparse::Status::Complete(n_parsed) => {
404 if response.code != Some(200) {
405 return Ok(HeaderStatus {
406 status: response.code,
407 status_message: response.reason.map(str::to_owned),
408 encoding: None,
409 });
410 }
411 let encoding = if let Some(enc) = response
412 .headers
413 .iter()
414 .find(|h| h.name == "Content-Encoding")
415 {
416 Some(String::from_utf8(enc.value.to_vec())?)
417 } else {
418 None
419 };
420 assert!(n_parsed == buf.len());
427 return Ok(HeaderStatus {
428 status: Some(200),
429 status_message: None,
430 encoding,
431 });
432 }
433 }
434 if n == 0 {
435 return Err(RequestError::TruncatedHeaders);
436 }
437 }
438}
439
440#[derive(Debug, Clone)]
442struct HeaderStatus {
443 status: Option<u16>,
445 status_message: Option<String>,
447 encoding: Option<String>,
449}
450
451async fn read_and_decompress<S, SP>(
460 runtime: &SP,
461 mut stream: S,
462 maxlen: usize,
463 result: &mut Vec<u8>,
464) -> RequestResult<()>
465where
466 S: AsyncRead + Unpin,
467 SP: SleepProvider,
468{
469 let buffer_window_size = 1024;
470 let mut written_total: usize = 0;
471 let read_timeout = Duration::from_secs(60);
496 let timer = runtime.sleep(read_timeout).fuse();
497 futures::pin_mut!(timer);
498
499 loop {
500 result.resize(written_total + buffer_window_size, 0);
502 let buf: &mut [u8] = &mut result[written_total..written_total + buffer_window_size];
503
504 let status = futures::select! {
505 status = stream.read(buf).fuse() => status,
506 _ = timer => {
507 result.resize(written_total, 0); return Err(RequestError::DirTimeout);
509 }
510 };
511 let written_in_this_loop = match status {
512 Ok(n) => n,
513 Err(other) => {
514 result.resize(written_total, 0); return Err(other.into());
516 }
517 };
518
519 written_total += written_in_this_loop;
520
521 if written_in_this_loop == 0 {
524 if written_total < result.len() {
530 result.resize(written_total, 0);
531 }
532 return Ok(());
533 }
534
535 if written_total > maxlen {
541 result.resize(maxlen, 0);
542 return Err(RequestError::ResponseTooLong(written_total));
543 }
544 }
545}
546
547fn retire_circ<R>(circ_mgr: &Arc<CircMgr<R>>, id: &tor_proto::circuit::UniqId, error: &str)
549where
550 R: Runtime,
551{
552 info!(
553 "{}: Retiring circuit because of directory failure: {}",
554 &id, &error
555 );
556 circ_mgr.retire_circ(id);
557}
558
559const LZMA_DICT_MEM_LIMIT: u64 = 1 << 24; macro_rules! decoder {
585 (XzDecoder, $s:expr) => {{
586 let mut decoder = XzDecoder::with_mem_limit($s, LZMA_DICT_MEM_LIMIT);
587 decoder.multiple_members(true);
588 Ok(Box::new(decoder))
589 }};
590 ($dec:ident, $s:expr) => {{
591 let mut decoder = $dec::new($s);
592 decoder.multiple_members(true);
593 Ok(Box::new(decoder))
594 }};
595}
596
597fn get_decoder<'a, S: AsyncBufRead + Unpin + Send + 'a>(
600 stream: S,
601 encoding: Option<&str>,
602 anonymized: AnonymizedRequest,
603) -> RequestResult<Box<dyn AsyncRead + Unpin + Send + 'a>> {
604 use AnonymizedRequest::Direct;
605 match (encoding, anonymized) {
606 (None | Some("identity"), _) => Ok(Box::new(stream)),
607 (Some("deflate"), _) => decoder!(ZlibDecoder, stream),
608 #[cfg(feature = "xz")]
612 (Some("x-tor-lzma"), Direct) => decoder!(XzDecoder, stream),
613 #[cfg(feature = "zstd")]
614 (Some("x-zstd"), Direct) => decoder!(ZstdDecoder, stream),
615 (Some(other), _) => Err(RequestError::ContentEncoding(other.into())),
616 }
617}
618
619#[cfg(test)]
620mod test {
621 #![allow(clippy::bool_assert_comparison)]
623 #![allow(clippy::clone_on_copy)]
624 #![allow(clippy::dbg_macro)]
625 #![allow(clippy::mixed_attributes_style)]
626 #![allow(clippy::print_stderr)]
627 #![allow(clippy::print_stdout)]
628 #![allow(clippy::single_char_pattern)]
629 #![allow(clippy::unwrap_used)]
630 #![allow(clippy::unchecked_time_subtraction)]
631 #![allow(clippy::useless_vec)]
632 #![allow(clippy::needless_pass_by_value)]
633 #![allow(clippy::string_slice)] use super::*;
636 use tor_rtmock::io::stream_pair;
637
638 use tor_rtmock::simple_time::SimpleMockTimeProvider;
639 use web_time_compat::{SystemTime, SystemTimeExt};
640
641 use futures_await_test::async_test;
642
643 async fn decomp_basic(
645 encoding: Option<&str>,
646 data: &[u8],
647 maxlen: usize,
648 ) -> (RequestResult<()>, Vec<u8>) {
649 #[allow(deprecated)] let mock_time = SimpleMockTimeProvider::from_wallclock(SystemTime::get());
653
654 let mut output = Vec::new();
655 let mut stream = match get_decoder(data, encoding, AnonymizedRequest::Direct) {
656 Ok(s) => s,
657 Err(e) => return (Err(e), output),
658 };
659
660 let r = read_and_decompress(&mock_time, &mut stream, maxlen, &mut output).await;
661
662 (r, output)
663 }
664
665 #[async_test]
666 async fn decompress_identity() -> RequestResult<()> {
667 let mut text = Vec::new();
668 for _ in 0..1000 {
669 text.extend(b"This is a string with a nontrivial length that we'll use to make sure that the loop is executed more than once.");
670 }
671
672 let limit = 10 << 20;
673 let (s, r) = decomp_basic(None, &text[..], limit).await;
674 s?;
675 assert_eq!(r, text);
676
677 let (s, r) = decomp_basic(Some("identity"), &text[..], limit).await;
678 s?;
679 assert_eq!(r, text);
680
681 let limit = 100;
683 let (s, r) = decomp_basic(Some("identity"), &text[..], limit).await;
684 assert!(s.is_err());
685 assert_eq!(r, &text[..100]);
686
687 Ok(())
688 }
689
690 #[async_test]
691 async fn decomp_zlib() -> RequestResult<()> {
692 let compressed =
693 hex::decode("789cf3cf4b5548cb2cce500829cf8730825253200ca79c52881c00e5970c88").unwrap();
694
695 let limit = 10 << 20;
696 let (s, r) = decomp_basic(Some("deflate"), &compressed, limit).await;
697 s?;
698 assert_eq!(r, b"One fish Two fish Red fish Blue fish");
699
700 Ok(())
701 }
702
703 #[cfg(feature = "zstd")]
704 #[async_test]
705 async fn decomp_zstd() -> RequestResult<()> {
706 let compressed = hex::decode("28b52ffd24250d0100c84f6e6520666973682054776f526564426c756520666973680a0200600c0e2509478352cb").unwrap();
707 let limit = 10 << 20;
708 let (s, r) = decomp_basic(Some("x-zstd"), &compressed, limit).await;
709 s?;
710 assert_eq!(r, b"One fish Two fish Red fish Blue fish\n");
711
712 Ok(())
713 }
714
715 #[cfg(feature = "xz")]
716 #[async_test]
717 async fn decomp_xz() -> RequestResult<()> {
718 let compressed = hex::decode("fd377a585a000004e6d6b44604c02525210116000000000000000000bfdbca33e00024001d5d00279b88a202ca8612cfb3c19c87c34248a570451e4851d3323d34ab8000000000000901af64854c91f600014125281fe0821fb6f37d010000000004595a").unwrap();
720 let limit = LZMA_DICT_MEM_LIMIT as usize;
721 let (s, r) = decomp_basic(Some("x-tor-lzma"), &compressed, limit).await;
722 s?;
723 assert_eq!(r, b"One fish Two fish Red fish Blue fish\n");
724
725 Ok(())
726 }
727
728 #[cfg(feature = "xz")]
729 #[async_test]
730 async fn decomp_xz_bad() -> RequestResult<()> {
731 let compressed = hex::decode("fd377a585a000004e6d6b446020021011c00000010cf58cce00024001d5d00279b88a202ca8612cfb3c19c87c34248a570451e4851d3323d34ab8000000000000901af64854c91f600013925d6ec06651fb6f37d010000000004595a").unwrap();
733 let limit = 10 << 20;
734 let (s, _) = decomp_basic(Some("x-tor-lzma"), &compressed, limit).await;
735 assert!(matches!(s, Err(RequestError::IoError(_))));
736
737 Ok(())
738 }
739
740 #[async_test]
741 async fn decomp_unknown() {
742 let compressed = hex::decode("28b52ffd24250d0100c84f6e6520666973682054776f526564426c756520666973680a0200600c0e2509478352cb").unwrap();
743 let limit = 10 << 20;
744 let (s, _r) = decomp_basic(Some("x-proprietary-rle"), &compressed, limit).await;
745
746 assert!(matches!(s, Err(RequestError::ContentEncoding(_))));
747 }
748
749 #[async_test]
750 async fn decomp_bad_data() {
751 let compressed = b"This is not good zlib data";
752 let limit = 10 << 20;
753 let (s, _r) = decomp_basic(Some("deflate"), compressed, limit).await;
754
755 assert!(matches!(s, Err(RequestError::IoError(_))));
757 }
758
759 #[test]
760 fn headers_ok() -> RequestResult<()> {
761 let text = b"HTTP/1.0 200 OK\r\nDate: ignored\r\nContent-Encoding: Waffles\r\n\r\n";
762
763 let mut s = &text[..];
764 let h = tor_rtcompat::test_with_one_runtime!(async |rt| read_headers(&rt, &mut s).await)?;
765
766 assert_eq!(h.status, Some(200));
767 assert_eq!(h.encoding.as_deref(), Some("Waffles"));
768
769 let mut s = &text[..15];
771 let h = tor_rtcompat::test_with_one_runtime!(async |rt| read_headers(&rt, &mut s).await);
772 assert!(matches!(h, Err(RequestError::TruncatedHeaders)));
773
774 let text = b"HTTP/1.0 404 Not found\r\n\r\n";
776 let mut s = &text[..];
777 let h = tor_rtcompat::test_with_one_runtime!(async |rt| read_headers(&rt, &mut s).await)?;
778
779 assert_eq!(h.status, Some(404));
780 assert!(h.encoding.is_none());
781
782 Ok(())
783 }
784
785 #[test]
786 fn headers_bogus() {
787 let text = b"HTTP/999.0 WHAT EVEN\r\n\r\n";
788 let mut s = &text[..];
789 let h = tor_rtcompat::test_with_one_runtime!(async |rt| read_headers(&rt, &mut s).await);
790
791 assert!(h.is_err());
792 assert!(matches!(h, Err(RequestError::HttparseError(_))));
793 }
794
795 fn run_download_test<Req: request::Requestable>(
801 req: Req,
802 response: &[u8],
803 ) -> (Result<DirResponse>, RequestResult<Vec<u8>>) {
804 let (mut s1, s2) = stream_pair();
805 let (mut s2_r, mut s2_w) = s2.split();
806
807 tor_rtcompat::test_with_one_runtime!(|rt| async move {
808 let rt2 = rt.clone();
809 let (v1, v2, v3): (
810 Result<DirResponse>,
811 RequestResult<Vec<u8>>,
812 RequestResult<()>,
813 ) = futures::join!(
814 async {
815 let r = send_request(&rt, &req, &mut s1, None).await;
817 s1.close().await.map_err(|error| {
818 Error::RequestFailed(RequestFailedError {
819 source: None,
820 error: error.into(),
821 })
822 })?;
823 r
824 },
825 async {
826 let mut v = Vec::new();
828 s2_r.read_to_end(&mut v).await?;
829 Ok(v)
830 },
831 async {
832 s2_w.write_all(response).await?;
834 rt2.sleep(Duration::from_millis(50)).await;
847 s2_w.close().await?;
848 Ok(())
849 }
850 );
851
852 assert!(v3.is_ok());
853
854 (v1, v2)
855 })
856 }
857
858 #[test]
859 fn test_send_request() -> RequestResult<()> {
860 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
861
862 let (response, request) = run_download_test(
863 req,
864 b"HTTP/1.0 200 OK\r\n\r\nThis is where the descs would go.",
865 );
866
867 let request = request?;
868 assert!(request[..].starts_with(
869 b"GET /tor/micro/d/CQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQk HTTP/1.0\r\n"
870 ));
871
872 let response = response.unwrap();
873 assert_eq!(response.status_code(), 200);
874 assert!(!response.is_partial());
875 assert!(response.error().is_none());
876 assert!(response.source().is_none());
877 let out_ref = response.output_unchecked();
878 assert_eq!(out_ref, b"This is where the descs would go.");
879 let out = response.into_output_unchecked();
880 assert_eq!(&out, b"This is where the descs would go.");
881
882 Ok(())
883 }
884
885 #[test]
886 fn test_download_truncated() {
887 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
889 let mut response_text: Vec<u8> =
890 (*b"HTTP/1.0 200 OK\r\nContent-Encoding: deflate\r\n\r\n").into();
891 response_text.extend(
893 hex::decode("789cf3cf4b5548cb2cce500829cf8730825253200ca79c52881c00e5970c88").unwrap(),
894 );
895 response_text.extend(
896 hex::decode("789cf3cf4b5548cb2cce500829cf8730825253200ca79c52881c00e5").unwrap(),
897 );
898 let (response, request) = run_download_test(req, &response_text);
899 assert!(request.is_ok());
900 assert!(response.is_err()); let req: request::MicrodescRequest = vec![[9; 32]; 2].into_iter().collect();
904
905 let (response, request) = run_download_test(req, &response_text);
906 assert!(request.is_ok());
907
908 let response = response.unwrap();
909 assert_eq!(response.status_code(), 200);
910 assert!(response.error().is_some());
911 assert!(response.is_partial());
912 assert!(response.output_unchecked().len() < 37 * 2);
913 assert!(response.output_unchecked().starts_with(b"One fish"));
914 }
915
916 #[test]
917 fn test_404() {
918 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
919 let response_text = b"HTTP/1.0 418 I'm a teapot\r\n\r\n";
920 let (response, _request) = run_download_test(req, response_text);
921
922 assert_eq!(response.unwrap().status_code(), 418);
923 }
924
925 #[test]
926 fn test_headers_truncated() {
927 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
928 let response_text = b"HTTP/1.0 404 truncation happens here\r\n";
929 let (response, _request) = run_download_test(req, response_text);
930
931 assert!(matches!(
932 response,
933 Err(Error::RequestFailed(RequestFailedError {
934 error: RequestError::TruncatedHeaders,
935 ..
936 }))
937 ));
938
939 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
941 let response_text = b"";
942 let (response, _request) = run_download_test(req, response_text);
943
944 assert!(matches!(
945 response,
946 Err(Error::RequestFailed(RequestFailedError {
947 error: RequestError::TruncatedHeaders,
948 ..
949 }))
950 ));
951 }
952
953 #[test]
954 fn test_headers_too_long() {
955 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
956 let mut response_text: Vec<u8> = (*b"HTTP/1.0 418 I'm a teapot\r\nX-Too-Many-As: ").into();
957 response_text.resize(16384, b'A');
958 let (response, _request) = run_download_test(req, &response_text);
959
960 assert!(response.as_ref().unwrap_err().should_retire_circ());
961 assert!(matches!(
962 response,
963 Err(Error::RequestFailed(RequestFailedError {
964 error: RequestError::HeadersTooLong(_),
965 ..
966 }))
967 ));
968 }
969
970 #[test]
971 fn test_bad_utf8() {
972 let req: request::MicrodescRequest = vec![[9; 32]].into_iter().collect();
973 let faulty_utf8 = vec![0, 159, 146, 150];
974
975 let mut response_text: Vec<u8> = b"HTTP/1.0 200 OK\r\n\r\n".into();
976 response_text.extend(faulty_utf8);
977
978 let (response, _request) = run_download_test(req, &response_text);
979
980 assert!(matches!(
981 response.unwrap().into_output_string().unwrap_err(),
982 RequestFailedError {
983 error: RequestError::Utf8Encoding(_),
984 ..
985 }
986 ));
987 }
988}