#![deny(missing_docs)]
use std::{fmt, io};
use enum_as_inner::EnumAsInner;
use thiserror::Error;
use trust_dns_resolver::Name;
#[cfg(feature = "backtrace")]
use crate::proto::{trace, ExtBacktrace};
use crate::{
proto::error::ProtoError,
resolver::error::{ResolveError, ResolveErrorKind},
};
#[derive(Debug, EnumAsInner, Error)]
#[non_exhaustive]
pub enum ErrorKind {
#[error("{0}")]
Message(&'static str),
#[error("{0}")]
Msg(String),
#[error("forward response: {0}")]
Forward(Name),
#[error("io error: {0}")]
Io(#[from] std::io::Error),
#[error("proto error: {0}")]
Proto(#[from] ProtoError),
#[error("proto error: {0}")]
Resolve(ResolveError),
#[error("request timed out")]
Timeout,
}
#[derive(Error, Clone, Debug)]
#[non_exhaustive]
pub struct Error {
pub kind: Box<ErrorKind>,
#[cfg(feature = "backtrace")]
pub backtrack: Option<ExtBacktrace>,
}
impl Error {
pub fn kind(&self) -> &ErrorKind {
&self.kind
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
cfg_if::cfg_if! {
if #[cfg(feature = "backtrace")] {
if let Some(ref backtrace) = self.backtrack {
fmt::Display::fmt(&self.kind, f)?;
fmt::Debug::fmt(backtrace, f)
} else {
fmt::Display::fmt(&self.kind, f)
}
} else {
fmt::Display::fmt(&self.kind, f)
}
}
}
}
impl<E> From<E> for Error
where
E: Into<ErrorKind>,
{
fn from(error: E) -> Self {
let kind: ErrorKind = error.into();
Self {
kind: Box::new(kind),
#[cfg(feature = "backtrace")]
backtrack: trace!(),
}
}
}
impl From<&'static str> for Error {
fn from(msg: &'static str) -> Self {
ErrorKind::Message(msg).into()
}
}
impl From<String> for Error {
fn from(msg: String) -> Self {
ErrorKind::Msg(msg).into()
}
}
impl From<Error> for io::Error {
fn from(e: Error) -> Self {
match *e.kind() {
ErrorKind::Timeout => Self::new(io::ErrorKind::TimedOut, e),
_ => Self::new(io::ErrorKind::Other, e),
}
}
}
impl From<Error> for String {
fn from(e: Error) -> Self {
e.to_string()
}
}
impl From<ResolveError> for Error {
fn from(e: ResolveError) -> Self {
if let ResolveErrorKind::NoRecordsFound { soa, .. } = e.kind() {
match soa {
Some(soa) => ErrorKind::Forward(soa.name().clone()).into(),
_ => ErrorKind::Resolve(e).into(),
}
} else {
ErrorKind::Resolve(e).into()
}
}
}
impl Clone for ErrorKind {
fn clone(&self) -> Self {
use self::ErrorKind::*;
match *self {
Message(msg) => Message(msg),
Msg(ref msg) => Msg(msg.clone()),
Forward(ref ns) => Forward(ns.clone()),
Io(ref io) => Io(std::io::Error::from(io.kind())),
Proto(ref proto) => Proto(proto.clone()),
Resolve(ref resolve) => Resolve(resolve.clone()),
Timeout => Self::Timeout,
}
}
}
pub trait FromError: From<Error> + std::error::Error + Clone {}
impl<E> FromError for E where E: From<Error> + std::error::Error + Clone {}