trust_dns_proto/
error.rs

1// Copyright 2015-2020 Benjamin Fry <benjaminfry@me.com>
2//
3// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
4// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
5// http://opensource.org/licenses/MIT>, at your option. This file may not be
6// copied, modified, or distributed except according to those terms.
7
8//! Error types for the crate
9
10#![deny(missing_docs)]
11
12use std::{fmt, io, sync};
13
14#[cfg(feature = "backtrace")]
15#[cfg_attr(docsrs, doc(cfg(feature = "backtrace")))]
16pub use backtrace::Backtrace as ExtBacktrace;
17use enum_as_inner::EnumAsInner;
18#[cfg(feature = "backtrace")]
19use once_cell::sync::Lazy;
20use thiserror::Error;
21
22use crate::op::Header;
23
24#[cfg(feature = "dnssec")]
25use crate::rr::dnssec::rdata::tsig::TsigAlgorithm;
26use crate::rr::{Name, RecordType};
27use crate::serialize::binary::DecodeError;
28
29/// Boolean for checking if backtrace is enabled at runtime
30#[cfg(feature = "backtrace")]
31#[cfg_attr(docsrs, doc(cfg(feature = "backtrace")))]
32pub static ENABLE_BACKTRACE: Lazy<bool> = Lazy::new(|| {
33    use std::env;
34    let bt = env::var("RUST_BACKTRACE");
35    matches!(bt.as_ref().map(|s| s as &str), Ok("full") | Ok("1"))
36});
37
38/// Generate a backtrace
39///
40/// If RUST_BACKTRACE is 1 or full then this will return Some(Backtrace), otherwise, NONE.
41#[cfg(feature = "backtrace")]
42#[cfg_attr(docsrs, doc(cfg(feature = "backtrace")))]
43#[macro_export]
44macro_rules! trace {
45    () => {{
46        use $crate::error::ExtBacktrace as Backtrace;
47
48        if *$crate::error::ENABLE_BACKTRACE {
49            Some(Backtrace::new())
50        } else {
51            None
52        }
53    }};
54}
55
56/// An alias for results returned by functions of this crate
57pub type ProtoResult<T> = ::std::result::Result<T, ProtoError>;
58
59/// The error kind for errors that get returned in the crate
60#[derive(Debug, EnumAsInner, Error)]
61#[non_exhaustive]
62pub enum ProtoErrorKind {
63    /// Query count is not one
64    #[error("there should only be one query per request, got: {0}")]
65    BadQueryCount(usize),
66
67    /// The underlying resource is too busy
68    ///
69    /// This is a signal that an internal resource is too busy. The intended action should be tried
70    /// again, ideally after waiting for a little while for the situation to improve. Alternatively,
71    /// the action could be tried on another resource (for example, in a name server pool).
72    #[error("resource too busy")]
73    Busy,
74
75    /// An error caused by a canceled future
76    #[error("future was canceled: {0:?}")]
77    Canceled(futures_channel::oneshot::Canceled),
78
79    /// Character data length exceeded the limit
80    #[error("char data length exceeds {max}: {len}")]
81    CharacterDataTooLong {
82        /// Specified maximum
83        max: usize,
84        /// Actual length
85        len: usize,
86    },
87
88    /// Overlapping labels
89    #[error("overlapping labels name {label} other {other}")]
90    LabelOverlapsWithOther {
91        /// Start of the label that is overlaps
92        label: usize,
93        /// Start of the other label
94        other: usize,
95    },
96
97    /// DNS protocol version doesn't have the expected version 3
98    #[error("dns key value unknown, must be 3: {0}")]
99    DnsKeyProtocolNot3(u8),
100
101    /// A domain name was too long
102    #[error("name label data exceed 255: {0}")]
103    DomainNameTooLong(usize),
104
105    /// EDNS resource record label is not the root label, although required
106    #[error("edns resource record label must be the root label (.): {0}")]
107    EdnsNameNotRoot(crate::rr::Name),
108
109    /// Format error in Message Parsing
110    #[error("message format error: {error}")]
111    FormError {
112        /// Header of the bad Message
113        header: Header,
114        /// Error that occured while parsing the Message
115        error: Box<ProtoError>,
116    },
117
118    /// An HMAC failed to verify
119    #[error("hmac validation failure")]
120    HmacInvalid(),
121
122    /// The length of rdata read was not as expected
123    #[error("incorrect rdata length read: {read} expected: {len}")]
124    IncorrectRDataLengthRead {
125        /// The amount of read data
126        read: usize,
127        /// The expected length of the data
128        len: usize,
129    },
130
131    /// Label bytes exceeded the limit of 63
132    #[error("label bytes exceed 63: {0}")]
133    LabelBytesTooLong(usize),
134
135    /// Label bytes exceeded the limit of 63
136    #[error("label points to data not prior to idx: {idx} ptr: {ptr}")]
137    PointerNotPriorToLabel {
138        /// index of the label containing this pointer
139        idx: usize,
140        /// location to which the pointer is directing
141        ptr: u16,
142    },
143
144    /// The maximum buffer size was exceeded
145    #[error("maximum buffer size exceeded: {0}")]
146    MaxBufferSizeExceeded(usize),
147
148    /// An error with an arbitrary message, referenced as &'static str
149    #[error("{0}")]
150    Message(&'static str),
151
152    /// An error with an arbitrary message, stored as String
153    #[error("{0}")]
154    Msg(String),
155
156    /// No error was specified
157    #[error("no error specified")]
158    NoError,
159
160    /// Not all records were able to be written
161    #[error("not all records could be written, wrote: {count}")]
162    NotAllRecordsWritten {
163        /// Number of records that were written before the error
164        count: usize,
165    },
166
167    /// Missing rrsigs
168    #[error("rrsigs are not present for record set name: {name} record_type: {record_type}")]
169    RrsigsNotPresent {
170        /// The record set name
171        name: Name,
172        /// The record type
173        record_type: RecordType,
174    },
175
176    /// An unknown algorithm type was found
177    #[error("algorithm type value unknown: {0}")]
178    UnknownAlgorithmTypeValue(u8),
179
180    /// An unknown dns class was found
181    #[error("dns class string unknown: {0}")]
182    UnknownDnsClassStr(String),
183
184    /// An unknown dns class value was found
185    #[error("dns class value unknown: {0}")]
186    UnknownDnsClassValue(u16),
187
188    /// An unknown record type string was found
189    #[error("record type string unknown: {0}")]
190    UnknownRecordTypeStr(String),
191
192    /// An unknown record type value was found
193    #[error("record type value unknown: {0}")]
194    UnknownRecordTypeValue(u16),
195
196    /// An unrecognized label code was found
197    #[error("unrecognized label code: {0:b}")]
198    UnrecognizedLabelCode(u8),
199
200    /// Unrecognized nsec3 flags were found
201    #[error("nsec3 flags should be 0b0000000*: {0:b}")]
202    UnrecognizedNsec3Flags(u8),
203
204    /// Unrecognized csync flags were found
205    #[error("csync flags should be 0b000000**: {0:b}")]
206    UnrecognizedCsyncFlags(u16),
207
208    // foreign
209    /// An error got returned from IO
210    #[error("io error: {0}")]
211    Io(io::Error),
212
213    /// Any sync poised error
214    #[error("lock poisoned error")]
215    Poisoned,
216
217    /// A ring error
218    #[error("ring error: {0}")]
219    Ring(#[from] Unspecified),
220
221    /// An ssl error
222    #[error("ssl error: {0}")]
223    SSL(#[from] SslErrorStack),
224
225    /// A tokio timer error
226    #[error("timer error")]
227    Timer,
228
229    /// A request timed out
230    #[error("request timed out")]
231    Timeout,
232
233    /// Tsig key verification failed
234    #[error("Tsig key wrong key error")]
235    TsigWrongKey,
236
237    /// Tsig unsupported mac algorithm
238    /// Supported algorithm documented in `TsigAlgorithm::supported` function.
239    #[cfg(feature = "dnssec")]
240    #[error("Tsig unsupported mac algorithm")]
241    TsigUnsupportedMacAlgorithm(TsigAlgorithm),
242
243    /// An url parsing error
244    #[error("url parsing error")]
245    UrlParsing(#[from] url::ParseError),
246
247    /// A utf8 parsing error
248    #[error("error parsing utf8 string")]
249    Utf8(#[from] std::str::Utf8Error),
250
251    /// A utf8 parsing error
252    #[error("error parsing utf8 string")]
253    FromUtf8(#[from] std::string::FromUtf8Error),
254
255    /// An int parsing error
256    #[error("error parsing int")]
257    ParseInt(#[from] std::num::ParseIntError),
258
259    /// A Quinn (Quic) connection error occurred
260    #[cfg(feature = "quinn")]
261    #[error("error creating quic connection: {0}")]
262    QuinnConnect(#[from] quinn::ConnectError),
263
264    /// A Quinn (QUIC) connection error occurred
265    #[cfg(feature = "quinn")]
266    #[error("error with quic connection: {0}")]
267    QuinnConnection(#[from] quinn::ConnectionError),
268
269    /// A Quinn (QUIC) write error occurred
270    #[cfg(feature = "quinn")]
271    #[error("error writing to quic connection: {0}")]
272    QuinnWriteError(#[from] quinn::WriteError),
273
274    /// A Quinn (QUIC) read error occurred
275    #[cfg(feature = "quinn")]
276    #[error("error writing to quic read: {0}")]
277    QuinnReadError(#[from] quinn::ReadExactError),
278
279    /// A Quinn (QUIC) configuration error occurred
280    #[cfg(feature = "quinn")]
281    #[error("error constructing quic configuration: {0}")]
282    QuinnConfigError(#[from] quinn::ConfigError),
283
284    /// Unknown QUIC stream used
285    #[cfg(feature = "quinn")]
286    #[error("an unknown quic stream was used")]
287    QuinnUnknownStreamError,
288
289    /// A quic message id should always be 0
290    #[cfg(feature = "quinn")]
291    #[error("quic messages should always be 0, got: {0}")]
292    QuicMessageIdNot0(u16),
293
294    /// A Rustls error occurred
295    #[cfg(feature = "rustls")]
296    #[error("rustls construction error: {0}")]
297    RustlsError(#[from] rustls::Error),
298}
299
300/// The error type for errors that get returned in the crate
301#[derive(Error, Clone, Debug)]
302#[non_exhaustive]
303pub struct ProtoError {
304    /// Kind of error that ocurred
305    pub kind: Box<ProtoErrorKind>,
306    /// Backtrace to the source of the error
307    #[cfg(feature = "backtrace")]
308    pub backtrack: Option<ExtBacktrace>,
309}
310
311impl ProtoError {
312    /// Get the kind of the error
313    pub fn kind(&self) -> &ProtoErrorKind {
314        &self.kind
315    }
316
317    /// If this is a ProtoErrorKind::Busy
318    pub fn is_busy(&self) -> bool {
319        matches!(*self.kind, ProtoErrorKind::Busy)
320    }
321
322    pub(crate) fn as_dyn(&self) -> &(dyn std::error::Error + 'static) {
323        self
324    }
325}
326
327impl fmt::Display for ProtoError {
328    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
329        cfg_if::cfg_if! {
330            if #[cfg(feature = "backtrace")] {
331                if let Some(ref backtrace) = self.backtrack {
332                    fmt::Display::fmt(&self.kind, f)?;
333                    fmt::Debug::fmt(backtrace, f)
334                } else {
335                    fmt::Display::fmt(&self.kind, f)
336                }
337            } else {
338                fmt::Display::fmt(&self.kind, f)
339            }
340        }
341    }
342}
343
344impl<E> From<E> for ProtoError
345where
346    E: Into<ProtoErrorKind>,
347{
348    fn from(error: E) -> Self {
349        let kind: ProtoErrorKind = error.into();
350
351        Self {
352            kind: Box::new(kind),
353            #[cfg(feature = "backtrace")]
354            backtrack: trace!(),
355        }
356    }
357}
358
359impl From<DecodeError> for ProtoError {
360    fn from(err: DecodeError) -> Self {
361        match err {
362            DecodeError::PointerNotPriorToLabel { idx, ptr } => {
363                ProtoErrorKind::PointerNotPriorToLabel { idx, ptr }
364            }
365            DecodeError::LabelBytesTooLong(len) => ProtoErrorKind::LabelBytesTooLong(len),
366            DecodeError::UnrecognizedLabelCode(code) => ProtoErrorKind::UnrecognizedLabelCode(code),
367            DecodeError::DomainNameTooLong(len) => ProtoErrorKind::DomainNameTooLong(len),
368            DecodeError::LabelOverlapsWithOther { label, other } => {
369                ProtoErrorKind::LabelOverlapsWithOther { label, other }
370            }
371            _ => ProtoErrorKind::Msg(err.to_string()),
372        }
373        .into()
374    }
375}
376
377impl From<&'static str> for ProtoError {
378    fn from(msg: &'static str) -> Self {
379        ProtoErrorKind::Message(msg).into()
380    }
381}
382
383impl From<String> for ProtoError {
384    fn from(msg: String) -> Self {
385        ProtoErrorKind::Msg(msg).into()
386    }
387}
388
389impl From<io::Error> for ProtoErrorKind {
390    fn from(e: io::Error) -> Self {
391        match e.kind() {
392            io::ErrorKind::TimedOut => Self::Timeout,
393            _ => Self::Io(e),
394        }
395    }
396}
397
398impl<T> From<sync::PoisonError<T>> for ProtoError {
399    fn from(_e: sync::PoisonError<T>) -> Self {
400        ProtoErrorKind::Poisoned.into()
401    }
402}
403
404impl From<ProtoError> for io::Error {
405    fn from(e: ProtoError) -> Self {
406        match *e.kind() {
407            ProtoErrorKind::Timeout => Self::new(io::ErrorKind::TimedOut, e),
408            _ => Self::new(io::ErrorKind::Other, e),
409        }
410    }
411}
412
413impl From<ProtoError> for String {
414    fn from(e: ProtoError) -> Self {
415        e.to_string()
416    }
417}
418
419#[cfg(feature = "wasm-bindgen")]
420#[cfg_attr(docsrs, doc(cfg(feature = "wasm-bindgen")))]
421impl From<ProtoError> for wasm_bindgen_crate::JsValue {
422    fn from(e: ProtoError) -> Self {
423        js_sys::Error::new(&e.to_string()).into()
424    }
425}
426
427impl Clone for ProtoErrorKind {
428    fn clone(&self) -> Self {
429        use self::ProtoErrorKind::*;
430        match *self {
431            BadQueryCount(count) => BadQueryCount(count),
432            Busy => Busy,
433            Canceled(ref c) => Canceled(*c),
434            CharacterDataTooLong { max, len } => CharacterDataTooLong { max, len },
435            LabelOverlapsWithOther { label, other } => LabelOverlapsWithOther { label, other },
436            DnsKeyProtocolNot3(protocol) => DnsKeyProtocolNot3(protocol),
437            DomainNameTooLong(len) => DomainNameTooLong(len),
438            EdnsNameNotRoot(ref found) => EdnsNameNotRoot(found.clone()),
439            FormError { header, ref error } => FormError {
440                header,
441                error: error.clone(),
442            },
443            HmacInvalid() => HmacInvalid(),
444            IncorrectRDataLengthRead { read, len } => IncorrectRDataLengthRead { read, len },
445            LabelBytesTooLong(len) => LabelBytesTooLong(len),
446            PointerNotPriorToLabel { idx, ptr } => PointerNotPriorToLabel { idx, ptr },
447            MaxBufferSizeExceeded(max) => MaxBufferSizeExceeded(max),
448            Message(msg) => Message(msg),
449            Msg(ref msg) => Msg(msg.clone()),
450            NoError => NoError,
451            NotAllRecordsWritten { count } => NotAllRecordsWritten { count },
452            RrsigsNotPresent {
453                ref name,
454                ref record_type,
455            } => RrsigsNotPresent {
456                name: name.clone(),
457                record_type: *record_type,
458            },
459            UnknownAlgorithmTypeValue(value) => UnknownAlgorithmTypeValue(value),
460            UnknownDnsClassStr(ref value) => UnknownDnsClassStr(value.clone()),
461            UnknownDnsClassValue(value) => UnknownDnsClassValue(value),
462            UnknownRecordTypeStr(ref value) => UnknownRecordTypeStr(value.clone()),
463            UnknownRecordTypeValue(value) => UnknownRecordTypeValue(value),
464            UnrecognizedLabelCode(value) => UnrecognizedLabelCode(value),
465            UnrecognizedNsec3Flags(flags) => UnrecognizedNsec3Flags(flags),
466            UnrecognizedCsyncFlags(flags) => UnrecognizedCsyncFlags(flags),
467
468            // foreign
469            Io(ref e) => Io(if let Some(raw) = e.raw_os_error() {
470                io::Error::from_raw_os_error(raw)
471            } else {
472                io::Error::from(e.kind())
473            }),
474            Poisoned => Poisoned,
475            Ring(ref _e) => Ring(Unspecified),
476            SSL(ref e) => Msg(format!("there was an SSL error: {e}")),
477            Timeout => Timeout,
478            Timer => Timer,
479            #[cfg(feature = "dnssec")]
480            TsigUnsupportedMacAlgorithm(ref alg) => TsigUnsupportedMacAlgorithm(alg.clone()),
481            TsigWrongKey => TsigWrongKey,
482            UrlParsing(ref e) => UrlParsing(*e),
483            Utf8(ref e) => Utf8(*e),
484            FromUtf8(ref e) => FromUtf8(e.clone()),
485            ParseInt(ref e) => ParseInt(e.clone()),
486            #[cfg(feature = "quinn")]
487            QuinnConnect(ref e) => QuinnConnect(e.clone()),
488            #[cfg(feature = "quinn")]
489            QuinnConnection(ref e) => QuinnConnection(e.clone()),
490            #[cfg(feature = "quinn")]
491            QuinnWriteError(ref e) => QuinnWriteError(e.clone()),
492            #[cfg(feature = "quinn")]
493            QuicMessageIdNot0(val) => QuicMessageIdNot0(val),
494            #[cfg(feature = "quinn")]
495            QuinnReadError(ref e) => QuinnReadError(e.clone()),
496            #[cfg(feature = "quinn")]
497            QuinnConfigError(ref e) => QuinnConfigError(e.clone()),
498            #[cfg(feature = "quinn")]
499            QuinnUnknownStreamError => QuinnUnknownStreamError,
500            #[cfg(feature = "rustls")]
501            RustlsError(ref e) => RustlsError(e.clone()),
502        }
503    }
504}
505
506/// A trait marking a type which implements From<ProtoError> and
507/// std::error::Error types as well as Clone + Send
508pub trait FromProtoError: From<ProtoError> + std::error::Error + Clone {}
509
510impl<E> FromProtoError for E where E: From<ProtoError> + std::error::Error + Clone {}
511
512#[cfg(not(feature = "openssl"))]
513use self::not_openssl::SslErrorStack;
514#[cfg(not(feature = "ring"))]
515use self::not_ring::{KeyRejected, Unspecified};
516#[cfg(feature = "openssl")]
517use openssl::error::ErrorStack as SslErrorStack;
518#[cfg(feature = "ring")]
519use ring::error::{KeyRejected, Unspecified};
520
521/// An alias for dnssec results returned by functions of this crate
522pub type DnsSecResult<T> = ::std::result::Result<T, DnsSecError>;
523
524/// The error kind for dnssec errors that get returned in the crate
525#[allow(unreachable_pub)]
526#[derive(Debug, Error)]
527#[non_exhaustive]
528pub enum DnsSecErrorKind {
529    /// An error with an arbitrary message, referenced as &'static str
530    #[error("{0}")]
531    Message(&'static str),
532
533    /// An error with an arbitrary message, stored as String
534    #[error("{0}")]
535    Msg(String),
536
537    // foreign
538    /// An error got returned by the trust-dns-proto crate
539    #[error("proto error: {0}")]
540    Proto(#[from] ProtoError),
541
542    /// A ring error
543    #[error("ring error: {0}")]
544    RingKeyRejected(#[from] KeyRejected),
545
546    /// A ring error
547    #[error("ring error: {0}")]
548    RingUnspecified(#[from] Unspecified),
549
550    /// An ssl error
551    #[error("ssl error: {0}")]
552    SSL(#[from] SslErrorStack),
553
554    /// A request timed out
555    #[error("request timed out")]
556    Timeout,
557}
558
559impl Clone for DnsSecErrorKind {
560    fn clone(&self) -> Self {
561        use DnsSecErrorKind::*;
562        match self {
563            Message(msg) => Message(msg),
564            Msg(ref msg) => Msg(msg.clone()),
565
566            // foreign
567            Proto(proto) => Proto(proto.clone()),
568            RingKeyRejected(r) => Msg(format!("Ring rejected key: {r}")),
569            RingUnspecified(_r) => RingUnspecified(Unspecified),
570            SSL(ssl) => Msg(format!("SSL had an error: {ssl}")),
571            Timeout => Timeout,
572        }
573    }
574}
575
576/// The error type for dnssec errors that get returned in the crate
577#[derive(Debug, Clone, Error)]
578pub struct DnsSecError {
579    kind: DnsSecErrorKind,
580    #[cfg(feature = "backtrace")]
581    backtrack: Option<ExtBacktrace>,
582}
583
584impl DnsSecError {
585    /// Get the kind of the error
586    pub fn kind(&self) -> &DnsSecErrorKind {
587        &self.kind
588    }
589}
590
591impl fmt::Display for DnsSecError {
592    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
593        cfg_if::cfg_if! {
594            if #[cfg(feature = "backtrace")] {
595                if let Some(ref backtrace) = self.backtrack {
596                    fmt::Display::fmt(&self.kind, f)?;
597                    fmt::Debug::fmt(backtrace, f)
598                } else {
599                    fmt::Display::fmt(&self.kind, f)
600                }
601            } else {
602                fmt::Display::fmt(&self.kind, f)
603            }
604        }
605    }
606}
607
608impl From<DnsSecErrorKind> for DnsSecError {
609    fn from(kind: DnsSecErrorKind) -> Self {
610        Self {
611            kind,
612            #[cfg(feature = "backtrace")]
613            backtrack: trace!(),
614        }
615    }
616}
617
618impl From<&'static str> for DnsSecError {
619    fn from(msg: &'static str) -> Self {
620        DnsSecErrorKind::Message(msg).into()
621    }
622}
623
624impl From<String> for DnsSecError {
625    fn from(msg: String) -> Self {
626        DnsSecErrorKind::Msg(msg).into()
627    }
628}
629
630impl From<ProtoError> for DnsSecError {
631    fn from(e: ProtoError) -> Self {
632        match *e.kind() {
633            ProtoErrorKind::Timeout => DnsSecErrorKind::Timeout.into(),
634            _ => DnsSecErrorKind::from(e).into(),
635        }
636    }
637}
638
639impl From<KeyRejected> for DnsSecError {
640    fn from(e: KeyRejected) -> Self {
641        DnsSecErrorKind::from(e).into()
642    }
643}
644
645impl From<Unspecified> for DnsSecError {
646    fn from(e: Unspecified) -> Self {
647        DnsSecErrorKind::from(e).into()
648    }
649}
650
651impl From<SslErrorStack> for DnsSecError {
652    fn from(e: SslErrorStack) -> Self {
653        DnsSecErrorKind::from(e).into()
654    }
655}
656
657#[doc(hidden)]
658#[allow(unreachable_pub)]
659#[cfg(not(feature = "openssl"))]
660#[cfg_attr(docsrs, doc(cfg(not(feature = "openssl"))))]
661pub mod not_openssl {
662    use std;
663
664    #[derive(Clone, Copy, Debug)]
665    pub struct SslErrorStack;
666
667    impl std::fmt::Display for SslErrorStack {
668        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
669            Ok(())
670        }
671    }
672
673    impl std::error::Error for SslErrorStack {
674        fn description(&self) -> &str {
675            "openssl feature not enabled"
676        }
677    }
678}
679
680#[doc(hidden)]
681#[allow(unreachable_pub)]
682#[cfg(not(feature = "ring"))]
683#[cfg_attr(docsrs, doc(cfg(feature = "ring")))]
684pub mod not_ring {
685    use std;
686
687    #[derive(Clone, Copy, Debug)]
688    pub struct KeyRejected;
689
690    #[derive(Clone, Copy, Debug)]
691    pub struct Unspecified;
692
693    impl std::fmt::Display for KeyRejected {
694        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
695            Ok(())
696        }
697    }
698
699    impl std::error::Error for KeyRejected {
700        fn description(&self) -> &str {
701            "ring feature not enabled"
702        }
703    }
704
705    impl std::fmt::Display for Unspecified {
706        fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
707            Ok(())
708        }
709    }
710
711    impl std::error::Error for Unspecified {
712        fn description(&self) -> &str {
713            "ring feature not enabled"
714        }
715    }
716}
trust_dns_proto/error.rs

trust_dns_proto/
error.rs
