use std::sync::Arc;
use thiserror::Error;
use tor_error::{ErrorKind, HasKind};
use tor_linkspec::OwnedChanTarget;
use tor_rtcompat::TimeoutError;
use crate::SourceInfo;
#[derive(Error, Debug, Clone)]
#[non_exhaustive]
#[allow(clippy::large_enum_variant)] pub enum Error {
#[error("Error while getting a circuit")]
CircMgr(#[from] tor_circmgr::Error),
#[error("Error fetching directory information")]
RequestFailed(#[from] RequestFailedError),
}
#[derive(Error, Debug, Clone)]
#[allow(clippy::exhaustive_structs)] #[error("Request failed{}", FromSource(.source))]
pub struct RequestFailedError {
pub source: Option<SourceInfo>,
#[source]
pub error: RequestError,
}
struct FromSource<'a>(&'a Option<SourceInfo>);
impl std::fmt::Display for FromSource<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(si) = self.0 {
write!(f, " from {}", si)
} else {
Ok(())
}
}
}
#[derive(Error, Debug, Clone)]
#[non_exhaustive]
pub enum RequestError {
#[error("directory timed out")]
DirTimeout,
#[error("truncated HTTP headers")]
TruncatedHeaders,
#[error("response too long; gave up after {0} bytes")]
ResponseTooLong(usize),
#[error("Couldn't decode data as UTF-8.")]
Utf8Encoding(#[from] std::string::FromUtf8Error),
#[error("IO error")]
IoError(#[source] Arc<std::io::Error>),
#[error("Protocol error while launching a stream")]
Proto(#[from] tor_proto::Error),
#[error("Couldn't parse HTTP headers")]
HttparseError(#[from] httparse::Error),
#[error("Couldn't create HTTP request")]
HttpError(#[source] Arc<http::Error>),
#[error("Unrecognized content encoding: {0:?}")]
ContentEncoding(String),
#[error("Too much clock skew with directory cache")]
TooMuchClockSkew,
#[error("We didn't have any objects to request")]
EmptyRequest,
#[error("HTTP status code {0}")]
HttpStatus(u16),
}
impl From<TimeoutError> for RequestError {
fn from(_: TimeoutError) -> Self {
RequestError::DirTimeout
}
}
impl From<std::io::Error> for RequestError {
fn from(err: std::io::Error) -> Self {
Self::IoError(Arc::new(err))
}
}
impl From<http::Error> for RequestError {
fn from(err: http::Error) -> Self {
Self::HttpError(Arc::new(err))
}
}
impl Error {
pub fn should_retire_circ(&self) -> bool {
match self {
Error::CircMgr(_) => true, Error::RequestFailed(RequestFailedError { error, .. }) => error.should_retire_circ(),
}
}
pub fn cache_ids(&self) -> Vec<&OwnedChanTarget> {
match &self {
Error::CircMgr(e) => e.peers(),
Error::RequestFailed(RequestFailedError {
source: Some(source),
..
}) => vec![source.cache_id()],
_ => Vec::new(),
}
}
}
impl RequestError {
pub fn should_retire_circ(&self) -> bool {
true
}
}
impl HasKind for RequestError {
fn kind(&self) -> ErrorKind {
use ErrorKind as EK;
use RequestError as E;
match self {
E::DirTimeout => EK::TorNetworkTimeout,
E::TruncatedHeaders => EK::TorProtocolViolation,
E::ResponseTooLong(_) => EK::TorProtocolViolation,
E::Utf8Encoding(_) => EK::TorProtocolViolation,
E::IoError(_) => EK::TorDirectoryError,
E::Proto(e) => e.kind(),
E::HttparseError(_) => EK::TorProtocolViolation,
E::HttpError(_) => EK::Internal,
E::ContentEncoding(_) => EK::TorProtocolViolation,
E::TooMuchClockSkew => EK::TorDirectoryError,
E::EmptyRequest => EK::Internal,
E::HttpStatus(_) => EK::TorDirectoryError,
}
}
}
impl HasKind for RequestFailedError {
fn kind(&self) -> ErrorKind {
self.error.kind()
}
}
impl HasKind for Error {
fn kind(&self) -> ErrorKind {
use Error as E;
match self {
E::CircMgr(e) => e.kind(),
E::RequestFailed(e) => e.kind(),
}
}
}