Introduce OctetsFrom and OctetsInto.

Changelog.md

@@ -12,6 +12,11 @@ Breaking
   `domain::base::octets::OctetsBuilder`. It’s method `into_octets` is now
   available as `freeze` on `OctetsBuilder. ([#75])
 
+* Supprt for extended errors defined in [RFC 8914]. ([#79] by [@xofyarg])
+* New traits `domain::base::octets::OctetsFrom` and `OctetsInto` to
+  convert types that are generic over octets sequences between different
+  octets sequences. ([#77])
+
 Bug Fixes
 
 * Fix domain name compressors when giving a root label only. ([#76]
@@ -20,15 +25,22 @@ Bug Fixes
   by [@vavrusa])
 * Fix canonical comparison of TXT RDATA by taking the length labels into
   account. ([#76] by [@vavrusa])
+* Fix parsed not rejecting of malformed TXT RDATA. ([#80] by [@vavrusa])
 
 New
 
+
 Other Changes
 
 [#74]: https://github.com/NLnetLabs/domain/pull/74
 [#75]: https://github.com/NLnetLabs/domain/pull/75
 [#76]: https://github.com/NLnetLabs/domain/pull/76
+[#77]: https://github.com/NLnetLabs/domain/pull/77
+[#79]: https://github.com/NLnetLabs/domain/pull/79
+[#80]: https://github.com/NLnetLabs/domain/pull/80
 [@vavrusa]: https://github.com/vavrusa
+[@xofyarg]: https://github.com/xofyarg
+[RFC 8914]: https://tools.ietf.org/html/rfc8914
 
 
 ## 0.5.3

src/base/charstr.rs

@@ -33,8 +33,8 @@ use core::{cmp, fmt, hash, ops, str};
 };
 use super::cmp::CanonicalOrd;
 use super::octets::{
-    Compose, EmptyBuilder, FromBuilder, IntoBuilder, OctetsBuilder, OctetsRef,
-    Parse, ParseError, Parser, ShortBuf
+    Compose, EmptyBuilder, FromBuilder, IntoBuilder, OctetsBuilder, OctetsFrom,
+    OctetsRef, Parse, ParseError, Parser, ShortBuf
 };
 use super::str::{BadSymbol, Symbol, SymbolError};
 
@@ -163,6 +163,20 @@ impl CharStr<[u8]> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets> OctetsFrom<CharStr<SrcOctets>> for CharStr<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(source: CharStr<SrcOctets>) -> Result<Self, ShortBuf> {
+        Octets::octets_from(source.0).map(|octets| {
+            unsafe {
+                Self::from_octets_unchecked(octets)
+            }
+        })
+    }
+}
+
+
 //--- FromStr
 
 impl<Octets> str::FromStr for CharStr<Octets>

src/base/message.rs

@@ -17,7 +17,7 @@ use super::iana::{Class, Rcode, Rtype};
 use super::message_builder::{AdditionalBuilder, AnswerBuilder};
 use super::name::ParsedDname;
 use super::octets::{
-    OctetsBuilder, OctetsRef, Parse, ParseError, Parser, ShortBuf
+    OctetsBuilder, OctetsFrom, OctetsRef, Parse, ParseError, Parser, ShortBuf
 };
 use super::opt::{Opt, OptRecord};
 use super::question::Question;
@@ -597,6 +597,20 @@ impl<Octets: AsRef<[u8]>> AsRef<[u8]> for Message<Octets> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets> OctetsFrom<Message<SrcOctets>> for Message<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(source: Message<SrcOctets>) -> Result<Self, ShortBuf> {
+        Octets::octets_from(source.octets).map(|octets| {
+            unsafe {
+                Self::from_octets_unchecked(octets)
+            }
+        })
+    }
+}
+
+
 //--- IntoIterator
 
 impl<'a, Octets> IntoIterator for &'a Message<Octets>

src/base/name/dname.rs

@@ -12,7 +12,7 @@ use core::str::FromStr;
 use super::super::cmp::CanonicalOrd;
 use super::super::octets::{
     Compose, EmptyBuilder, FormError, FromBuilder, OctetsBuilder, OctetsExt,
-    OctetsRef, Parse, Parser, ParseError, ShortBuf
+    OctetsFrom, OctetsRef, Parse, Parser, ParseError, ShortBuf
 };
 use super::builder::{DnameBuilder, FromStrError};
 use super::label::{Label, LabelTypeError, SplitLabelError};
@@ -588,6 +588,20 @@ impl<Octets: AsRef<T> + ?Sized, T: ?Sized> AsRef<T> for Dname<Octets> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets> OctetsFrom<Dname<SrcOctets>> for Dname<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(source: Dname<SrcOctets>) -> Result<Self, ShortBuf> {
+        Octets::octets_from(source.0).map(|octets| {
+            unsafe {
+                Self::from_octets_unchecked(octets)
+            }
+        })
+    }
+}
+
+
 //--- FromStr
 
 impl<Octets> FromStr for Dname<Octets>

src/base/name/relative.rs

@@ -7,8 +7,8 @@ use core::cmp::Ordering;
 #[cfg(feature = "std")] use std::vec::Vec;
 #[cfg(feature = "bytes")] use bytes::Bytes;
 use super::super::octets::{
-    Compose, IntoBuilder, OctetsBuilder, OctetsExt, OctetsRef, ParseError,
-    ShortBuf
+    Compose, IntoBuilder, OctetsBuilder, OctetsExt, OctetsFrom, OctetsRef,
+    ParseError, ShortBuf
 };
 use super::builder::{DnameBuilder, PushError};
 use super::chain::{Chain, LongChainError};
@@ -569,6 +569,21 @@ impl<Octets: AsRef<T> + ?Sized, T: ?Sized> AsRef<T> for RelativeDname<Octets> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets>
+OctetsFrom<RelativeDname<SrcOctets>> for RelativeDname<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(source: RelativeDname<SrcOctets>) -> Result<Self, ShortBuf> {
+        Octets::octets_from(source.0).map(|octets| {
+            unsafe {
+                Self::from_octets_unchecked(octets)
+            }
+        })
+    }
+}
+
+
 //--- ToLabelIter and ToRelativeDname
 
 impl<'a, Octets> ToLabelIter<'a> for RelativeDname<Octets>

src/base/octets.rs

@@ -313,6 +313,86 @@ impl<'a, A: Array<Item = u8>> OctetsRef for &'a SmallVec<A> {
 }
 
 
+//------------ OctetsFrom ----------------------------------------------------
+
+/// Convert a type from one octets type to another.
+///
+/// This trait allows creating a value of a type that is generic over an
+/// octets sequence from an identical value using a different type of octets
+/// sequence.
+///
+/// This is different from just `From` in that the conversion may fail if the
+/// source sequence is longer than the space available for the target type.
+pub trait OctetsFrom<Source>: Sized {
+    /// Performs the conversion.
+    fn octets_from(source: Source) -> Result<Self, ShortBuf>;
+}
+
+
+impl<'a, Source: AsRef<[u8]> + 'a> OctetsFrom<&'a Source> for &'a [u8] {
+    fn octets_from(source: &'a Source) -> Result<Self, ShortBuf> {
+        Ok(source.as_ref())
+    }
+}
+
+#[cfg(feature = "std")]
+impl<Source> OctetsFrom<Source> for Vec<u8>
+where Self: From<Source> {
+    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
+        Ok(From::from(source))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl<Source> OctetsFrom<Source> for Bytes
+where Self: From<Source> {
+    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
+        Ok(From::from(source))
+    }
+}
+
+#[cfg(feature = "bytes")]
+impl<Source> OctetsFrom<Source> for BytesMut
+where Self: From<Source> {
+    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
+        Ok(From::from(source))
+    }
+}
+
+#[cfg(features = "smallvec")]
+impl<Source, A> OctetsFrom<Source> for SmallVec<A>
+where Source: AsRef<u8>, A: Array<Item = u8> {
+    fn octets_from(source: Source) -> Result<Self, ShortBuf> {
+        Ok(smallvec::ToSmallVec::to_smallvec(source.as_ref()))
+    }
+}
+
+
+//------------ OctetsInto ----------------------------------------------------
+
+/// Convert a type from one octets type to another.
+///
+/// This trait allows trading in a value of a type that is generic over an
+/// octets sequence for an identical value using a different type of octets
+/// sequence.
+///
+/// This is different from just `Into` in that the conversion may fail if the
+/// source sequence is longer than the space available for the target type.
+///
+/// This trait has a blanket implementation for all pairs of types where 
+/// `OctetsFrom` has been implemented.
+pub trait OctetsInto<Target> {
+    /// Performs the conversion.
+    fn octets_into(self) -> Result<Target, ShortBuf>;
+}
+
+impl<Source, Target: OctetsFrom<Source>> OctetsInto<Target> for Source {
+    fn octets_into(self) -> Result<Target, ShortBuf> {
+        Target::octets_from(self)
+    }
+}
+
+
 //------------ OctetsBuilder -------------------------------------------------
 
 /// A buffer to construct an octet sequence.
@@ -557,11 +637,6 @@ impl<A: Array<Item = u8>> EmptyBuilder for SmallVec<A> {
 /// An octets type that can be converted into an octets builder.
 pub trait IntoBuilder {
     /// The type of octets builder this octets type can be converted into.
-    ///
-    /// If `Builder` implements [`IntoOctets`], the `Octets` associated
-    /// type of that trait must be `Self`.
-    ///
-    /// [`IntoOctets`]: trait.IntoOctets.html
     type Builder: OctetsBuilder;
 
     /// Converts an octets value into an octets builder.
@@ -620,12 +695,6 @@ impl<A: Array<Item = u8>> IntoBuilder for SmallVec<A> {
 //------------ FromBuilder ---------------------------------------------------
 
 /// An octets type that can be created from an octets builder.
-///
-/// This trait is a mirror of [`IntoOctets`] and only exists because otherwise
-/// trait bounds become ridiculously complex. The implementations of the two
-/// traits must behave identically.
-///
-/// [`IntoOctets`]: trait.IntoOctets.html
 pub trait FromBuilder: AsRef<[u8]> + Sized {
     /// The type of builder this octets type can be created from.
     type Builder: OctetsBuilder<Octets = Self>;

src/base/opt/mod.rs

@@ -47,7 +47,8 @@ use super::iana::{OptionCode, OptRcode, Rtype};
 use super::header::Header;
 use super::name::ToDname;
 use super::octets::{
-    Compose, OctetsBuilder, OctetsRef, Parse, ParseError, Parser, ShortBuf
+    Compose, OctetsBuilder, OctetsFrom, OctetsRef, Parse, ParseError, Parser,
+    ShortBuf
 };
 use super::rdata::RtypeRecordData;
 use super::record::Record;
@@ -104,6 +105,16 @@ impl<Octets: AsRef<[u8]>> Opt<Octets> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets> OctetsFrom<Opt<SrcOctets>> for Opt<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(source: Opt<SrcOctets>) -> Result<Self, ShortBuf> {
+        Octets::octets_from(source.octets).map(|octets| Opt { octets })
+    }
+}
+
+
 //--- PartialEq and Eq
 
 impl<Octets, Other> PartialEq<Opt<Other>> for Opt<Octets>
@@ -410,6 +421,22 @@ impl<Octets, N: ToDname> From<Record<N, Opt<Octets>>> for OptRecord<Octets> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets> OctetsFrom<OptRecord<SrcOctets>> for OptRecord<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(source: OptRecord<SrcOctets>) -> Result<Self, ShortBuf> {
+        Ok(OptRecord {
+            udp_payload_size: source.udp_payload_size,
+            ext_rcode: source.ext_rcode,
+            version: source.version,
+            flags: source.flags,
+            data: Opt::octets_from(source.data)?,
+        })
+    }
+}
+
+
 //--- Deref and AsRef
 
 impl<Octets> ops::Deref for OptRecord<Octets> {

src/base/question.rs

@@ -10,7 +10,8 @@ use super::cmp::CanonicalOrd;
 use super::iana::{Class, Rtype};
 use super::name::{ParsedDname, ToDname};
 use super::octets::{
-    Compose, OctetsBuilder, OctetsRef, Parse, Parser, ParseError, ShortBuf
+    Compose, OctetsBuilder, OctetsFrom, OctetsRef, Parse, Parser, ParseError,
+    ShortBuf
 };
 
 
@@ -42,7 +43,7 @@ pub struct Question<N> {
 
 /// # Creation and Conversion
 ///
-impl<N: ToDname> Question<N> {
+impl<N> Question<N> {
     /// Creates a new question from its three componets.
     pub fn new(qname: N, qtype: Rtype, qclass: Class) -> Self {
         Question { qname, qtype, qclass }
@@ -95,6 +96,19 @@ impl<N: ToDname> From<(N, Rtype)> for Question<N> {
 }
 
 
+//--- OctetsFrom
+
+impl<Name, SrcName> OctetsFrom<Question<SrcName>> for Question<Name>
+where Name: OctetsFrom<SrcName> {
+    fn octets_from(source: Question<SrcName>) -> Result<Self, ShortBuf> {
+        Ok(Question::new(
+            Name::octets_from(source.qname)?,
+            source.qtype, source.qclass
+        ))
+    }
+}
+
+
 //--- PartialEq and Eq
 
 impl<N, NN> PartialEq<Question<NN>> for Question<N>

src/base/rdata.rs

@@ -31,7 +31,8 @@ use core::cmp::Ordering;
 use super::cmp::CanonicalOrd;
 use super::iana::Rtype;
 use super::octets::{
-    Compose, OctetsBuilder, OctetsRef, Parse, ParseError, Parser, ShortBuf
+    Compose, OctetsBuilder, OctetsFrom, OctetsRef, Parse, ParseError, Parser,
+    ShortBuf
 };
 
 
@@ -220,6 +221,22 @@ impl UnknownRecordData<Bytes> {
 }
 
 
+//--- OctetsFrom
+
+impl<Octets, SrcOctets>
+OctetsFrom<UnknownRecordData<SrcOctets>> for UnknownRecordData<Octets>
+where Octets: OctetsFrom<SrcOctets> {
+    fn octets_from(
+        source: UnknownRecordData<SrcOctets>
+    ) -> Result<Self, ShortBuf> {
+        Ok(UnknownRecordData {
+            rtype: source.rtype,
+            data: Octets::octets_from(source.data)?
+        })
+    }
+}
+
+
 //--- PartialEq and Eq
 
 impl<Octets, Other> PartialEq<UnknownRecordData<Other>>