colin/hickory-dns
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor the Resource data structure

Browse Source 
the `rr_type` field has been removed. this eliminates the possibility of
setting `rdata` to a type that does not match `rr_type`. as a
consequence, the `set_record_type` has also been removed

the `record_type` of the `Resource` is now derived from what's stored in
the `rdata` field

`rdata` is no longer an `Option`. `rdata = None` was being used to
represent update records. an `Update` variant has been added to the
`RData` enum. this variant is used to represent update records, which
have RDLENGTH set to 0.

the `Resource::{default,new}` constructors have been removed. they felt
error prone as in most cases one wants to set the `rdata` and `name`
fields since they have no sensible defaults. all uses of those
constructors now use the pre-existing `from_rdata` constructor

the `Resource::with` constructor has also been removed. it was pretty
similar to `from_rdata` but initialized `rr_type` and not `rdata`. all
uses of `Record::with` has been changed to `from_rdata`
This commit is contained in:
Jorge Aparicio 2024-06-06 04:51:43 -05:00 committed by Benjamin Fry
parent 76f717d10f
commit ed192864f3
55 changed files with 1050 additions and 1486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bin/tests/named_tests.rs
View File

@ -311,7 +311,7 @@ fn test_forward() {
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
*response.answers()[0].data().and_then(RData::as_a).unwrap(), *response.answers()[0].data().as_a().unwrap(),
A::new(93, 184, 215, 14) A::new(93, 184, 215, 14)
); );
@ -334,7 +334,7 @@ fn test_forward() {
) )
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
*response.answers()[0].data().and_then(RData::as_a).unwrap(), *response.answers()[0].data().as_a().unwrap(),
A::new(93, 184, 215, 14) A::new(93, 184, 215, 14)
); );
assert!(!response.header().authoritative()); assert!(!response.header().authoritative());

6
bin/tests/server_harness/mod.rs
View File

@ -248,7 +248,7 @@ pub fn query_a<C: ClientHandle>(io_loop: &mut Runtime, client: &mut C) {
let response = query_message(io_loop, client, name, RecordType::A).unwrap(); let response = query_message(io_loop, client, name, RecordType::A).unwrap();
let record = &response.answers()[0]; let record = &response.answers()[0];
if let Some(RData::A(ref address)) = record.data() { if let RData::A(ref address) = record.data() {
assert_eq!(address, &A::new(127, 0, 0, 1)) assert_eq!(address, &A::new(127, 0, 0, 1))
} else { } else {
panic!("wrong RDATA") panic!("wrong RDATA")
@ -296,7 +296,7 @@ pub fn query_all_dnssec(
let dnskey = response let dnskey = response
.answers() .answers()
.iter() .iter()
.filter_map(Record::data) .map(Record::data)
.filter_map(DNSKEY::try_borrow) .filter_map(DNSKEY::try_borrow)
.find(|d| d.algorithm() == algorithm); .find(|d| d.algorithm() == algorithm);
assert!(dnskey.is_some(), "DNSKEY not found"); assert!(dnskey.is_some(), "DNSKEY not found");
@ -306,7 +306,7 @@ pub fn query_all_dnssec(
let rrsig = response let rrsig = response
.answers() .answers()
.iter() .iter()
.filter_map(Record::data) .map(Record::data)
.filter_map(RRSIG::try_borrow) .filter_map(RRSIG::try_borrow)
.filter(|rrsig| rrsig.algorithm() == algorithm) .filter(|rrsig| rrsig.algorithm() == algorithm)
.find(|rrsig| rrsig.type_covered() == RecordType::DNSKEY); .find(|rrsig| rrsig.type_covered() == RecordType::DNSKEY);

9
crates/client/src/client/async_client.rs
View File

@ -34,7 +34,7 @@ use crate::{
}, },
TokioTime, TokioTime,
}, },
rr::{rdata::SOA, DNSClass, Name, RData, Record, RecordSet, RecordType}, rr::{rdata::SOA, DNSClass, Name, Record, RecordSet, RecordType},
}; };
/// A DNS Client implemented over futures-rs. /// A DNS Client implemented over futures-rs.
@ -709,7 +709,7 @@ impl<R> ClientStreamXfrState<R> {
fn process(&mut self, answers: &[Record]) -> Result<(), ClientError> { fn process(&mut self, answers: &[Record]) -> Result<(), ClientError> {
use ClientStreamXfrState::*; use ClientStreamXfrState::*;
fn get_serial(r: &Record) -> Option<u32> { fn get_serial(r: &Record) -> Option<u32> {
r.data().and_then(RData::as_soa).map(SOA::serial) r.data().as_soa().map(SOA::serial)
} }
if answers.is_empty() { if answers.is_empty() {
@ -864,6 +864,7 @@ mod tests {
use crate::rr::rdata::{A, SOA}; use crate::rr::rdata::{A, SOA};
use futures_util::stream::iter; use futures_util::stream::iter;
use hickory_proto::rr::RData;
use ClientStreamXfrState::*; use ClientStreamXfrState::*;
fn soa_record(serial: u32) -> Record { fn soa_record(serial: u32) -> Record {
@ -1116,7 +1117,7 @@ mod tests {
let (message_returned, buffer) = query.await.unwrap().into_parts(); let (message_returned, buffer) = query.await.unwrap().into_parts();
// validate it's what we expected // validate it's what we expected
if let Some(RData::A(addr)) = message_returned.answers()[0].data() { if let RData::A(addr) = message_returned.answers()[0].data() {
assert_eq!(*addr, A::new(93, 184, 215, 14)); assert_eq!(*addr, A::new(93, 184, 215, 14));
} }
@ -1124,7 +1125,7 @@ mod tests {
.expect("buffer was parsed already by AsyncClient so we should be able to do it again"); .expect("buffer was parsed already by AsyncClient so we should be able to do it again");
// validate it's what we expected // validate it's what we expected
if let Some(RData::A(addr)) = message_parsed.answers()[0].data() { if let RData::A(addr) = message_parsed.answers()[0].data() {
assert_eq!(*addr, A::new(93, 184, 215, 14)); assert_eq!(*addr, A::new(93, 184, 215, 14));
} }
} }

4
crates/client/src/lib.rs
View File

@ -128,7 +128,7 @@
//! // Records are generic objects which can contain any data. //! // Records are generic objects which can contain any data.
//! // In order to access it we need to first check what type of record it is //! // In order to access it we need to first check what type of record it is
//! // In this case we are interested in A, IPv4 address //! // In this case we are interested in A, IPv4 address
//! if let Some(RData::A(ref ip)) = answers[0].data() { //! if let RData::A(ref ip) = answers[0].data() {
//! assert_eq!(*ip, A::new(93, 184, 215, 14)) //! assert_eq!(*ip, A::new(93, 184, 215, 14))
//! } else { //! } else {
//! assert!(false, "unexpected result") //! assert!(false, "unexpected result")
@ -263,7 +263,7 @@
//! let response = query.await.unwrap(); //! let response = query.await.unwrap();
//! //!
//! // validate it's what we expected //! // validate it's what we expected
//! if let Some(RData::A(addr)) = response.answers()[0].data() { //! if let RData::A(addr) = response.answers()[0].data() {
//! assert_eq!(*addr, A::new(93, 184, 215, 14)); //! assert_eq!(*addr, A::new(93, 184, 215, 14));
//! } //! }
//! } //! }

20
crates/proto/src/h2/h2_client_stream.rs
View File

@ -540,7 +540,7 @@ mod tests {
use crate::iocompat::AsyncIoTokioAsStd; use crate::iocompat::AsyncIoTokioAsStd;
use crate::op::{Message, Query, ResponseCode}; use crate::op::{Message, Query, ResponseCode};
use crate::rr::rdata::{A, AAAA}; use crate::rr::rdata::{A, AAAA};
use crate::rr::{Name, RData, RecordType}; use crate::rr::{Name, RecordType};
use crate::xfer::{DnsRequestOptions, FirstAnswer}; use crate::xfer::{DnsRequestOptions, FirstAnswer};
use super::*; use super::*;
@ -572,10 +572,7 @@ mod tests {
.expect("send_message failed"); .expect("send_message failed");
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record.data().as_a().expect("Expected A record");
.data()
.and_then(RData::as_a)
.expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14)); assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -600,7 +597,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!( assert_eq!(
@ -637,10 +634,7 @@ mod tests {
.expect("send_message failed"); .expect("send_message failed");
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record.data().as_a().expect("Expected A record");
.data()
.and_then(RData::as_a)
.expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14)); assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -665,7 +659,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!( assert_eq!(
@ -705,7 +699,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14)); assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -727,7 +721,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!( assert_eq!(

20
crates/proto/src/h3/h3_client_stream.rs
View File

@ -475,7 +475,7 @@ mod tests {
use crate::op::{Message, Query, ResponseCode}; use crate::op::{Message, Query, ResponseCode};
use crate::rr::rdata::{A, AAAA}; use crate::rr::rdata::{A, AAAA};
use crate::rr::{Name, RData, RecordType}; use crate::rr::{Name, RecordType};
use crate::xfer::{DnsRequestOptions, FirstAnswer}; use crate::xfer::{DnsRequestOptions, FirstAnswer};
use super::*; use super::*;
@ -507,10 +507,7 @@ mod tests {
.expect("send_message failed"); .expect("send_message failed");
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record.data().as_a().expect("Expected A record");
.data()
.and_then(RData::as_a)
.expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14)); assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -535,7 +532,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!( assert_eq!(
@ -572,10 +569,7 @@ mod tests {
.expect("send_message failed"); .expect("send_message failed");
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record.data().as_a().expect("Expected A record");
.data()
.and_then(RData::as_a)
.expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14)); assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -600,7 +594,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!( assert_eq!(
@ -641,7 +635,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14)); assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -663,7 +657,7 @@ mod tests {
let record = &response.answers()[0]; let record = &response.answers()[0];
let addr = record let addr = record
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("invalid response, expected A record"); .expect("invalid response, expected A record");
assert_eq!( assert_eq!(

16
crates/proto/src/op/edns.rs
View File

@ -156,11 +156,11 @@ impl<'a> From<&'a Record> for Edns {
let max_payload: u16 = u16::from(value.dns_class()); let max_payload: u16 = u16::from(value.dns_class());
let options: OPT = match value.data() { let options: OPT = match value.data() {
Some(RData::NULL(..)) | None => { RData::Update0(..) | RData::NULL(..) => {
// NULL, there was no data in the OPT // NULL, there was no data in the OPT
OPT::default() OPT::default()
} }
Some(RData::OPT(ref option_data)) => { RData::OPT(ref option_data) => {
option_data.clone() // TODO: Edns should just refer to this, have the same lifetime as the Record option_data.clone() // TODO: Edns should just refer to this, have the same lifetime as the Record
} }
_ => { _ => {
@ -183,24 +183,18 @@ impl<'a> From<&'a Edns> for Record {
/// This returns a Resource Record that is formatted for Edns(0). /// This returns a Resource Record that is formatted for Edns(0).
/// Note: the rcode_high value is only part of the rcode, the rest is part of the base /// Note: the rcode_high value is only part of the rcode, the rest is part of the base
fn from(value: &'a Edns) -> Self { fn from(value: &'a Edns) -> Self {
let mut record = Self::new();
record.set_name(Name::root());
record.set_record_type(RecordType::OPT);
record.set_dns_class(DNSClass::for_opt(value.max_payload()));
// rebuild the TTL field // rebuild the TTL field
let mut ttl: u32 = u32::from(value.rcode_high()) << 24; let mut ttl: u32 = u32::from(value.rcode_high()) << 24;
ttl |= u32::from(value.version()) << 16; ttl |= u32::from(value.version()) << 16;
ttl |= u32::from(value.flags); ttl |= u32::from(value.flags);
record.set_ttl(ttl);
// now for each option, write out the option array // now for each option, write out the option array
// also, since this is a hash, there is no guarantee that ordering will be preserved from // also, since this is a hash, there is no guarantee that ordering will be preserved from
// the original binary format. // the original binary format.
// maybe switch to: https://crates.io/crates/linked-hash-map/ // maybe switch to: https://crates.io/crates/linked-hash-map/
record.set_data(Some(RData::OPT(value.options().clone()))); let mut record = Self::from_rdata(Name::root(), ttl, RData::OPT(value.options().clone()));
record.set_dns_class(DNSClass::for_opt(value.max_payload()));
record record
} }

12
crates/proto/src/op/message.rs
View File

@ -1191,9 +1191,9 @@ mod tests {
.set_checking_disabled(true) .set_checking_disabled(true)
.set_response_code(ResponseCode::ServFail); .set_response_code(ResponseCode::ServFail);
message.add_answer(Record::new()); message.add_answer(Record::stub());
message.add_name_server(Record::new()); message.add_name_server(Record::stub());
message.add_additional(Record::new()); message.add_additional(Record::stub());
message.update_counts(); message.update_counts();
test_emit_and_read(message); test_emit_and_read(message);
@ -1229,9 +1229,9 @@ mod tests {
.set_checking_disabled(true) .set_checking_disabled(true)
.set_response_code(ResponseCode::ServFail); .set_response_code(ResponseCode::ServFail);
message.add_answer(Record::new()); message.add_answer(Record::stub());
message.add_name_server(Record::new()); message.add_name_server(Record::stub());
message.add_additional(Record::new()); message.add_additional(Record::stub());
// at here, we don't call update_counts and we even set wrong count, // at here, we don't call update_counts and we even set wrong count,
// because we are trying to test whether the counts in the header // because we are trying to test whether the counts in the header

19
crates/proto/src/op/update_message.rs
View File

@ -11,10 +11,7 @@ use std::fmt::Debug;
use crate::{ use crate::{
op::{Edns, Message, MessageType, OpCode, Query}, op::{Edns, Message, MessageType, OpCode, Query},
rr::{ rr::{rdata::SOA, DNSClass, Name, RData, Record, RecordSet, RecordType},
rdata::{NULL, SOA},
DNSClass, Name, RData, Record, RecordSet, RecordType,
},
}; };
/// To reduce errors in using the Message struct as an Update, this will do the call throughs /// To reduce errors in using the Message struct as an Update, this will do the call throughs
@ -181,9 +178,9 @@ pub fn create(rrset: RecordSet, zone_origin: Name, use_edns: bool) -> Message {
.set_recursion_desired(false); .set_recursion_desired(false);
message.add_zone(zone); message.add_zone(zone);
let mut prerequisite = Record::with(rrset.name().clone(), rrset.record_type(), 0); let mut prerequisite = Record::update0(rrset.name().clone(), 0, rrset.record_type());
prerequisite.set_dns_class(DNSClass::NONE); prerequisite.set_dns_class(DNSClass::NONE);
message.add_pre_requisite(prerequisite); message.add_pre_requisite(prerequisite.into_record_of_rdata());
message.add_updates(rrset); message.add_updates(rrset);
// Extended dns // Extended dns
@ -251,9 +248,9 @@ pub fn append(rrset: RecordSet, zone_origin: Name, must_exist: bool, use_edns: b
message.add_zone(zone); message.add_zone(zone);
if must_exist { if must_exist {
let mut prerequisite = Record::with(rrset.name().clone(), rrset.record_type(), 0); let mut prerequisite = Record::update0(rrset.name().clone(), 0, rrset.record_type());
prerequisite.set_dns_class(DNSClass::ANY); prerequisite.set_dns_class(DNSClass::ANY);
message.add_pre_requisite(prerequisite); message.add_pre_requisite(prerequisite.into_record_of_rdata());
} }
message.add_updates(rrset); message.add_updates(rrset);
@ -492,7 +489,7 @@ pub fn delete_rrset(mut record: Record, zone_origin: Name, use_edns: bool) -> Me
// the TTL should be 0 // the TTL should be 0
record.set_ttl(0); record.set_ttl(0);
// the rdata must be null to delete all rrsets // the rdata must be null to delete all rrsets
record.set_data(Some(RData::NULL(NULL::new()))); record.set_data(RData::Update0(record.record_type()));
message.add_update(record); message.add_update(record);
// Extended dns // Extended dns
@ -557,12 +554,12 @@ pub fn delete_all(
// the TTL should be 0 // the TTL should be 0
// the rdata must be null to delete all rrsets // the rdata must be null to delete all rrsets
// the record type must be any // the record type must be any
let mut record = Record::with(name_of_records, RecordType::ANY, 0); let mut record = Record::update0(name_of_records, 0, RecordType::ANY);
// the class must be none for an rrset delete // the class must be none for an rrset delete
record.set_dns_class(DNSClass::ANY); record.set_dns_class(DNSClass::ANY);
message.add_update(record); message.add_update(record.into_record_of_rdata());
// Extended dns // Extended dns
if use_edns { if use_edns {

26
crates/proto/src/rr/dnssec/rdata/tsig.rs
View File

@ -756,7 +756,7 @@ pub fn signed_bitmessage_to_buf(
// parse a tsig record // parse a tsig record
let sig = Record::read(&mut decoder)?; let sig = Record::read(&mut decoder)?;
let tsig = if let (RecordType::TSIG, Some(RData::DNSSEC(DNSSECRData::TSIG(tsig_data)))) = let tsig = if let (RecordType::TSIG, RData::DNSSEC(DNSSECRData::TSIG(tsig_data))) =
(sig.record_type(), sig.data()) (sig.record_type(), sig.data())
{ {
tsig_data tsig_data
@ -795,17 +795,17 @@ pub fn signed_bitmessage_to_buf(
pub fn make_tsig_record(name: Name, rdata: TSIG) -> Record { pub fn make_tsig_record(name: Name, rdata: TSIG) -> Record {
// https://tools.ietf.org/html/rfc8945#section-4.2 // https://tools.ietf.org/html/rfc8945#section-4.2
let mut tsig = Record::new(); let mut tsig = Record::from_rdata(
// NAME: The name of the key used, in domain name syntax
// NAME: The name of the key used, in domain name syntax name,
tsig.set_name(name)
// TYPE: This MUST be TSIG (250: Transaction SIGnature).
.set_record_type(RecordType::TSIG)
// CLASS: This MUST be ANY.
.set_dns_class(DNSClass::ANY)
// TTL: This MUST be 0. // TTL: This MUST be 0.
.set_ttl(0) 0,
.set_data(Some(DNSSECRData::TSIG(rdata).into())); // TYPE: This MUST be TSIG (250: Transaction SIGnature).
DNSSECRData::TSIG(rdata).into(),
);
// CLASS: This MUST be ANY.
tsig.set_dns_class(DNSClass::ANY);
tsig tsig
} }
@ -864,7 +864,7 @@ mod tests {
#[test] #[test]
fn test_sign_encode() { fn test_sign_encode() {
let mut message = Message::new(); let mut message = Message::new();
message.add_answer(Record::new()); message.add_answer(Record::stub());
let key_name = Name::from_ascii("some.name").unwrap(); let key_name = Name::from_ascii("some.name").unwrap();
@ -899,7 +899,7 @@ mod tests {
#[test] #[test]
fn test_sign_encode_id_changed() { fn test_sign_encode_id_changed() {
let mut message = Message::new(); let mut message = Message::new();
message.set_id(123).add_answer(Record::new()); message.set_id(123).add_answer(Record::stub());
let key_name = Name::from_ascii("some.name").unwrap(); let key_name = Name::from_ascii("some.name").unwrap();

191
crates/proto/src/rr/dnssec/signer.rs
View File

@ -530,23 +530,15 @@ impl MessageFinalizer for SigSigner {
// this is based on RFCs 2535, 2931 and 3007 // this is based on RFCs 2535, 2931 and 3007
// 'For all SIG(0) RRs, the owner name, class, TTL, and original TTL, are
// meaningless.' - 2931
let mut sig0 = Record::new();
// The TTL fields SHOULD be zero
sig0.set_ttl(0);
// The CLASS field SHOULD be ANY
sig0.set_dns_class(DNSClass::ANY);
// The owner name SHOULD be root (a single zero octet). // The owner name SHOULD be root (a single zero octet).
sig0.set_name(Name::root()); let name = Name::root();
let num_labels = sig0.name().num_labels(); // The TTL fields SHOULD be zero
let ttl = 0;
let num_labels = name.num_labels();
let expiration_time: u32 = current_time + (5 * 60); // +5 minutes in seconds let expiration_time: u32 = current_time + (5 * 60); // +5 minutes in seconds
sig0.set_record_type(RecordType::SIG);
let pre_sig0 = SIG::new( let pre_sig0 = SIG::new(
// type covered in SIG(0) is 0 which is what makes this SIG0 vs a standard SIG // type covered in SIG(0) is 0 which is what makes this SIG0 vs a standard SIG
RecordType::ZERO, RecordType::ZERO,
@ -565,9 +557,14 @@ impl MessageFinalizer for SigSigner {
Vec::new(), Vec::new(),
); );
let signature: Vec<u8> = self.sign_message(message, &pre_sig0)?; let signature: Vec<u8> = self.sign_message(message, &pre_sig0)?;
sig0.set_data(Some(RData::DNSSEC(DNSSECRData::SIG( let rdata = RData::DNSSEC(DNSSECRData::SIG(pre_sig0.set_sig(signature)));
pre_sig0.set_sig(signature),
)))); // 'For all SIG(0) RRs, the owner name, class, TTL, and original TTL, are
// meaningless.' - 2931
let mut sig0 = Record::from_rdata(name, ttl, rdata);
// The CLASS field SHOULD be ANY
sig0.set_dns_class(DNSClass::ANY);
Ok((vec![sig0], None)) Ok((vec![sig0], None))
} }
@ -659,7 +656,7 @@ mod tests {
let sig = signer.sign_message(&question, &pre_sig0); let sig = signer.sign_message(&question, &pre_sig0);
println!("sig after sign: {sig:?}"); println!("sig after sign: {sig:?}");
if let Some(RData::DNSSEC(DNSSECRData::SIG(ref sig))) = question.sig0()[0].data() { if let RData::DNSSEC(DNSSECRData::SIG(ref sig)) = question.sig0()[0].data() {
assert!(sig0key.verify_message(&question, sig.sig(), sig).is_ok()); assert!(sig0key.verify_message(&question, sig.sig(), sig).is_ok());
} }
} }
@ -692,28 +689,20 @@ mod tests {
); );
let rrset = vec![ let rrset = vec![
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"a.iana-servers.net.", .clone(),
None, Record::from_rdata(
) origin,
.unwrap())))) 86400,
.clone(), RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
Record::new() )
.set_name(origin) .set_dns_class(DNSClass::IN)
.set_ttl(86400) .clone(),
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"b.iana-servers.net.",
None,
)
.unwrap()))))
.clone(),
]; ];
let tbs = tbs::rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap(); let tbs = tbs::rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap();
@ -829,87 +818,61 @@ MC0CAQACBQC+L6pNAgMBAAECBQCYj0ZNAgMA9CsCAwDHZwICeEUCAnE/AgMA3u0=
), ),
); );
let rrset = vec![ let rrset = vec![
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"a.iana-servers.net.", .clone(),
None, Record::from_rdata(
) origin.clone(),
.unwrap())))) 86400,
.clone(), RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
Record::new() )
.set_name(origin.clone()) .set_dns_class(DNSClass::IN)
.set_ttl(86400) .clone(),
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"b.iana-servers.net.",
None,
)
.unwrap()))))
.clone(),
]; ];
let tbs = rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap(); let tbs = rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap();
assert!(!tbs.as_ref().is_empty()); assert!(!tbs.as_ref().is_empty());
let rrset = vec![ let rrset = vec![
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::CNAME) RData::CNAME(CNAME(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::CNAME(CNAME( .set_dns_class(DNSClass::IN)
Name::parse("a.iana-servers.net.", None).unwrap(), .clone(), // different type
)))) Record::from_rdata(
.clone(), // different type Name::parse("www.example.com.", None).unwrap(),
Record::new() 86400,
.set_name(Name::parse("www.example.com.", None).unwrap()) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_ttl(86400) )
.set_record_type(RecordType::NS) .set_dns_class(DNSClass::IN)
.set_dns_class(DNSClass::IN) .clone(), // different name
.set_data(Some(RData::NS(NS(Name::parse( Record::from_rdata(
"a.iana-servers.net.", origin.clone(),
None, 86400,
) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.unwrap())))) )
.clone(), // different name .set_dns_class(DNSClass::CH)
Record::new() .clone(), // different class
.set_name(origin.clone()) Record::from_rdata(
.set_ttl(86400) origin.clone(),
.set_record_type(RecordType::NS) 86400,
.set_dns_class(DNSClass::CH) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_data(Some(RData::NS(NS(Name::parse( )
"a.iana-servers.net.", .set_dns_class(DNSClass::IN)
None, .clone(),
) Record::from_rdata(
.unwrap())))) origin,
.clone(), // different class 86400,
Record::new() RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
.set_name(origin.clone()) )
.set_ttl(86400) .set_dns_class(DNSClass::IN)
.set_record_type(RecordType::NS) .clone(),
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"a.iana-servers.net.",
None,
)
.unwrap()))))
.clone(),
Record::new()
.set_name(origin)
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"b.iana-servers.net.",
None,
)
.unwrap()))))
.clone(),
]; ];
let filtered_tbs = rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap(); let filtered_tbs = rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap();

10
crates/proto/src/rr/dnssec/tbs.rs
View File

@ -170,9 +170,7 @@ pub fn rrset_tbs<B: Borrow<Record>>(
{ {
let mut rdata_encoder = BinEncoder::new(&mut rdata_buf); let mut rdata_encoder = BinEncoder::new(&mut rdata_buf);
rdata_encoder.set_canonical_names(true); rdata_encoder.set_canonical_names(true);
if let Some(rdata) = record.data() { assert!(record.data().emit(&mut rdata_encoder).is_ok());
assert!(rdata.emit(&mut rdata_encoder).is_ok());
}
} }
assert!(encoder.emit_u16(rdata_buf.len() as u16).is_ok()); assert!(encoder.emit_u16(rdata_buf.len() as u16).is_ok());
// //
@ -199,11 +197,7 @@ pub fn rrset_tbs_with_rrsig<B: Borrow<Record>>(
rrsig: &Record<RRSIG>, rrsig: &Record<RRSIG>,
records: &[B], records: &[B],
) -> ProtoResult<TBS> { ) -> ProtoResult<TBS> {
if let Some(sig) = rrsig.data() { rrset_tbs_with_sig(rrsig.name(), rrsig.dns_class(), rrsig.data(), records)
rrset_tbs_with_sig(rrsig.name(), rrsig.dns_class(), sig, records)
} else {
Err(format!("could not determine name from {}", rrsig.name()).into())
}
} }
/// Returns the to-be-signed serialization of the given record set using the information /// Returns the to-be-signed serialization of the given record set using the information

2
crates/proto/src/rr/dnssec/tsig.rs
View File

@ -128,7 +128,7 @@ impl TSigner {
first_message: bool, first_message: bool,
) -> ProtoResult<(Vec<u8>, Range<u64>, u64)> { ) -> ProtoResult<(Vec<u8>, Range<u64>, u64)> {
let (tbv, record) = signed_bitmessage_to_buf(previous_hash, message, first_message)?; let (tbv, record) = signed_bitmessage_to_buf(previous_hash, message, first_message)?;
let tsig = if let Some(RData::DNSSEC(DNSSECRData::TSIG(tsig))) = record.data() { let tsig = if let RData::DNSSEC(DNSSECRData::TSIG(tsig)) = record.data() {
tsig tsig
} else { } else {
unreachable!("tsig::signed_message_to_buff always returns a TSIG record") unreachable!("tsig::signed_message_to_buff always returns a TSIG record")

5
crates/proto/src/rr/mod.rs
View File

@ -57,6 +57,11 @@ pub trait RecordData: Clone + Sized + PartialEq + Eq + Display + Debug + BinEnco
/// Converts this RecordData into generic RecordData /// Converts this RecordData into generic RecordData
fn into_rdata(self) -> RData; fn into_rdata(self) -> RData;
/// RDLENGTH = 0
fn is_update(&self) -> bool {
false
}
} }
trait RecordDataDecodable<'r>: Sized { trait RecordDataDecodable<'r>: Sized {

1
crates/proto/src/rr/rdata/update.rs Normal file
View File

@ -0,0 +1 @@
pub struct UpdateRdata(pub RecordType);

11
crates/proto/src/rr/record_data.rs
View File

@ -691,6 +691,9 @@ pub enum RData {
rdata: NULL, rdata: NULL,
}, },
/// Update record with RDLENGTH = 0 (RFC2136)
Update0(RecordType),
/// This corresponds to a record type of 0, unspecified /// This corresponds to a record type of 0, unspecified
#[deprecated(note = "Use None for the RData in the resource record instead")] #[deprecated(note = "Use None for the RData in the resource record instead")]
ZERO, ZERO,
@ -735,6 +738,7 @@ impl RData {
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
Self::DNSSEC(ref rdata) => DNSSECRData::to_record_type(rdata), Self::DNSSEC(ref rdata) => DNSSECRData::to_record_type(rdata),
Self::Unknown { code, .. } => code, Self::Unknown { code, .. } => code,
Self::Update0(record_type) => record_type,
Self::ZERO => RecordType::ZERO, Self::ZERO => RecordType::ZERO,
} }
} }
@ -975,6 +979,7 @@ impl BinEncodable for RData {
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
Self::DNSSEC(ref rdata) => encoder.with_canonical_names(|encoder| rdata.emit(encoder)), Self::DNSSEC(ref rdata) => encoder.with_canonical_names(|encoder| rdata.emit(encoder)),
Self::Unknown { ref rdata, .. } => rdata.emit(encoder), Self::Unknown { ref rdata, .. } => rdata.emit(encoder),
Self::Update0(_) => Ok(()),
} }
} }
} }
@ -995,6 +1000,10 @@ impl RecordData for RData {
fn into_rdata(self) -> RData { fn into_rdata(self) -> RData {
self self
} }
fn is_update(&self) -> bool {
matches!(self, RData::Update0(_))
}
} }
impl fmt::Display for RData { impl fmt::Display for RData {
@ -1034,6 +1043,7 @@ impl fmt::Display for RData {
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
Self::DNSSEC(ref rdata) => w(f, rdata), Self::DNSSEC(ref rdata) => w(f, rdata),
Self::Unknown { ref rdata, .. } => w(f, rdata), Self::Unknown { ref rdata, .. } => w(f, rdata),
Self::Update0(_) => w(f, "UPDATE"),
} }
} }
} }
@ -1274,6 +1284,7 @@ mod tests {
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
RData::DNSSEC(ref rdata) => rdata.to_record_type(), RData::DNSSEC(ref rdata) => rdata.to_record_type(),
RData::Unknown { code, .. } => code, RData::Unknown { code, .. } => code,
RData::Update0(record_type) => record_type,
RData::ZERO => RecordType::ZERO, RData::ZERO => RecordType::ZERO,
} }
} }

223
crates/proto/src/rr/resource.rs
View File

@ -75,25 +75,23 @@ const MDNS_ENABLE_CACHE_FLUSH: u16 = 1 << 15;
// TODO: make Record carry a lifetime for more efficient storage options in the future // TODO: make Record carry a lifetime for more efficient storage options in the future
pub struct Record<R: RecordData = RData> { pub struct Record<R: RecordData = RData> {
name_labels: Name, name_labels: Name,
rr_type: RecordType,
dns_class: DNSClass, dns_class: DNSClass,
ttl: u32, ttl: u32,
rdata: Option<R>, rdata: R,
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: bool, mdns_cache_flush: bool,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
proof: Proof, proof: Proof,
} }
impl Default for Record<RData> { impl Record {
fn default() -> Self { #[cfg(test)]
pub fn stub() -> Self {
Self { Self {
// TODO: make these part of a Builder instead to cleanup Records at runtime?
name_labels: Name::new(), name_labels: Name::new(),
rr_type: RecordType::NULL,
dns_class: DNSClass::IN, dns_class: DNSClass::IN,
ttl: 0, ttl: 0,
rdata: None, rdata: RData::Update0(RecordType::NULL),
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: false, mdns_cache_flush: false,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -102,62 +100,20 @@ impl Default for Record<RData> {
} }
} }
impl Record<RData> { impl Record {
/// Creates a default record, use the setters to build a more useful object. /// Creates an update record with RDLENGTH=0
/// pub fn update0(name: Name, ttl: u32, rr_type: RecordType) -> Self {
/// There are no optional elements in this object, defaults are an empty name, type A, class IN,
/// ttl of 0 and the 0.0.0.0 ip address.
pub fn new() -> Self {
Self::default()
}
/// Create a record with the specified initial values.
///
/// # Arguments
///
/// * `name` - name of the resource records
/// * `rr_type` - the record type
/// * `ttl` - time-to-live is the amount of time this record should be cached before refreshing
// TODO: maybe deprecate in the future, there are valid use cases for null data...
// #[deprecated = "consider using the typed variant `from_rdata`"]
pub fn with(name: Name, rr_type: RecordType, ttl: u32) -> Self {
Self { Self {
name_labels: name, name_labels: name,
rr_type,
dns_class: DNSClass::IN, dns_class: DNSClass::IN,
ttl, ttl,
rdata: None, rdata: RData::Update0(rr_type),
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: false, mdns_cache_flush: false,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
proof: Proof::default(), proof: Proof::default(),
} }
} }
/// ```text
/// TYPE two octets containing one of the RR type codes. This
/// field specifies the meaning of the data in the RDATA
/// field.
/// ```
#[deprecated(note = "use `set_record_type`")]
pub fn set_rr_type(&mut self, rr_type: RecordType) -> &mut Self {
self.rr_type = rr_type;
self
}
/// Generally Speaking, this is redundant to the RecordType stored in the associated RData and not recommended
/// to set this separately. Exceptions to this are for Update Messages, where the RecordType is used distinctly
/// as a means to express certain Update instructions. For queries and responses, it will always match the RData
///
/// ```text
/// TYPE two octets containing one of the RR type codes. This
/// field specifies the meaning of the data in the RDATA
/// field.
/// ```
pub fn set_record_type(&mut self, rr_type: RecordType) -> &mut Self {
self.rr_type = rr_type;
self
}
} }
impl<R: RecordData> Record<R> { impl<R: RecordData> Record<R> {
@ -171,10 +127,9 @@ impl<R: RecordData> Record<R> {
pub fn from_rdata(name: Name, ttl: u32, rdata: R) -> Self { pub fn from_rdata(name: Name, ttl: u32, rdata: R) -> Self {
Self { Self {
name_labels: name, name_labels: name,
rr_type: rdata.record_type(),
dns_class: DNSClass::IN, dns_class: DNSClass::IN,
ttl, ttl,
rdata: Some(rdata), rdata,
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: false, mdns_cache_flush: false,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -187,7 +142,6 @@ impl<R: RecordData> Record<R> {
pub fn try_from(record: Record<RData>) -> Result<Self, Record<RData>> { pub fn try_from(record: Record<RData>) -> Result<Self, Record<RData>> {
let Record { let Record {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata, rdata,
@ -197,35 +151,22 @@ impl<R: RecordData> Record<R> {
proof, proof,
} = record; } = record;
match rdata.map(R::try_from_rdata) { match R::try_from_rdata(rdata) {
None => Err(Record { Ok(rdata) => Ok(Self {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata: None, rdata,
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush, mdns_cache_flush,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
proof, proof,
}), }),
Some(Ok(rdata)) => Ok(Self { Err(rdata) => Err(Record {
name_labels, name_labels,
rr_type: rdata.record_type(),
dns_class, dns_class,
ttl, ttl,
rdata: Some(rdata), rdata,
#[cfg(feature = "mdns")]
mdns_cache_flush,
#[cfg(feature = "dnssec")]
proof,
}),
Some(Err(rdata)) => Err(Record {
name_labels,
rr_type,
dns_class,
ttl,
rdata: Some(rdata),
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush, mdns_cache_flush,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -238,7 +179,6 @@ impl<R: RecordData> Record<R> {
pub fn into_record_of_rdata(self) -> Record<RData> { pub fn into_record_of_rdata(self) -> Record<RData> {
let Self { let Self {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata, rdata,
@ -248,11 +188,10 @@ impl<R: RecordData> Record<R> {
proof, proof,
} = self; } = self;
let rdata: Option<RData> = rdata.map(RecordData::into_rdata); let rdata: RData = RecordData::into_rdata(rdata);
Record { Record {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata, rdata,
@ -300,18 +239,7 @@ impl<R: RecordData> Record<R> {
/// the RDATA field is a 4 octet ARPA Internet address. /// the RDATA field is a 4 octet ARPA Internet address.
/// ``` /// ```
#[track_caller] #[track_caller]
pub fn set_data(&mut self, rdata: Option<R>) -> &mut Self { pub fn set_data(&mut self, rdata: R) -> &mut Self {
debug_assert!(
if let Some(rdata) = &rdata {
rdata.record_type() == self.rr_type || rdata.record_type() == RecordType::NULL
} else {
true
},
"record types do not match, {} <> {:?}",
self.rr_type,
rdata.map(|r| r.record_type())
);
self.rdata = rdata; self.rdata = rdata;
self self
} }
@ -342,7 +270,7 @@ impl<R: RecordData> Record<R> {
/// Returns the type of the RecordData in the record /// Returns the type of the RecordData in the record
#[inline] #[inline]
pub fn record_type(&self) -> RecordType { pub fn record_type(&self) -> RecordType {
self.rr_type self.rdata.record_type()
} }
/// Returns the DNSClass of the Record, generally IN fro internet /// Returns the DNSClass of the Record, generally IN fro internet
@ -359,19 +287,19 @@ impl<R: RecordData> Record<R> {
/// Returns the Record Data, i.e. the record information /// Returns the Record Data, i.e. the record information
#[inline] #[inline]
pub fn data(&self) -> Option<&R> { pub fn data(&self) -> &R {
self.rdata.as_ref() &self.rdata
} }
/// Returns a mutable reference to the Record Data /// Returns a mutable reference to the Record Data
#[inline] #[inline]
pub fn data_mut(&mut self) -> Option<&mut R> { pub fn data_mut(&mut self) -> &mut R {
self.rdata.as_mut() &mut self.rdata
} }
/// Returns the RData consuming the Record /// Returns the RData consuming the Record
#[inline] #[inline]
pub fn into_data(self) -> Option<R> { pub fn into_data(self) -> R {
self.rdata self.rdata
} }
@ -405,14 +333,12 @@ impl<R: RecordData> Record<R> {
pub struct RecordParts<R: RecordData = RData> { pub struct RecordParts<R: RecordData = RData> {
/// label names /// label names
pub name_labels: Name, pub name_labels: Name,
/// record type
pub rr_type: RecordType,
/// dns class /// dns class
pub dns_class: DNSClass, pub dns_class: DNSClass,
/// time to live /// time to live
pub ttl: u32, pub ttl: u32,
/// rdata /// rdata
pub rdata: Option<R>, pub rdata: R,
/// mDNS cache flush /// mDNS cache flush
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
#[cfg_attr(docsrs, doc(cfg(feature = "mdns")))] #[cfg_attr(docsrs, doc(cfg(feature = "mdns")))]
@ -427,7 +353,6 @@ impl<R: RecordData> From<Record<R>> for RecordParts<R> {
fn from(record: Record<R>) -> Self { fn from(record: Record<R>) -> Self {
let Record { let Record {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata, rdata,
@ -439,7 +364,6 @@ impl<R: RecordData> From<Record<R>> for RecordParts<R> {
Self { Self {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata, rdata,
@ -461,7 +385,7 @@ impl IntoRecordSet for Record {
impl<R: RecordData> BinEncodable for Record<R> { impl<R: RecordData> BinEncodable for Record<R> {
fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()> { fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()> {
self.name_labels.emit(encoder)?; self.name_labels.emit(encoder)?;
self.rr_type.emit(encoder)?; self.record_type().emit(encoder)?;
#[cfg(not(feature = "mdns"))] #[cfg(not(feature = "mdns"))]
self.dns_class.emit(encoder)?; self.dns_class.emit(encoder)?;
@ -483,8 +407,8 @@ impl<R: RecordData> BinEncodable for Record<R> {
// write the RData // write the RData
// the None case is handled below by writing `0` for the length of the RData // the None case is handled below by writing `0` for the length of the RData
// this is in turn read as `None` during the `read` operation. // this is in turn read as `None` during the `read` operation.
if let Some(rdata) = &self.rdata { if !self.rdata.is_update() {
rdata.emit(encoder)?; self.rdata.emit(encoder)?;
} }
// get the length written // get the length written
@ -568,30 +492,18 @@ impl<'r> BinDecodable<'r> for Record<RData> {
// this is to handle updates, RFC 2136, which uses 0 to indicate certain aspects of pre-requisites // this is to handle updates, RFC 2136, which uses 0 to indicate certain aspects of pre-requisites
// Null represents any data. // Null represents any data.
let rdata = if rd_length == 0 { let rdata = if rd_length == 0 {
None RData::Update0(record_type)
} else { } else {
// RDATA a variable length string of octets that describes the // RDATA a variable length string of octets that describes the
// resource. The format of this information varies // resource. The format of this information varies
// according to the TYPE and CLASS of the resource record. // according to the TYPE and CLASS of the resource record.
// Adding restrict to the rdata length because it's used for many calculations later // Adding restrict to the rdata length because it's used for many calculations later
// and must be validated before hand // and must be validated before hand
Some(RData::read(decoder, record_type, Restrict::new(rd_length))?) RData::read(decoder, record_type, Restrict::new(rd_length))?
}; };
debug_assert!(
if let Some(rdata) = &rdata {
rdata.record_type() == record_type
} else {
true
},
"record types do not match, {} <> {:?}",
record_type,
rdata.map(|r| r.record_type())
);
Ok(Self { Ok(Self {
name_labels, name_labels,
rr_type: record_type,
dns_class: class, dns_class: class,
ttl, ttl,
rdata, rdata,
@ -649,17 +561,14 @@ impl<R: RecordData> fmt::Display for Record<R> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
write!( write!(
f, f,
"{name} {ttl} {class} {ty}", "{name} {ttl} {class} {ty} {rdata}",
name = self.name_labels, name = self.name_labels,
ttl = self.ttl, ttl = self.ttl,
class = self.dns_class, class = self.dns_class,
ty = self.rr_type, ty = self.record_type(),
rdata = self.rdata,
)?; )?;
if let Some(rdata) = &self.rdata {
write!(f, " {rdata}")?;
}
Ok(()) Ok(())
} }
} }
@ -679,7 +588,6 @@ impl<R: RecordData> PartialEq for Record<R> {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
// self == other && // the same pointer // self == other && // the same pointer
self.name_labels == other.name_labels self.name_labels == other.name_labels
&& self.rr_type == other.rr_type
&& self.dns_class == other.dns_class && self.dns_class == other.dns_class
&& self.rdata == other.rdata && self.rdata == other.rdata
} }
@ -732,7 +640,10 @@ impl Ord for Record {
// resource records be maintained in binary? // resource records be maintained in binary?
compare_or_equal!(self, other, name_labels); compare_or_equal!(self, other, name_labels);
compare_or_equal!(self, other, rr_type); match self.record_type().cmp(&other.record_type()) {
o @ Ordering::Less | o @ Ordering::Greater => return o,
Ordering::Equal => {}
}
compare_or_equal!(self, other, dns_class); compare_or_equal!(self, other, dns_class);
compare_or_equal!(self, other, ttl); compare_or_equal!(self, other, ttl);
compare_or_equal!(self, other, rdata); compare_or_equal!(self, other, rdata);
@ -794,10 +705,9 @@ impl<'a> From<&'a Record> for Proven<&'a Record> {
/// A Record where the RecordData type is already known /// A Record where the RecordData type is already known
pub struct RecordRef<'a, R: RecordData> { pub struct RecordRef<'a, R: RecordData> {
name_labels: &'a Name, name_labels: &'a Name,
rr_type: RecordType,
dns_class: DNSClass, dns_class: DNSClass,
ttl: u32, ttl: u32,
rdata: Option<&'a R>, rdata: &'a R,
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: bool, mdns_cache_flush: bool,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -809,10 +719,9 @@ impl<'a, R: RecordData> RecordRef<'a, R> {
pub fn to_owned(&self) -> Record<R> { pub fn to_owned(&self) -> Record<R> {
Record { Record {
name_labels: self.name_labels.to_owned(), name_labels: self.name_labels.to_owned(),
rr_type: self.rr_type,
dns_class: self.dns_class, dns_class: self.dns_class,
ttl: self.ttl, ttl: self.ttl,
rdata: self.rdata.cloned(), rdata: self.rdata.clone(),
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: self.mdns_cache_flush, mdns_cache_flush: self.mdns_cache_flush,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -829,7 +738,7 @@ impl<'a, R: RecordData> RecordRef<'a, R> {
/// Returns the type of the RecordData in the record /// Returns the type of the RecordData in the record
#[inline] #[inline]
pub fn record_type(&self) -> RecordType { pub fn record_type(&self) -> RecordType {
self.rr_type self.rdata.record_type()
} }
/// Returns the DNSClass of the Record, generally IN fro internet /// Returns the DNSClass of the Record, generally IN fro internet
@ -846,7 +755,7 @@ impl<'a, R: RecordData> RecordRef<'a, R> {
/// Returns the Record Data, i.e. the record information /// Returns the Record Data, i.e. the record information
#[inline] #[inline]
pub fn data(&self) -> Option<&R> { pub fn data(&self) -> &R {
self.rdata self.rdata
} }
@ -874,7 +783,6 @@ impl<'a, R: RecordData> TryFrom<&'a Record> for RecordRef<'a, R> {
fn try_from(record: &'a Record) -> Result<Self, Self::Error> { fn try_from(record: &'a Record) -> Result<Self, Self::Error> {
let Record { let Record {
name_labels, name_labels,
rr_type,
dns_class, dns_class,
ttl, ttl,
rdata, rdata,
@ -884,24 +792,13 @@ impl<'a, R: RecordData> TryFrom<&'a Record> for RecordRef<'a, R> {
proof, proof,
} = record; } = record;
match rdata.as_ref().and_then(R::try_borrow) { match R::try_borrow(rdata) {
None => Ok(Self { None => Err(record),
name_labels,
rr_type: *rr_type,
dns_class: *dns_class,
ttl: *ttl,
rdata: None,
#[cfg(feature = "mdns")]
mdns_cache_flush: *mdns_cache_flush,
#[cfg(feature = "dnssec")]
proof: *proof,
}),
Some(rdata) => Ok(Self { Some(rdata) => Ok(Self {
name_labels, name_labels,
rr_type: *rr_type,
dns_class: *dns_class, dns_class: *dns_class,
ttl: *ttl, ttl: *ttl,
rdata: Some(rdata), rdata,
#[cfg(feature = "mdns")] #[cfg(feature = "mdns")]
mdns_cache_flush: *mdns_cache_flush, mdns_cache_flush: *mdns_cache_flush,
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -920,9 +817,8 @@ mod tests {
use super::*; use super::*;
use crate::rr::dns_class::DNSClass; use crate::rr::dns_class::DNSClass;
use crate::rr::rdata::A; use crate::rr::rdata::{A, AAAA};
use crate::rr::record_data::RData; use crate::rr::record_data::RData;
use crate::rr::record_type::RecordType;
use crate::rr::Name; use crate::rr::Name;
#[allow(clippy::useless_attribute)] #[allow(clippy::useless_attribute)]
#[allow(unused)] #[allow(unused)]
@ -930,13 +826,11 @@ mod tests {
#[test] #[test]
fn test_emit_and_read() { fn test_emit_and_read() {
let mut record = Record::new(); let record = Record::from_rdata(
record Name::from_str("www.example.com").unwrap(),
.set_name(Name::from_str("www.example.com").unwrap()) 5,
.set_record_type(RecordType::A) RData::A(A::new(192, 168, 0, 1)),
.set_dns_class(DNSClass::IN) );
.set_ttl(5)
.set_data(Some(RData::A(A::new(192, 168, 0, 1))));
let mut vec_bytes: Vec<u8> = Vec::with_capacity(512); let mut vec_bytes: Vec<u8> = Vec::with_capacity(512);
{ {
@ -953,25 +847,24 @@ mod tests {
#[test] #[test]
fn test_order() { fn test_order() {
let mut record = Record::new(); let mut record = Record::from_rdata(
record Name::from_str("www.example.com").unwrap(),
.set_name(Name::from_str("www.example.com").unwrap()) 5,
.set_record_type(RecordType::A) RData::A(A::new(192, 168, 0, 1)),
.set_dns_class(DNSClass::IN) );
.set_ttl(5) record.set_dns_class(DNSClass::IN);
.set_data(Some(RData::A(A::new(192, 168, 0, 1))));
let mut greater_name = record.clone(); let mut greater_name = record.clone();
greater_name.set_name(Name::from_str("zzz.example.com").unwrap()); greater_name.set_name(Name::from_str("zzz.example.com").unwrap());
let mut greater_type = record.clone().into_record_of_rdata(); let mut greater_type = record.clone().into_record_of_rdata();
greater_type.set_record_type(RecordType::AAAA); greater_type.set_data(RData::AAAA(AAAA::new(0, 0, 0, 0, 0, 0, 0, 0)));
let mut greater_class = record.clone(); let mut greater_class = record.clone();
greater_class.set_dns_class(DNSClass::NONE); greater_class.set_dns_class(DNSClass::NONE);
let mut greater_rdata = record.clone(); let mut greater_rdata = record.clone();
greater_rdata.set_data(Some(RData::A(A::new(192, 168, 0, 255)))); greater_rdata.set_data(RData::A(A::new(192, 168, 0, 255)));
let compares = vec![ let compares = vec![
(&record, &greater_name), (&record, &greater_name),
@ -993,7 +886,7 @@ mod tests {
const RR_CLASS_OFFSET: usize = 1 /* empty name */ + const RR_CLASS_OFFSET: usize = 1 /* empty name */ +
std::mem::size_of::<u16>() /* rr_type */; std::mem::size_of::<u16>() /* rr_type */;
let mut record = Record::<RData>::new(); let mut record = Record::<RData>::stub();
record.set_mdns_cache_flush(true); record.set_mdns_cache_flush(true);
let mut vec_bytes: Vec<u8> = Vec::with_capacity(512); let mut vec_bytes: Vec<u8> = Vec::with_capacity(512);

245
crates/proto/src/rr/rr_set.rs
View File

@ -231,7 +231,7 @@ impl RecordSet {
self.records self.records
.iter() .iter()
.find(|r| r.data().map(|r| r == rdata).unwrap_or(false)) .find(|r| r.data() == rdata)
.expect("insert failed") .expect("insert failed")
} }
@ -239,8 +239,7 @@ impl RecordSet {
pub fn add_rdata(&mut self, rdata: RData) -> bool { pub fn add_rdata(&mut self, rdata: RData) -> bool {
debug_assert_eq!(self.record_type, rdata.record_type()); debug_assert_eq!(self.record_type, rdata.record_type());
let mut record = Record::with(self.name.clone(), self.record_type, self.ttl); let record = Record::from_rdata(self.name.clone(), self.ttl, rdata);
record.set_data(Some(rdata));
self.insert(record, 0) self.insert(record, 0)
} }
@ -295,8 +294,8 @@ impl RecordSet {
if let Some(soa_record) = self.records.first() { if let Some(soa_record) = self.records.first() {
match soa_record.data() { match soa_record.data() {
Some(RData::SOA(ref existing_soa)) => { RData::SOA(ref existing_soa) => {
if let Some(RData::SOA(ref new_soa)) = record.data() { if let RData::SOA(ref new_soa) = record.data() {
if new_soa.serial() <= existing_soa.serial() { if new_soa.serial() <= existing_soa.serial() {
info!( info!(
"update ignored serial out of data: {:?} <= {:?}", "update ignored serial out of data: {:?} <= {:?}",
@ -561,14 +560,14 @@ impl<'r> Iterator for RrsigsByAlgorithms<'r> {
self.rrsigs self.rrsigs
.by_ref() .by_ref()
.filter(|record| { .filter(|record| {
if let Some(RData::DNSSEC(DNSSECRData::RRSIG(ref rrsig))) = record.data() { if let RData::DNSSEC(DNSSECRData::RRSIG(ref rrsig)) = record.data() {
supported_algorithms.has(rrsig.algorithm()) supported_algorithms.has(rrsig.algorithm())
} else { } else {
false false
} }
}) })
.max_by_key(|record| { .max_by_key(|record| {
if let Some(RData::DNSSEC(DNSSECRData::RRSIG(ref rrsig))) = record.data() { if let RData::DNSSEC(DNSSECRData::RRSIG(ref rrsig)) = record.data() {
rrsig.algorithm() rrsig.algorithm()
} else { } else {
#[allow(deprecated)] #[allow(deprecated)]
@ -626,13 +625,13 @@ mod test {
let record_type = RecordType::A; let record_type = RecordType::A;
let mut rr_set = RecordSet::new(&name, record_type, 0); let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new() let insert = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(86400) 86400,
.set_record_type(record_type) RData::A(Ipv4Addr::new(93, 184, 216, 24).into()),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 24).into()))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
assert!(rr_set.insert(insert.clone(), 0)); assert!(rr_set.insert(insert.clone(), 0));
assert_eq!(rr_set.records_without_rrsigs().count(), 1); assert_eq!(rr_set.records_without_rrsigs().count(), 1);
@ -644,13 +643,13 @@ mod test {
assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert)); assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert));
// add one // add one
let insert1 = Record::new() let insert1 = Record::from_rdata(
.set_name(name) name,
.set_ttl(86400) 86400,
.set_record_type(record_type) RData::A(Ipv4Addr::new(93, 184, 216, 25).into()),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 25).into()))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
assert!(rr_set.insert(insert1.clone(), 0)); assert!(rr_set.insert(insert1.clone(), 0));
assert_eq!(rr_set.records_without_rrsigs().count(), 2); assert_eq!(rr_set.records_without_rrsigs().count(), 2);
assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert)); assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert));
@ -664,12 +663,10 @@ mod test {
let record_type = RecordType::SOA; let record_type = RecordType::SOA;
let mut rr_set = RecordSet::new(&name, record_type, 0); let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new() let insert = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.org.").unwrap(), Name::from_str("sns.dns.icann.org.").unwrap(),
Name::from_str("noc.dns.icann.org.").unwrap(), Name::from_str("noc.dns.icann.org.").unwrap(),
2015082403, 2015082403,
@ -677,14 +674,14 @@ mod test {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(); )
let same_serial = Record::new() .set_dns_class(DNSClass::IN)
.set_name(name.clone()) .clone();
.set_ttl(3600) let same_serial = Record::from_rdata(
.set_record_type(RecordType::SOA) name.clone(),
.set_dns_class(DNSClass::IN) 3600,
.set_data(Some(RData::SOA(SOA::new( RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.net.").unwrap(), Name::from_str("sns.dns.icann.net.").unwrap(),
Name::from_str("noc.dns.icann.net.").unwrap(), Name::from_str("noc.dns.icann.net.").unwrap(),
2015082403, 2015082403,
@ -692,14 +689,14 @@ mod test {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(); )
let new_serial = Record::new() .set_dns_class(DNSClass::IN)
.set_name(name) .clone();
.set_ttl(3600) let new_serial = Record::from_rdata(
.set_record_type(RecordType::SOA) name,
.set_dns_class(DNSClass::IN) 3600,
.set_data(Some(RData::SOA(SOA::new( RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.net.").unwrap(), Name::from_str("sns.dns.icann.net.").unwrap(),
Name::from_str("noc.dns.icann.net.").unwrap(), Name::from_str("noc.dns.icann.net.").unwrap(),
2015082404, 2015082404,
@ -707,8 +704,10 @@ mod test {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(); )
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert.clone(), 0)); assert!(rr_set.insert(insert.clone(), 0));
assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert)); assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert));
@ -741,19 +740,11 @@ mod test {
let record_type = RecordType::CNAME; let record_type = RecordType::CNAME;
let mut rr_set = RecordSet::new(&name, record_type, 0); let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new() let insert = Record::from_rdata(name.clone(), 3600, RData::CNAME(CNAME(cname)))
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::CNAME)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(cname))))
.clone(); .clone();
let new_record = Record::new() let new_record = Record::from_rdata(name, 3600, RData::CNAME(CNAME(new_cname)))
.set_name(name)
.set_ttl(3600)
.set_record_type(RecordType::CNAME)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(new_cname))))
.clone(); .clone();
assert!(rr_set.insert(insert.clone(), 0)); assert!(rr_set.insert(insert.clone(), 0));
@ -773,20 +764,20 @@ mod test {
let record_type = RecordType::A; let record_type = RecordType::A;
let mut rr_set = RecordSet::new(&name, record_type, 0); let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new() let insert = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(86400) 86400,
.set_record_type(record_type) RData::A(Ipv4Addr::new(93, 184, 216, 24).into()),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 24).into()))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
let insert1 = Record::new() let insert1 = Record::from_rdata(
.set_name(name) name,
.set_ttl(86400) 86400,
.set_record_type(record_type) RData::A(Ipv4Addr::new(93, 184, 216, 25).into()),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 25).into()))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
assert!(rr_set.insert(insert.clone(), 0)); assert!(rr_set.insert(insert.clone(), 0));
assert!(rr_set.insert(insert1.clone(), 0)); assert!(rr_set.insert(insert1.clone(), 0));
@ -804,12 +795,10 @@ mod test {
let record_type = RecordType::SOA; let record_type = RecordType::SOA;
let mut rr_set = RecordSet::new(&name, record_type, 0); let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new() let insert = Record::from_rdata(
.set_name(name) name,
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.org.").unwrap(), Name::from_str("sns.dns.icann.org.").unwrap(),
Name::from_str("noc.dns.icann.org.").unwrap(), Name::from_str("noc.dns.icann.org.").unwrap(),
2015082403, 2015082403,
@ -817,8 +806,10 @@ mod test {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(); )
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert.clone(), 0)); assert!(rr_set.insert(insert.clone(), 0));
assert!(!rr_set.remove(&insert, 0)); assert!(!rr_set.remove(&insert, 0));
@ -831,24 +822,20 @@ mod test {
let record_type = RecordType::NS; let record_type = RecordType::NS;
let mut rr_set = RecordSet::new(&name, record_type, 0); let mut rr_set = RecordSet::new(&name, record_type, 0);
let ns1 = Record::new() let ns1 = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::from_str("a.iana-servers.net.").unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS( .set_dns_class(DNSClass::IN)
Name::from_str("a.iana-servers.net.").unwrap() .clone();
)))) let ns2 = Record::from_rdata(
.clone(); name,
let ns2 = Record::new() 86400,
.set_name(name) RData::NS(NS(Name::from_str("b.iana-servers.net.").unwrap())),
.set_ttl(86400) )
.set_record_type(RecordType::NS) .set_dns_class(DNSClass::IN)
.set_dns_class(DNSClass::IN) .clone();
.set_data(Some(RData::NS(NS(
Name::from_str("b.iana-servers.net.").unwrap()
))))
.clone();
assert!(rr_set.insert(ns1.clone(), 0)); assert!(rr_set.insert(ns1.clone(), 0));
assert!(rr_set.insert(ns2.clone(), 0)); assert!(rr_set.insert(ns2.clone(), 0));
@ -918,41 +905,37 @@ mod test {
vec![], vec![],
); );
let rrsig_rsa = Record::new() let rrsig_rsa = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::RRSIG) RData::DNSSEC(DNSSECRData::RRSIG(rsasha256)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(rsasha256)))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
let rrsig_ecp256 = Record::new() let rrsig_ecp256 = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::RRSIG) RData::DNSSEC(DNSSECRData::RRSIG(ecp256)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(ecp256)))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
let rrsig_ecp384 = Record::new() let rrsig_ecp384 = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::RRSIG) RData::DNSSEC(DNSSECRData::RRSIG(ecp384)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(ecp384)))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
let rrsig_ed25519 = Record::new() let rrsig_ed25519 = Record::from_rdata(
.set_name(name.clone()) name.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::RRSIG) RData::DNSSEC(DNSSECRData::RRSIG(ed25519)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(ed25519)))) .set_dns_class(DNSClass::IN)
.clone(); .clone();
let a = Record::new() let a = Record::from_rdata(name, 3600, RData::A(Ipv4Addr::new(93, 184, 216, 24).into()))
.set_name(name)
.set_ttl(3600)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 24).into())))
.clone(); .clone();
let mut rrset = RecordSet::from(a); let mut rrset = RecordSet::from(a);
@ -964,7 +947,7 @@ mod test {
assert!(rrset assert!(rrset
.records_with_rrsigs(SupportedAlgorithms::all(),) .records_with_rrsigs(SupportedAlgorithms::all(),)
.any( .any(
|r| if let Some(RData::DNSSEC(DNSSECRData::RRSIG(ref sig))) = r.data() { |r| if let RData::DNSSEC(DNSSECRData::RRSIG(ref sig)) = r.data() {
sig.algorithm() == Algorithm::ED25519 sig.algorithm() == Algorithm::ED25519
} else { } else {
false false
@ -974,7 +957,7 @@ mod test {
let mut supported_algorithms = SupportedAlgorithms::new(); let mut supported_algorithms = SupportedAlgorithms::new();
supported_algorithms.set(Algorithm::ECDSAP384SHA384); supported_algorithms.set(Algorithm::ECDSAP384SHA384);
assert!(rrset.records_with_rrsigs(supported_algorithms).any(|r| { assert!(rrset.records_with_rrsigs(supported_algorithms).any(|r| {
if let Some(RData::DNSSEC(DNSSECRData::RRSIG(ref sig))) = r.data() { if let RData::DNSSEC(DNSSECRData::RRSIG(ref sig)) = r.data() {
sig.algorithm() == Algorithm::ECDSAP384SHA384 sig.algorithm() == Algorithm::ECDSAP384SHA384
} else { } else {
false false
@ -984,7 +967,7 @@ mod test {
let mut supported_algorithms = SupportedAlgorithms::new(); let mut supported_algorithms = SupportedAlgorithms::new();
supported_algorithms.set(Algorithm::ED25519); supported_algorithms.set(Algorithm::ED25519);
assert!(rrset.records_with_rrsigs(supported_algorithms).any(|r| { assert!(rrset.records_with_rrsigs(supported_algorithms).any(|r| {
if let Some(RData::DNSSEC(DNSSECRData::RRSIG(ref sig))) = r.data() { if let RData::DNSSEC(DNSSECRData::RRSIG(ref sig)) = r.data() {
sig.algorithm() == Algorithm::ED25519 sig.algorithm() == Algorithm::ED25519
} else { } else {
false false

7
crates/proto/src/serialize/txt/rdata_parsers/svcb.rs
View File

@ -377,12 +377,7 @@ mod tests {
.expect("failed to parse record") .expect("failed to parse record")
.1; .1;
let record_set = records.into_iter().next().expect("no record found").1; let record_set = records.into_iter().next().expect("no record found").1;
record_set D::try_borrow(record_set.into_iter().next().unwrap().data())
.into_iter()
.next()
.unwrap()
.data()
.and_then(D::try_borrow)
.expect("Not the correct record") .expect("Not the correct record")
.clone() .clone()
} }

25
crates/proto/src/serialize/txt/zone.rs
View File

@ -369,44 +369,41 @@ impl<'a> Parser<'a> {
)?; )?;
// verify that we have everything we need for the record // verify that we have everything we need for the record
let mut record = Record::new();
// TODO COW or RC would reduce mem usage, perhaps Name should have an intern()... // TODO COW or RC would reduce mem usage, perhaps Name should have an intern()...
// might want to wait until RC.weak() stabilizes, as that would be needed for global // might want to wait until RC.weak() stabilizes, as that would be needed for global
// memory where you want // memory where you want
record.set_name(current_name.clone().ok_or_else(|| { let name = current_name.clone().ok_or_else(|| {
ParseError::from(ParseErrorKind::Message("record name not specified")) ParseError::from(ParseErrorKind::Message("record name not specified"))
})?); })?;
record.set_record_type(rtype);
record.set_dns_class(class);
// slightly annoying, need to grab the TTL, then move rdata into the record, // slightly annoying, need to grab the TTL, then move rdata into the record,
// then check the Type again and have custom add logic. // then check the Type again and have custom add logic.
match rtype { let set_ttl = match rtype {
RecordType::SOA => { RecordType::SOA => {
// TTL for the SOA is set internally... // TTL for the SOA is set internally...
// expire is for the SOA, minimum is default for records // expire is for the SOA, minimum is default for records
if let RData::SOA(ref soa) = rdata { if let RData::SOA(ref soa) = rdata {
// TODO, this looks wrong, get_expire() should be get_minimum(), right? // TODO, this looks wrong, get_expire() should be get_minimum(), right?
record.set_ttl(soa.expire() as u32); // the spec seems a little inaccurate with u32 and i32 let set_ttl = soa.expire() as u32; // the spec seems a little inaccurate with u32 and i32
if ttl.is_none() { if ttl.is_none() {
*ttl = Some(soa.minimum()); *ttl = Some(soa.minimum());
} // TODO: should this only set it if it's not set? } // TODO: should this only set it if it's not set?
set_ttl
} else { } else {
let msg = format!("Invalid RData here, expected SOA: {rdata:?}"); let msg = format!("Invalid RData here, expected SOA: {rdata:?}");
return ParseResult::Err(ParseError::from(ParseErrorKind::Msg(msg))); return ParseResult::Err(ParseError::from(ParseErrorKind::Msg(msg)));
} }
} }
_ => { _ => ttl.ok_or_else(|| {
record.set_ttl(ttl.ok_or_else(|| { ParseError::from(ParseErrorKind::Message("record ttl not specified"))
ParseError::from(ParseErrorKind::Message("record ttl not specified")) })?,
})?); };
}
}
// TODO: validate record, e.g. the name of SRV record allows _ but others do not. // TODO: validate record, e.g. the name of SRV record allows _ but others do not.
// move the rdata into record... // move the rdata into record...
record.set_data(Some(rdata)); let mut record = Record::from_rdata(name, set_ttl, rdata);
record.set_dns_class(class);
// add to the map // add to the map
let key = RrKey::new(LowerName::new(record.name()), record.record_type()); let key = RrKey::new(LowerName::new(record.name()), record.record_type());

2
crates/proto/src/tests/udp.rs
View File

@ -224,7 +224,7 @@ pub fn udp_client_stream_test<S: UdpSocket + Send + 'static, E: Executor>(
println!("client got response {i}"); println!("client got response {i}");
let response = Message::from(response); let response = Message::from(response);
if let Some(RData::NULL(null)) = response.answers()[0].data() { if let RData::NULL(null) = response.answers()[0].data() {
assert_eq!(null.anything(), test_bytes); assert_eq!(null.anything(), test_bytes);
} else { } else {
panic!("not a NULL response"); panic!("not a NULL response");

96
crates/proto/src/xfer/dns_multiplexer.rs
View File

@ -548,13 +548,13 @@ mod test {
let query = msg.clone(); let query = msg.clone();
msg.set_message_type(MessageType::Response).add_answer( msg.set_message_type(MessageType::Response).add_answer(
Record::new() Record::from_rdata(
.set_name(name) name,
.set_ttl(86400) 86400,
.set_record_type(RecordType::A) RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into()))) .set_dns_class(DNSClass::IN)
.clone(), .clone(),
); );
( (
DnsRequest::new(query, DnsRequestOptions::default()), DnsRequest::new(query, DnsRequestOptions::default()),
@ -580,12 +580,10 @@ mod test {
fn axfr_response() -> Vec<Record> { fn axfr_response() -> Vec<Record> {
use crate::rr::rdata::*; use crate::rr::rdata::*;
let origin = Name::from_ascii("example.com").unwrap(); let origin = Name::from_ascii("example.com").unwrap();
let soa = Record::new() let soa = Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403, 2015082403,
@ -593,52 +591,46 @@ mod test {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(); )
.set_dns_class(DNSClass::IN)
.clone();
vec![ vec![
soa.clone(), soa.clone(),
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"a.iana-servers.net.", .clone(),
None, Record::from_rdata(
) origin.clone(),
.unwrap())))) 86400,
.clone(), RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
Record::new() )
.set_name(origin.clone()) .set_dns_class(DNSClass::IN)
.set_ttl(86400) .clone(),
.set_record_type(RecordType::NS) Record::from_rdata(
.set_dns_class(DNSClass::IN) origin.clone(),
.set_data(Some(RData::NS(NS(Name::parse( 86400,
"b.iana-servers.net.", RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
None, )
) .set_dns_class(DNSClass::IN)
.unwrap())))) .clone(),
.clone(), Record::from_rdata(
Record::new() origin,
.set_name(origin.clone()) 86400,
.set_ttl(86400) RData::AAAA(
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into())))
.clone(),
Record::new()
.set_name(origin)
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(
Ipv6Addr::new( Ipv6Addr::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
) )
.into(), .into(),
))) ),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
soa, soa,
] ]
} }

9
crates/proto/src/xfer/dns_response.rs
View File

@ -22,7 +22,7 @@ use futures_util::{ready, stream::Stream};
use crate::{ use crate::{
error::{ProtoError, ProtoErrorKind, ProtoResult}, error::{ProtoError, ProtoErrorKind, ProtoResult},
op::{Message, ResponseCode}, op::{Message, ResponseCode},
rr::{rdata::SOA, resource::RecordRef, RData, RecordType}, rr::{rdata::SOA, resource::RecordRef, RecordType},
}; };
/// A stream returning DNS responses /// A stream returning DNS responses
@ -217,12 +217,7 @@ impl DnsResponse {
// TODO: should this ensure that the SOA zone matches the Queried Zone? // TODO: should this ensure that the SOA zone matches the Queried Zone?
self.name_servers() self.name_servers()
.iter() .iter()
.filter_map(|record| { .filter_map(|record| record.data().as_soa().map(|soa| (record.ttl(), soa)))
record
.data()
.and_then(RData::as_soa)
.map(|soa| (record.ttl(), soa))
})
.next() .next()
.map(|(ttl, soa)| (ttl).min(soa.minimum())) .map(|(ttl, soa)| (ttl).min(soa.minimum()))
} }

18
crates/proto/src/xfer/dnssec_dns_handle.rs
View File

@ -30,7 +30,7 @@ use crate::{
Algorithm, Proof, ProofError, ProofErrorKind, SupportedAlgorithms, TrustAnchor, Algorithm, Proof, ProofError, ProofErrorKind, SupportedAlgorithms, TrustAnchor,
}, },
rdata::opt::EdnsOption, rdata::opt::EdnsOption,
DNSClass, Name, RData, Record, RecordData, RecordType, DNSClass, Name, Record, RecordData, RecordType,
}, },
xfer::{dns_handle::DnsHandle, DnsRequest, DnsRequestOptions, DnsResponse, FirstAnswer}, xfer::{dns_handle::DnsHandle, DnsRequest, DnsRequestOptions, DnsResponse, FirstAnswer},
}; };
@ -320,7 +320,7 @@ where
let rrsigs: Vec<&RRSIG> = records let rrsigs: Vec<&RRSIG> = records
.iter() .iter()
.filter(|rr| rr.record_type() == RecordType::RRSIG && rr.name() == &name) .filter(|rr| rr.record_type() == RecordType::RRSIG && rr.name() == &name)
.filter_map(|rr| rr.data()) .map(|rr| rr.data())
.filter_map(|rrsig| RRSIG::try_borrow(rrsig)) .filter_map(|rrsig| RRSIG::try_borrow(rrsig))
.filter(|rrsig| rrsig.type_covered() == record_type) .filter(|rrsig| rrsig.type_covered() == record_type)
.collect(); .collect();
@ -426,7 +426,7 @@ where
let anchored_keys: Vec<&DNSKEY> = rrset let anchored_keys: Vec<&DNSKEY> = rrset
.records .records
.iter() .iter()
.filter_map(|r| r.data()) .map(|r| r.data())
.filter_map(DNSKEY::try_borrow) .filter_map(DNSKEY::try_borrow)
.filter(|dnskey| { .filter(|dnskey| {
if handle if handle
@ -458,12 +458,12 @@ where
.records .records
.iter() .iter()
.enumerate() .enumerate()
.filter_map(|(i, rr)| rr.data().map(|d| (i, d))) .map(|(i, rr)| (i, rr.data()))
.filter_map(|(i, data)| DNSKEY::try_borrow(data).map(|d| (i, d))) .filter_map(|(i, data)| DNSKEY::try_borrow(data).map(|d| (i, d)))
.filter(|&(_, key_rdata)| { .filter(|&(_, key_rdata)| {
ds_records ds_records
.iter() .iter()
.filter_map(|r| r.data().map(|d| (d, r.name()))) .map(|r| (r.data(), r.name()))
// must be covered by at least one DS record // must be covered by at least one DS record
.any(|(ds_rdata, ds_name)| { .any(|(ds_rdata, ds_name)| {
if ds_rdata.covers(&rrset.name, key_rdata).unwrap_or(false) { if ds_rdata.covers(&rrset.name, key_rdata).unwrap_or(false) {
@ -640,7 +640,7 @@ where
rrset rrset
.records .records
.iter() .iter()
.filter_map(|r| r.data().map(|d| (d, r.name()))) .map(|r| (r.data(), r.name()))
.filter_map(|(d, n)| DNSKEY::try_borrow(d).map(|d| (d, n))) .filter_map(|(d, n)| DNSKEY::try_borrow(d).map(|d| (d, n)))
.find_map(|(dnskey, dnskey_name)| { .find_map(|(dnskey, dnskey_name)| {
// If we had rrsigs to verify, then we want them to be secure, or the result is a Bogus proof // If we had rrsigs to verify, then we want them to be secure, or the result is a Bogus proof
@ -687,7 +687,7 @@ where
message message
.answers() .answers()
.iter() .iter()
.filter_map(|r| r.data().map(|data| (r.name(), data))) .map(|r| (r.name(), r.data()))
.filter_map(|(dnskey_name, data)| { .filter_map(|(dnskey_name, data)| {
DNSKEY::try_borrow(data).map(|data| (dnskey_name, data)) DNSKEY::try_borrow(data).map(|data| (dnskey_name, data))
}) })
@ -854,7 +854,7 @@ pub fn verify_nsec(query: Arc<Query>, soa_name: &Name, nsecs: &[&Record]) -> Pro
if let Some(nsec) = nsecs.iter().find(|nsec| query.name() == nsec.name()) { if let Some(nsec) = nsecs.iter().find(|nsec| query.name() == nsec.name()) {
if nsec if nsec
.data() .data()
.and_then(RData::as_dnssec) .as_dnssec()
.and_then(DNSSECRData::as_nsec) .and_then(DNSSECRData::as_nsec)
.map_or(false, |rdata| { .map_or(false, |rdata| {
// this should not be in the covered list // this should not be in the covered list
@ -872,7 +872,7 @@ pub fn verify_nsec(query: Arc<Query>, soa_name: &Name, nsecs: &[&Record]) -> Pro
// the query name must be greater than nsec's label (or equal in the case of wildcard) // the query name must be greater than nsec's label (or equal in the case of wildcard)
name >= nsec.name() && { name >= nsec.name() && {
nsec.data() nsec.data()
.and_then(RData::as_dnssec) .as_dnssec()
.and_then(DNSSECRData::as_nsec) .and_then(DNSSECRData::as_nsec)
.map_or(false, |rdata| { .map_or(false, |rdata| {
// the query name is less than the next name // the query name is less than the next name

2
crates/recursor/src/recursor.rs
View File

@ -476,7 +476,7 @@ impl Recursor {
// unpack all glued records // unpack all glued records
for zns in response.record_iter() { for zns in response.record_iter() {
if let Some(ns_data) = zns.data().and_then(RData::as_ns) { if let Some(ns_data) = zns.data().as_ns() {
// let glue_ips = glue // let glue_ips = glue
// .iter() // .iter()
// .filter(|g| g.name() == ns_data) // .filter(|g| g.name() == ns_data)

2
crates/resolver/src/async_resolver.rs
View File

@ -426,7 +426,7 @@ impl<P: ConnectionProvider> AsyncResolver<P> {
self.client_cache.clone(), self.client_cache.clone(),
self.request_options(), self.request_options(),
hosts, hosts,
finally_ip_addr.and_then(Record::into_data), finally_ip_addr.map(Record::into_data),
) )
.await .await
} }

4
crates/resolver/src/caching_client.rs
View File

@ -345,7 +345,7 @@ where
(Cow::Borrowed(query.name()), INITIAL_TTL, false), (Cow::Borrowed(query.name()), INITIAL_TTL, false),
|(search_name, cname_ttl, was_cname), r| { |(search_name, cname_ttl, was_cname), r| {
match r.data() { match r.data() {
Some(RData::CNAME(CNAME(ref cname))) => { RData::CNAME(CNAME(ref cname)) => {
// take the minimum TTL of the cname_ttl and the next record in the chain // take the minimum TTL of the cname_ttl and the next record in the chain
let ttl = cname_ttl.min(r.ttl()); let ttl = cname_ttl.min(r.ttl());
debug_assert_eq!(r.record_type(), RecordType::CNAME); debug_assert_eq!(r.record_type(), RecordType::CNAME);
@ -353,7 +353,7 @@ where
return (Cow::Owned(cname.clone()), ttl, true); return (Cow::Owned(cname.clone()), ttl, true);
} }
} }
Some(RData::SRV(ref srv)) => { RData::SRV(ref srv) => {
// take the minimum TTL of the cname_ttl and the next record in the chain // take the minimum TTL of the cname_ttl and the next record in the chain
let ttl = cname_ttl.min(r.ttl()); let ttl = cname_ttl.min(r.ttl());
debug_assert_eq!(r.record_type(), RecordType::SRV); debug_assert_eq!(r.record_type(), RecordType::SRV);

11
crates/resolver/src/lookup.rs
View File

@ -147,7 +147,7 @@ impl<'a> Iterator for LookupIter<'a> {
type Item = &'a RData; type Item = &'a RData;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
self.0.next().and_then(Record::data) self.0.next().map(Record::data)
} }
} }
@ -161,7 +161,7 @@ impl<'a> Iterator for DnssecIter<'a> {
type Item = Proven<&'a RData>; type Item = Proven<&'a RData>;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
self.0.next().and_then(|r| r.map(Record::data).transpose()) self.0.next().map(|r| r.map(Record::data))
} }
} }
@ -218,7 +218,7 @@ impl Iterator for LookupIntoIter {
type Item = RData; type Item = RData;
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
let rdata = self.records.get(self.index).and_then(Record::data); let rdata = self.records.get(self.index).map(Record::data);
self.index += 1; self.index += 1;
rdata.cloned() rdata.cloned()
} }
@ -658,7 +658,6 @@ pub mod tests {
.unwrap() .unwrap()
.records()[0] .records()[0]
) )
.unwrap()
.ip_addr() .ip_addr()
.unwrap(), .unwrap(),
Ipv4Addr::new(127, 0, 0, 1) Ipv4Addr::new(127, 0, 0, 1)
@ -769,11 +768,11 @@ pub mod tests {
assert_eq!( assert_eq!(
*lookup.next().unwrap().require(Proof::Secure).unwrap(), *lookup.next().unwrap().require(Proof::Secure).unwrap(),
*a1.data().unwrap() *a1.data()
); );
assert_eq!( assert_eq!(
*lookup.next().unwrap().require(Proof::Insecure).unwrap(), *lookup.next().unwrap().require(Proof::Insecure).unwrap(),
*a2.data().unwrap() *a2.data()
); );
assert_eq!(lookup.next(), None); assert_eq!(lookup.next(), None);
} }

5
crates/resolver/src/name_server/name_server_pool.rs
View File

@ -483,7 +483,6 @@ mod tests {
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use hickory_proto::rr::RData;
use proto::op::Query; use proto::op::Query;
use proto::rr::{Name, RecordType}; use proto::rr::{Name, RecordType};
use proto::xfer::{DnsHandle, DnsRequestOptions}; use proto::xfer::{DnsHandle, DnsRequestOptions};
@ -619,7 +618,7 @@ mod tests {
assert_eq!( assert_eq!(
*response.answers()[0] *response.answers()[0]
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("no a record available"), .expect("no a record available"),
Ipv4Addr::new(93, 184, 215, 14).into() Ipv4Addr::new(93, 184, 215, 14).into()
); );
@ -643,7 +642,7 @@ mod tests {
assert_eq!( assert_eq!(
*response.answers()[0] *response.answers()[0]
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("no aaaa record available"), .expect("no aaaa record available"),
Ipv6Addr::new(0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c).into() Ipv6Addr::new(0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c).into()
); );

28
crates/server/src/authority/message_response.rs
View File

@ -257,7 +257,7 @@ mod tests {
use std::str::FromStr; use std::str::FromStr;
use crate::proto::op::{Header, Message}; use crate::proto::op::{Header, Message};
use crate::proto::rr::{DNSClass, Name, RData, Record, RecordType}; use crate::proto::rr::{DNSClass, Name, RData, Record};
use crate::proto::serialize::binary::BinEncoder; use crate::proto::serialize::binary::BinEncoder;
use super::*; use super::*;
@ -269,12 +269,13 @@ mod tests {
let mut encoder = BinEncoder::new(&mut buf); let mut encoder = BinEncoder::new(&mut buf);
encoder.set_max_size(512); encoder.set_max_size(512);
let answer = Record::new() let answer = Record::from_rdata(
.set_record_type(RecordType::A) Name::from_str("www.example.com.").unwrap(),
.set_name(Name::from_str("www.example.com.").unwrap()) 0,
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into()))) RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
.set_dns_class(DNSClass::NONE) )
.clone(); .set_dns_class(DNSClass::NONE)
.clone();
let message = MessageResponse { let message = MessageResponse {
header: Header::new(), header: Header::new(),
@ -306,12 +307,13 @@ mod tests {
let mut encoder = BinEncoder::new(&mut buf); let mut encoder = BinEncoder::new(&mut buf);
encoder.set_max_size(512); encoder.set_max_size(512);
let answer = Record::new() let answer = Record::from_rdata(
.set_record_type(RecordType::A) Name::from_str("www.example.com.").unwrap(),
.set_name(Name::from_str("www.example.com.").unwrap()) 0,
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into()))) RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
.set_dns_class(DNSClass::NONE) )
.clone(); .set_dns_class(DNSClass::NONE)
.clone();
let message = MessageResponse { let message = MessageResponse {
header: Header::new(), header: Header::new(),

4
crates/server/src/store/file/authority.rs
View File

@ -277,7 +277,7 @@ mod tests {
.expect("A record not found in authority") .expect("A record not found in authority")
.data() .data()
{ {
Some(RData::A(ip)) => assert_eq!(A::new(127, 0, 0, 1), *ip), RData::A(ip) => assert_eq!(A::new(127, 0, 0, 1), *ip),
_ => panic!("wrong rdata type returned"), _ => panic!("wrong rdata type returned"),
} }
@ -295,7 +295,7 @@ mod tests {
.expect("A record not found in authority") .expect("A record not found in authority")
.data() .data()
{ {
Some(RData::A(ip)) => assert_eq!(A::new(127, 0, 0, 5), *ip), RData::A(ip) => assert_eq!(A::new(127, 0, 0, 5), *ip),
_ => panic!("wrong rdata type returned"), _ => panic!("wrong rdata type returned"),
} }
} }

43
crates/server/src/store/in_memory/authority.rs
View File

@ -91,7 +91,7 @@ impl InMemoryAuthority {
.iter() .iter()
.find(|(key, _)| key.record_type == RecordType::SOA) .find(|(key, _)| key.record_type == RecordType::SOA)
.and_then(|(_, rrset)| rrset.records_without_rrsigs().next()) .and_then(|(_, rrset)| rrset.records_without_rrsigs().next())
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_soa) .and_then(RData::as_soa)
.map(SOA::serial) .map(SOA::serial)
.ok_or_else(|| format!("SOA record must be present: {origin}"))?; .ok_or_else(|| format!("SOA record must be present: {origin}"))?;
@ -345,7 +345,7 @@ impl InnerInMemory {
self.records self.records
.get(&rr_key) .get(&rr_key)
.and_then(|rrset| rrset.records_without_rrsigs().next()) .and_then(|rrset| rrset.records_without_rrsigs().next())
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_soa) .and_then(RData::as_soa)
} }
@ -449,9 +449,7 @@ impl InnerInMemory {
}; };
for record in records { for record in records {
if let Some(rdata) = record.data() { new_answer.add_rdata(record.data().clone());
new_answer.add_rdata(rdata.clone());
}
} }
#[cfg(feature = "dnssec")] #[cfg(feature = "dnssec")]
@ -548,7 +546,7 @@ impl InnerInMemory {
return 0; return 0;
}; };
let serial = if let Some(RData::SOA(ref mut soa_rdata)) = record.data_mut() { let serial = if let RData::SOA(ref mut soa_rdata) = record.data_mut() {
soa_rdata.increment_serial(); soa_rdata.increment_serial();
soa_rdata.serial() soa_rdata.serial()
} else { } else {
@ -699,10 +697,9 @@ impl InnerInMemory {
} }
Some((name, vec)) => { Some((name, vec)) => {
// names aren't equal, create the NSEC record // names aren't equal, create the NSEC record
let mut record = Record::with(name.clone(), RecordType::NSEC, ttl);
let rdata = NSEC::new_cover_self(key.name.clone().into(), vec); let rdata = NSEC::new_cover_self(key.name.clone().into(), vec);
record.set_data(Some(RData::DNSSEC(DNSSECRData::NSEC(rdata)))); let record = Record::from_rdata(name.clone(), ttl, rdata);
records.push(record); records.push(record.into_record_of_rdata());
// new record... // new record...
nsec_info = Some((key.name.borrow(), vec![key.record_type])) nsec_info = Some((key.name.borrow(), vec![key.record_type]))
@ -713,10 +710,9 @@ impl InnerInMemory {
// the last record // the last record
if let Some((name, vec)) = nsec_info { if let Some((name, vec)) = nsec_info {
// names aren't equal, create the NSEC record // names aren't equal, create the NSEC record
let mut record = Record::with(name.clone(), RecordType::NSEC, ttl);
let rdata = NSEC::new_cover_self(origin.clone().into(), vec); let rdata = NSEC::new_cover_self(origin.clone().into(), vec);
record.set_data(Some(RData::DNSSEC(DNSSECRData::NSEC(rdata)))); let record = Record::from_rdata(name.clone(), ttl, rdata);
records.push(record); records.push(record.into_record_of_rdata());
} }
} }
@ -750,7 +746,7 @@ impl InnerInMemory {
rr_set.clear_rrsigs(); rr_set.clear_rrsigs();
let rrsig_temp = Record::with(rr_set.name().clone(), RecordType::RRSIG, zone_ttl); let rrsig_temp = Record::update0(rr_set.name().clone(), zone_ttl, RecordType::RRSIG);
for signer in secure_keys { for signer in secure_keys {
debug!( debug!(
@ -800,7 +796,7 @@ impl InnerInMemory {
}; };
let mut rrsig = rrsig_temp.clone(); let mut rrsig = rrsig_temp.clone();
rrsig.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(RRSIG::new( rrsig.set_data(RData::DNSSEC(DNSSECRData::RRSIG(RRSIG::new(
// type_covered: RecordType, // type_covered: RecordType,
rr_set.record_type(), rr_set.record_type(),
// algorithm: Algorithm, // algorithm: Algorithm,
@ -819,7 +815,7 @@ impl InnerInMemory {
signer.signer_name().clone(), signer.signer_name().clone(),
// sig: Vec<u8> // sig: Vec<u8>
signature, signature,
))))); ))));
rr_set.insert_rrsig(rrsig); rr_set.insert_rrsig(rrsig);
} }
@ -869,14 +865,14 @@ fn maybe_next_name(
| (t @ RecordType::ANAME, RecordType::ANAME) => record_set | (t @ RecordType::ANAME, RecordType::ANAME) => record_set
.records_without_rrsigs() .records_without_rrsigs()
.next() .next()
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_aname) .and_then(RData::as_aname)
.map(|aname| LowerName::from(&aname.0)) .map(|aname| LowerName::from(&aname.0))
.map(|name| (name, t)), .map(|name| (name, t)),
(t @ RecordType::NS, RecordType::NS) => record_set (t @ RecordType::NS, RecordType::NS) => record_set
.records_without_rrsigs() .records_without_rrsigs()
.next() .next()
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_ns) .and_then(RData::as_ns)
.map(|ns| LowerName::from(&ns.0)) .map(|ns| LowerName::from(&ns.0))
.map(|name| (name, t)), .map(|name| (name, t)),
@ -884,14 +880,14 @@ fn maybe_next_name(
(t @ RecordType::CNAME, _) => record_set (t @ RecordType::CNAME, _) => record_set
.records_without_rrsigs() .records_without_rrsigs()
.next() .next()
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_cname) .and_then(RData::as_cname)
.map(|cname| LowerName::from(&cname.0)) .map(|cname| LowerName::from(&cname.0))
.map(|name| (name, t)), .map(|name| (name, t)),
(t @ RecordType::MX, RecordType::MX) => record_set (t @ RecordType::MX, RecordType::MX) => record_set
.records_without_rrsigs() .records_without_rrsigs()
.next() .next()
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_mx) .and_then(RData::as_mx)
.map(|mx| mx.exchange().clone()) .map(|mx| mx.exchange().clone())
.map(LowerName::from) .map(LowerName::from)
@ -899,7 +895,7 @@ fn maybe_next_name(
(t @ RecordType::SRV, RecordType::SRV) => record_set (t @ RecordType::SRV, RecordType::SRV) => record_set
.records_without_rrsigs() .records_without_rrsigs()
.next() .next()
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_srv) .and_then(RData::as_srv)
.map(|srv| srv.target().clone()) .map(|srv| srv.target().clone())
.map(LowerName::from) .map(LowerName::from)
@ -1075,10 +1071,7 @@ impl Authority for InMemoryAuthority {
_ => None, _ => None,
}) })
.map(|records| { .map(|records| {
records records.map(Record::data).cloned().collect::<Vec<_>>()
.filter_map(Record::data)
.cloned()
.collect::<Vec<_>>()
}); });
(rdatas, a_aaaa_ttl) (rdatas, a_aaaa_ttl)
@ -1266,7 +1259,7 @@ impl Authority for InMemoryAuthority {
rr_set rr_set
.records(false, SupportedAlgorithms::default()) .records(false, SupportedAlgorithms::default())
.next() .next()
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_dnssec) .and_then(RData::as_dnssec)
.and_then(DNSSECRData::as_nsec) .and_then(DNSSECRData::as_nsec)
.map_or(false, |r| { .map_or(false, |r| {

2
crates/server/src/store/recursor/config.rs
View File

@ -65,7 +65,7 @@ impl RecursiveConfig {
Ok(roots_zone Ok(roots_zone
.values() .values()
.flat_map(RecordSet::records_without_rrsigs) .flat_map(RecordSet::records_without_rrsigs)
.filter_map(Record::data) .map(Record::data)
.filter_map(RData::ip_addr) // we only want IPs .filter_map(RData::ip_addr) // we only want IPs
.map(|ip| SocketAddr::from((ip, 53))) // all the roots only have tradition DNS ports .map(|ip| SocketAddr::from((ip, 53))) // all the roots only have tradition DNS ports
.collect()) .collect())

29
crates/server/src/store/sqlite/authority.rs
View File

@ -185,7 +185,10 @@ impl SqliteAuthority {
info!("persisting zone to journal at SOA.serial: {}", serial); info!("persisting zone to journal at SOA.serial: {}", serial);
// TODO: THIS NEEDS TO BE IN A TRANSACTION!!! // TODO: THIS NEEDS TO BE IN A TRANSACTION!!!
journal.insert_record(serial, Record::new().set_record_type(RecordType::AXFR))?; journal.insert_record(
serial,
&Record::update0(Name::new(), 0, RecordType::AXFR).into_record_of_rdata(),
)?;
for rr_set in self.in_memory.records().await.values() { for rr_set in self.in_memory.records().await.values() {
// TODO: should we preserve rr_sets or not? // TODO: should we preserve rr_sets or not?
@ -323,7 +326,7 @@ impl SqliteAuthority {
match require.dns_class() { match require.dns_class() {
DNSClass::ANY => { DNSClass::ANY => {
if let None | Some(RData::NULL(..)) = require.data() { if let RData::Update0(_) | RData::NULL(..) = require.data() {
match require.record_type() { match require.record_type() {
// ANY ANY empty Name is in use // ANY ANY empty Name is in use
RecordType::ANY => { RecordType::ANY => {
@ -361,7 +364,7 @@ impl SqliteAuthority {
} }
} }
DNSClass::NONE => { DNSClass::NONE => {
if let None | Some(RData::NULL(..)) = require.data() { if let RData::Update0(_) | RData::NULL(..) = require.data() {
match require.record_type() { match require.record_type() {
// NONE ANY empty Name is not in use // NONE ANY empty Name is not in use
RecordType::ANY => { RecordType::ANY => {
@ -477,11 +480,10 @@ impl SqliteAuthority {
debug!("authorizing with: {:?}", sig0s); debug!("authorizing with: {:?}", sig0s);
if !sig0s.is_empty() { if !sig0s.is_empty() {
let mut found_key = false; let mut found_key = false;
for sig in sig0s.iter().filter_map(|sig0| { for sig in sig0s
sig0.data() .iter()
.and_then(RData::as_dnssec) .filter_map(|sig0| sig0.data().as_dnssec().and_then(DNSSECRData::as_sig))
.and_then(DNSSECRData::as_sig) {
}) {
let name = LowerName::from(sig.signer_name()); let name = LowerName::from(sig.signer_name());
let keys = self let keys = self
.lookup(&name, RecordType::KEY, LookupOptions::default()) .lookup(&name, RecordType::KEY, LookupOptions::default())
@ -496,12 +498,7 @@ impl SqliteAuthority {
// TODO: check key usage flags and restrictions // TODO: check key usage flags and restrictions
found_key = keys found_key = keys
.iter() .iter()
.filter_map(|rr_set| { .filter_map(|rr_set| rr_set.data().as_dnssec().and_then(DNSSECRData::as_key))
rr_set
.data()
.and_then(RData::as_dnssec)
.and_then(DNSSECRData::as_key)
})
.any(|key| { .any(|key| {
key.verify_message(update_message, sig.sig(), sig) key.verify_message(update_message, sig.sig(), sig)
.map(|_| { .map(|_| {
@ -598,7 +595,7 @@ impl SqliteAuthority {
if rr.ttl() != 0 { if rr.ttl() != 0 {
return Err(ResponseCode::FormErr); return Err(ResponseCode::FormErr);
} }
if let None | Some(RData::NULL(..)) = rr.data() { if let RData::Update0(_) | RData::NULL(..) = rr.data() {
() ()
} else { } else {
return Err(ResponseCode::FormErr); return Err(ResponseCode::FormErr);
@ -773,7 +770,7 @@ impl SqliteAuthority {
// SOA or NS RRs will be deleted. // SOA or NS RRs will be deleted.
// ANY rrset empty Delete an RRset // ANY rrset empty Delete an RRset
if let None | Some(RData::NULL(..)) = rr.data() { if let RData::Update0(_) | RData::NULL(..) = rr.data() {
let deleted = self.in_memory.records_mut().await.remove(&rr_key); let deleted = self.in_memory.records_mut().await.remove(&rr_key);
info!("deleted rrset: {:?}", deleted); info!("deleted rrset: {:?}", deleted);
updated = updated || deleted.is_some(); updated = updated || deleted.is_some();

68
crates/server/tests/authority_battery/basic.rs
View File

@ -37,7 +37,7 @@ pub fn test_a_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found in authority") .expect("A record not found in authority")
.data() .data()
.and_then(RData::as_a) .as_a()
{ {
Some(ip) => assert_eq!(A4::new(127, 0, 0, 1), *ip), Some(ip) => assert_eq!(A4::new(127, 0, 0, 1), *ip),
_ => panic!("wrong rdata type returned"), _ => panic!("wrong rdata type returned"),
@ -54,7 +54,7 @@ pub fn test_soa<A: Authority<Lookup = AuthLookup>>(authority: A) {
.expect("SOA record not found in authority") .expect("SOA record not found in authority")
.data() .data()
{ {
Some(RData::SOA(soa)) => { RData::SOA(soa) => {
assert_eq!(Name::from_str("hickory-dns.org.").unwrap(), *soa.mname()); assert_eq!(Name::from_str("hickory-dns.org.").unwrap(), *soa.mname());
assert_eq!( assert_eq!(
Name::from_str("root.hickory-dns.org.").unwrap(), Name::from_str("root.hickory-dns.org.").unwrap(),
@ -79,7 +79,7 @@ pub fn test_ns<A: Authority<Lookup = AuthLookup>>(authority: A) {
.expect("NS record not found in authority") .expect("NS record not found in authority")
.data() .data()
{ {
Some(RData::NS(name)) => assert_eq!(Name::from_str("bbb.example.com.").unwrap(), name.0), RData::NS(name) => assert_eq!(Name::from_str("bbb.example.com.").unwrap(), name.0),
_ => panic!("wrong rdata type returned"), _ => panic!("wrong rdata type returned"),
} }
} }
@ -104,7 +104,7 @@ pub fn test_ns_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("NS record not found in authority") .expect("NS record not found in authority")
.data() .data()
.and_then(RData::as_ns) .as_ns()
.expect("Not an NS record"); .expect("Not an NS record");
assert_eq!(Name::from_str("bbb.example.com.").unwrap(), ns.0); assert_eq!(Name::from_str("bbb.example.com.").unwrap(), ns.0);
@ -114,7 +114,7 @@ pub fn test_ns_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 2), *a); assert_eq!(A4::new(127, 0, 0, 2), *a);
} }
@ -139,7 +139,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("MX record not found in authority") .expect("MX record not found in authority")
.data() .data()
.and_then(RData::as_mx) .as_mx()
.expect("Not an MX record"); .expect("Not an MX record");
assert_eq!( assert_eq!(
@ -154,7 +154,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found") .expect("CNAME record not found")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not an CNAME record"); .expect("Not an CNAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0);
@ -162,7 +162,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
@ -170,7 +170,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("AAAA record not found") .expect("AAAA record not found")
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("Not an AAAA record"); .expect("Not an AAAA record");
assert_eq!(AAAA::new(0, 0, 0, 0, 0, 0, 0, 1), *aaaa); assert_eq!(AAAA::new(0, 0, 0, 0, 0, 0, 0, 1), *aaaa);
} }
@ -198,7 +198,7 @@ pub fn test_mx_to_null<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("MX record not found in authority") .expect("MX record not found in authority")
.data() .data()
.and_then(RData::as_mx) .as_mx()
.expect("Not an MX record"); .expect("Not an MX record");
assert_eq!(Name::from_str(".").unwrap(), *mx.exchange()); assert_eq!(Name::from_str(".").unwrap(), *mx.exchange());
@ -224,7 +224,7 @@ pub fn test_cname<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found in authority") .expect("CNAME record not found in authority")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0);
@ -251,7 +251,7 @@ pub fn test_cname_alias<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found in authority") .expect("CNAME record not found in authority")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not a CNAME record"); .expect("Not a CNAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0);
@ -262,7 +262,7 @@ pub fn test_cname_alias<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
} }
@ -292,7 +292,7 @@ pub fn test_cname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found in authority") .expect("CNAME record not found in authority")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not a CNAME record"); .expect("Not a CNAME record");
assert_eq!(Name::from_str("alias.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("alias.example.com.").unwrap(), cname.0);
@ -304,7 +304,7 @@ pub fn test_cname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found") .expect("CNAME record not found")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not an CNAME record"); .expect("Not an CNAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0);
@ -312,7 +312,7 @@ pub fn test_cname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
} }
@ -339,7 +339,7 @@ pub fn test_aname<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("ANAME record not found in authority") .expect("ANAME record not found in authority")
.data() .data()
.and_then(RData::as_aname) .as_aname()
.expect("Not an ANAME record"); .expect("Not an ANAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), aname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), aname.0);
@ -348,7 +348,7 @@ pub fn test_aname<A: Authority<Lookup = AuthLookup>>(authority: A) {
let a = additionals let a = additionals
.iter() .iter()
.find(|r| r.record_type() == RecordType::A) .find(|r| r.record_type() == RecordType::A)
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_a) .and_then(RData::as_a)
.expect("A not found"); .expect("A not found");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
@ -356,7 +356,7 @@ pub fn test_aname<A: Authority<Lookup = AuthLookup>>(authority: A) {
let aaaa = additionals let aaaa = additionals
.iter() .iter()
.find(|r| r.record_type() == RecordType::AAAA) .find(|r| r.record_type() == RecordType::AAAA)
.and_then(Record::data) .map(Record::data)
.and_then(RData::as_aaaa) .and_then(RData::as_aaaa)
.expect("AAAA not found"); .expect("AAAA not found");
assert_eq!(AAAA::new(0, 0, 0, 0, 0, 0, 0, 1), *aaaa); assert_eq!(AAAA::new(0, 0, 0, 0, 0, 0, 0, 1), *aaaa);
@ -385,7 +385,7 @@ pub fn test_aname_a_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.map(|r| (r.name(), r.data())) .map(|r| (r.name(), r.data()))
.expect("No A answer"); .expect("No A answer");
let a = a.and_then(RData::as_a).expect("Not an A record"); let a = a.as_a().expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
assert_eq!(Name::from_str("example.com.").unwrap(), *name); assert_eq!(Name::from_str("example.com.").unwrap(), *name);
@ -395,7 +395,7 @@ pub fn test_aname_a_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("ANAME record not found in authority") .expect("ANAME record not found in authority")
.data() .data()
.and_then(RData::as_aname) .as_aname()
.expect("Not an ANAME record"); .expect("Not an ANAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), aname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), aname.0);
@ -427,7 +427,7 @@ pub fn test_aname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.map(|r| (r.name(), r.data())) .map(|r| (r.name(), r.data()))
.expect("Not an A record"); .expect("Not an A record");
let a = a.and_then(RData::as_a).expect("Not an A record"); let a = a.as_a().expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
assert_eq!(Name::from_str("aname-chain.example.com.").unwrap(), *name); assert_eq!(Name::from_str("aname-chain.example.com.").unwrap(), *name);
@ -438,7 +438,7 @@ pub fn test_aname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("ANAME record not found in authority") .expect("ANAME record not found in authority")
.data() .data()
.and_then(RData::as_aname) .as_aname()
.expect("Not an ANAME record"); .expect("Not an ANAME record");
assert_eq!(Name::from_str("alias.example.com.").unwrap(), aname.0); assert_eq!(Name::from_str("alias.example.com.").unwrap(), aname.0);
@ -447,7 +447,7 @@ pub fn test_aname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found") .expect("CNAME record not found")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not an CNAME record"); .expect("Not an CNAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0);
@ -455,7 +455,7 @@ pub fn test_aname_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
} }
@ -492,7 +492,7 @@ pub fn test_dots_in_name<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found in authority") .expect("A record not found in authority")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("wrong rdata type returned"), .expect("wrong rdata type returned"),
A4::new(127, 0, 0, 3) A4::new(127, 0, 0, 3)
); );
@ -567,7 +567,7 @@ pub fn test_wildcard<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found in authority") .expect("CNAME record not found in authority")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("wrong rdata type returned") .expect("wrong rdata type returned")
.0, .0,
Name::from_str("www.example.com.").unwrap() Name::from_str("www.example.com.").unwrap()
@ -602,7 +602,7 @@ pub fn test_wildcard<A: Authority<Lookup = AuthLookup>>(authority: A) {
}) })
.expect("CNAME record not found in authority") .expect("CNAME record not found in authority")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("wrong rdata type returned") .expect("wrong rdata type returned")
.0, .0,
Name::from_str("www.example.com.").unwrap() Name::from_str("www.example.com.").unwrap()
@ -635,7 +635,7 @@ pub fn test_wildcard_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found in authority") .expect("CNAME record not found in authority")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("wrong rdata type returned") .expect("wrong rdata type returned")
.0, .0,
Name::from_str("www.example.com.").unwrap() Name::from_str("www.example.com.").unwrap()
@ -646,7 +646,7 @@ pub fn test_wildcard_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
} }
@ -675,7 +675,7 @@ pub fn test_srv<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("SRV record not found in authority") .expect("SRV record not found in authority")
.data() .data()
.and_then(RData::as_srv) .as_srv()
.expect("Not an SRV record"); .expect("Not an SRV record");
assert_eq!(Name::from_str("alias.example.com.").unwrap(), *srv.target()); assert_eq!(Name::from_str("alias.example.com.").unwrap(), *srv.target());
@ -687,7 +687,7 @@ pub fn test_srv<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("CNAME record not found") .expect("CNAME record not found")
.data() .data()
.and_then(RData::as_cname) .as_cname()
.expect("Not an CNAME record"); .expect("Not an CNAME record");
assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0); assert_eq!(Name::from_str("www.example.com.").unwrap(), cname.0);
@ -695,7 +695,7 @@ pub fn test_srv<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("A record not found") .expect("A record not found")
.data() .data()
.and_then(RData::as_a) .as_a()
.expect("Not an A record"); .expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a); assert_eq!(A4::new(127, 0, 0, 1), *a);
@ -703,7 +703,7 @@ pub fn test_srv<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next() .next()
.expect("AAAA record not found") .expect("AAAA record not found")
.data() .data()
.and_then(RData::as_aaaa) .as_aaaa()
.expect("Not an AAAA record"); .expect("Not an AAAA record");
assert_eq!(AAAA::new(0, 0, 0, 0, 0, 0, 0, 1), *aaaa); assert_eq!(AAAA::new(0, 0, 0, 0, 0, 0, 0, 1), *aaaa);
} }

17
crates/server/tests/authority_battery/dnssec.rs
View File

@ -64,12 +64,7 @@ pub fn test_soa<A: Authority<Lookup = AuthLookup>>(authority: A, keys: &[DNSKEY]
assert_eq!(soa_records.len(), 1); assert_eq!(soa_records.len(), 1);
let soa = soa_records let soa = soa_records.first().unwrap().data().as_soa().unwrap();
.first()
.unwrap()
.data()
.and_then(RData::as_soa)
.unwrap();
assert_eq!(Name::from_str("hickory-dns.org.").unwrap(), *soa.mname()); assert_eq!(Name::from_str("hickory-dns.org.").unwrap(), *soa.mname());
assert_eq!( assert_eq!(
@ -102,13 +97,7 @@ pub fn test_ns<A: Authority<Lookup = AuthLookup>>(authority: A, keys: &[DNSKEY])
.partition(|r| r.record_type() == RecordType::NS); .partition(|r| r.record_type() == RecordType::NS);
assert_eq!( assert_eq!(
ns_records ns_records.first().unwrap().data().as_ns().unwrap().0,
.first()
.unwrap()
.data()
.and_then(RData::as_ns)
.unwrap()
.0,
Name::from_str("bbb.example.com.").unwrap() Name::from_str("bbb.example.com.").unwrap()
); );
@ -373,7 +362,7 @@ pub fn verify(records: &[&Record], rrsig_records: &[Record<RRSIG>], keys: &[DNSK
// should be signed with all the keys // should be signed with all the keys
assert!(keys.iter().all(|key| rrsig_records assert!(keys.iter().all(|key| rrsig_records
.iter() .iter()
.filter_map(|rrsig| rrsig.data()) .map(|rrsig| rrsig.data())
.filter(|rrsig| rrsig.algorithm() == key.algorithm()) .filter(|rrsig| rrsig.algorithm() == key.algorithm())
.filter(|rrsig| rrsig.key_tag() == key.calculate_key_tag().unwrap()) .filter(|rrsig| rrsig.key_tag() == key.calculate_key_tag().unwrap())
.filter(|rrsig| rrsig.type_covered() == record_type) .filter(|rrsig| rrsig.type_covered() == record_type)

49
crates/server/tests/authority_battery/dynamic_update.rs
View File

@ -71,7 +71,7 @@ pub fn test_create<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys: &[
.expect("A record not found in authority") .expect("A record not found in authority")
.data() .data()
{ {
Some(RData::A(ip)) => assert_eq!(A4::new(127, 0, 0, 10), *ip), RData::A(ip) => assert_eq!(A4::new(127, 0, 0, 10), *ip),
_ => panic!("wrong rdata type returned"), _ => panic!("wrong rdata type returned"),
} }
@ -93,12 +93,10 @@ pub fn test_create_multi<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
.append_name(&name) .append_name(&name)
.unwrap(); .unwrap();
// create a record // create a record
let mut record = Record::with(name.clone(), RecordType::A, 8); let record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let record = record;
let mut record2 = record.clone(); let mut record2 = record.clone();
record2.set_data(Some(RData::A(A4::new(100, 10, 100, 11)))); record2.set_data(RData::A(A4::new(100, 10, 100, 11)));
let record2 = record2; let record2 = record2;
let mut rrset = RecordSet::from(record.clone()); let mut rrset = RecordSet::from(record.clone());
@ -140,8 +138,7 @@ pub fn test_append<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys: &[
.unwrap(); .unwrap();
// append a record // append a record
let mut record = Record::with(name.clone(), RecordType::A, 8); let record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let mut message = update_message::append( let mut message = update_message::append(
@ -180,7 +177,7 @@ pub fn test_append<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys: &[
// will fail if already set and not the same value. // will fail if already set and not the same value.
let mut record2 = record.clone(); let mut record2 = record.clone();
record2.set_data(Some(RData::A(A4::new(101, 11, 101, 11)))); record2.set_data(RData::A(A4::new(101, 11, 101, 11)));
let message = update_message::append( let message = update_message::append(
record2.clone().into(), record2.clone().into(),
@ -240,8 +237,7 @@ pub fn test_append_multi<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
.unwrap(); .unwrap();
// append a record // append a record
let mut record = Record::with(name.clone(), RecordType::A, 8); let record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
// next append to a non-existent RRset // next append to a non-existent RRset
let message = update_message::append( let message = update_message::append(
@ -254,9 +250,9 @@ pub fn test_append_multi<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
// will fail if already set and not the same value. // will fail if already set and not the same value.
let mut record2 = record.clone(); let mut record2 = record.clone();
record2.set_data(Some(RData::A(A4::new(101, 11, 101, 11)))); record2.set_data(RData::A(A4::new(101, 11, 101, 11)));
let mut record3 = record.clone(); let mut record3 = record.clone();
record3.set_data(Some(RData::A(A4::new(101, 11, 101, 12)))); record3.set_data(RData::A(A4::new(101, 11, 101, 12)));
// build the append set // build the append set
let mut rrset = RecordSet::from(record2.clone()); let mut rrset = RecordSet::from(record2.clone());
@ -326,8 +322,7 @@ pub fn test_compare_and_swap<A: Authority<Lookup = AuthLookup>>(
.unwrap(); .unwrap();
// create a record // create a record
let mut record = Record::with(name.clone(), RecordType::A, 8); let mut record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let record = record; let record = record;
let message = update_message::create( let message = update_message::create(
@ -339,7 +334,7 @@ pub fn test_compare_and_swap<A: Authority<Lookup = AuthLookup>>(
let current = record; let current = record;
let mut new = current.clone(); let mut new = current.clone();
new.set_data(Some(RData::A(A4::new(101, 11, 101, 11)))); new.set_data(RData::A(A4::new(101, 11, 101, 11)));
let new = new; let new = new;
let message = update_message::compare_and_swap( let message = update_message::compare_and_swap(
@ -366,7 +361,7 @@ pub fn test_compare_and_swap<A: Authority<Lookup = AuthLookup>>(
// check the it fails if tried again. // check the it fails if tried again.
let mut not = new.clone(); let mut not = new.clone();
not.set_data(Some(RData::A(A4::new(102, 12, 102, 12)))); not.set_data(RData::A(A4::new(102, 12, 102, 12)));
let not = not; let not = not;
let message = update_message::compare_and_swap( let message = update_message::compare_and_swap(
@ -457,7 +452,7 @@ pub fn test_compare_and_swap_multi<A: Authority<Lookup = AuthLookup>>(
// check the it fails if tried again. // check the it fails if tried again.
let mut not = new1.clone(); let mut not = new1.clone();
not.set_data(Some(RData::A(A4::new(102, 12, 102, 12)))); not.set_data(RData::A(A4::new(102, 12, 102, 12)));
let not = not; let not = not;
let message = update_message::compare_and_swap( let message = update_message::compare_and_swap(
@ -499,8 +494,7 @@ pub fn test_delete_by_rdata<A: Authority<Lookup = AuthLookup>>(
.unwrap(); .unwrap();
// append a record // append a record
let mut record1 = Record::with(name.clone(), RecordType::A, 8); let record1 = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record1.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let mut message = update_message::delete_by_rdata( let mut message = update_message::delete_by_rdata(
@ -519,7 +513,7 @@ pub fn test_delete_by_rdata<A: Authority<Lookup = AuthLookup>>(
assert!(update_authority(message, key, &mut authority).expect("delete_by_rdata failed")); assert!(update_authority(message, key, &mut authority).expect("delete_by_rdata failed"));
let mut record2 = record1.clone(); let mut record2 = record1.clone();
record2.set_data(Some(RData::A(A4::new(101, 11, 101, 11)))); record2.set_data(RData::A(A4::new(101, 11, 101, 11)));
let message = update_message::append( let message = update_message::append(
record2.clone().into(), record2.clone().into(),
Name::from_str("example.com.").unwrap(), Name::from_str("example.com.").unwrap(),
@ -595,8 +589,8 @@ pub fn test_delete_by_rdata_multi<A: Authority<Lookup = AuthLookup>>(
// append a record // append a record
let mut rrset = RecordSet::with_ttl(name.clone(), RecordType::A, 8); let mut rrset = RecordSet::with_ttl(name.clone(), RecordType::A, 8);
let record1 = rrset.new_record(record1.data().unwrap()).clone(); let record1 = rrset.new_record(record1.data()).clone();
let record3 = rrset.new_record(record3.data().unwrap()).clone(); let record3 = rrset.new_record(record3.data()).clone();
let rrset = rrset; let rrset = rrset;
let message = update_message::append( let message = update_message::append(
@ -642,8 +636,7 @@ pub fn test_delete_rrset<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
.unwrap(); .unwrap();
// append a record // append a record
let mut record = Record::with(name.clone(), RecordType::A, 8); let mut record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let message = update_message::delete_rrset( let message = update_message::delete_rrset(
@ -662,7 +655,7 @@ pub fn test_delete_rrset<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
assert!(update_authority(message, key, &mut authority).expect("create failed")); assert!(update_authority(message, key, &mut authority).expect("create failed"));
let mut record = record.clone(); let mut record = record.clone();
record.set_data(Some(RData::A(A4::new(101, 11, 101, 11)))); record.set_data(RData::A(A4::new(101, 11, 101, 11)));
let message = update_message::append( let message = update_message::append(
record.clone().into(), record.clone().into(),
Name::from_str("example.com.").unwrap(), Name::from_str("example.com.").unwrap(),
@ -705,8 +698,7 @@ pub fn test_delete_all<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys
.unwrap(); .unwrap();
// append a record // append a record
let mut record = Record::with(name.clone(), RecordType::A, 8); let mut record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let message = update_message::delete_all( let message = update_message::delete_all(
@ -726,8 +718,7 @@ pub fn test_delete_all<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys
assert!(update_authority(message, key, &mut authority).expect("create failed")); assert!(update_authority(message, key, &mut authority).expect("create failed"));
let mut record = record.clone(); let mut record = record.clone();
record.set_record_type(RecordType::AAAA); record.set_data(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8)));
record.set_data(Some(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8))));
let message = update_message::create( let message = update_message::create(
record.clone().into(), record.clone().into(),
Name::from_str("example.com.").unwrap(), Name::from_str("example.com.").unwrap(),

7
crates/server/tests/forwarder.rs
View File

@ -6,7 +6,7 @@ use std::str::FromStr;
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use hickory_proto::rr::{Name, RData, RecordType}; use hickory_proto::rr::{Name, RecordType};
use hickory_resolver::name_server::TokioConnectionProvider; use hickory_resolver::name_server::TokioConnectionProvider;
use hickory_server::{ use hickory_server::{
authority::{Authority, LookupObject}, authority::{Authority, LookupObject},
@ -29,9 +29,6 @@ fn test_lookup() {
.unwrap(); .unwrap();
let address = lookup.iter().next().expect("no addresses returned!"); let address = lookup.iter().next().expect("no addresses returned!");
let address = address let address = address.data().as_a().expect("not an A record");
.data()
.and_then(RData::as_a)
.expect("not an A record");
assert_eq!(*address, Ipv4Addr::new(93, 184, 215, 14).into()); assert_eq!(*address, Ipv4Addr::new(93, 184, 215, 14).into());
} }

24
crates/server/tests/in_memory.rs
View File

@ -76,9 +76,7 @@ fn test_cname_loop() {
assert_eq!(record.name(), &Name::from_str("foo.example.com.").unwrap()); assert_eq!(record.name(), &Name::from_str("foo.example.com.").unwrap());
assert_eq!( assert_eq!(
record.data(), record.data(),
Some(&RData::CNAME(CNAME( &RData::CNAME(CNAME(Name::from_str("foo.example.com.").unwrap()))
Name::from_str("foo.example.com.").unwrap()
)))
); );
assert!( assert!(
@ -100,9 +98,7 @@ fn test_cname_loop() {
assert_eq!(record.name(), &Name::from_str("bar.example.com.").unwrap()); assert_eq!(record.name(), &Name::from_str("bar.example.com.").unwrap());
assert_eq!( assert_eq!(
record.data(), record.data(),
Some(&RData::CNAME(CNAME( &RData::CNAME(CNAME(Name::from_str("foo.example.com.").unwrap()))
Name::from_str("foo.example.com.").unwrap()
)))
); );
let additionals = lookup let additionals = lookup
@ -114,9 +110,7 @@ fn test_cname_loop() {
assert_eq!(record.name(), &Name::from_str("foo.example.com.").unwrap()); assert_eq!(record.name(), &Name::from_str("foo.example.com.").unwrap());
assert_eq!( assert_eq!(
record.data(), record.data(),
Some(&RData::CNAME(CNAME( &RData::CNAME(CNAME(Name::from_str("foo.example.com.").unwrap()))
Name::from_str("foo.example.com.").unwrap()
)))
); );
let mut lookup = runtime let mut lookup = runtime
@ -133,9 +127,7 @@ fn test_cname_loop() {
assert_eq!(record.name(), &Name::from_str("baz.example.com.").unwrap()); assert_eq!(record.name(), &Name::from_str("baz.example.com.").unwrap());
assert_eq!( assert_eq!(
record.data(), record.data(),
Some(&RData::CNAME(CNAME( &RData::CNAME(CNAME(Name::from_str("boz.example.com.").unwrap()))
Name::from_str("boz.example.com.").unwrap()
)))
); );
let additionals = lookup let additionals = lookup
@ -147,16 +139,12 @@ fn test_cname_loop() {
assert_eq!(record.name(), &Name::from_str("boz.example.com.").unwrap()); assert_eq!(record.name(), &Name::from_str("boz.example.com.").unwrap());
assert_eq!( assert_eq!(
record.data(), record.data(),
Some(&RData::CNAME(CNAME( &RData::CNAME(CNAME(Name::from_str("biz.example.com.").unwrap()))
Name::from_str("biz.example.com.").unwrap()
)))
); );
let record = additionals[1]; let record = additionals[1];
assert_eq!(record.name(), &Name::from_str("biz.example.com.").unwrap()); assert_eq!(record.name(), &Name::from_str("biz.example.com.").unwrap());
assert_eq!( assert_eq!(
record.data(), record.data(),
Some(&RData::CNAME(CNAME( &RData::CNAME(CNAME(Name::from_str("baz.example.com.").unwrap()))
Name::from_str("baz.example.com.").unwrap()
)))
); );
} }

15
crates/server/tests/sqlite_tests.rs
View File

@ -32,10 +32,7 @@ fn test_init_journal() {
fn create_test_journal() -> (Record, Journal) { fn create_test_journal() -> (Record, Journal) {
let www = Name::from_str("www.example.com").unwrap(); let www = Name::from_str("www.example.com").unwrap();
let mut record = Record::new(); let mut record = Record::from_rdata(www, 0, RData::A(A::from_str("127.0.0.1").unwrap()));
record.set_name(www);
record.set_record_type(RecordType::A);
record.set_data(Some(RData::A(A::from_str("127.0.0.1").unwrap())));
// test that this message can be inserted // test that this message can be inserted
let conn = Connection::open_in_memory().expect("could not create in memory DB"); let conn = Connection::open_in_memory().expect("could not create in memory DB");
@ -46,7 +43,7 @@ fn create_test_journal() -> (Record, Journal) {
journal.insert_record(0, &record).unwrap(); journal.insert_record(0, &record).unwrap();
// insert another... // insert another...
record.set_data(Some(RData::A(A::from_str("127.0.1.1").unwrap()))); record.set_data(RData::A(A::from_str("127.0.1.1").unwrap()));
journal.insert_record(0, &record).unwrap(); journal.insert_record(0, &record).unwrap();
(record, journal) (record, journal)
@ -61,7 +58,7 @@ fn test_insert_and_select_record() {
.select_record(0) .select_record(0)
.expect("persistence error") .expect("persistence error")
.expect("none"); .expect("none");
record.set_data(Some(RData::A(A::from_str("127.0.0.1").unwrap()))); record.set_data(RData::A(A::from_str("127.0.0.1").unwrap()));
assert_eq!(journal_record, record); assert_eq!(journal_record, record);
// test another // test another
@ -69,7 +66,7 @@ fn test_insert_and_select_record() {
.select_record(row_id + 1) .select_record(row_id + 1)
.expect("persistence error") .expect("persistence error")
.expect("none"); .expect("none");
record.set_data(Some(RData::A(A::from_str("127.0.1.1").unwrap()))); record.set_data(RData::A(A::from_str("127.0.1.1").unwrap()));
assert_eq!(journal_record, record); assert_eq!(journal_record, record);
// check that we get nothing for id over row_id // check that we get nothing for id over row_id
@ -86,11 +83,11 @@ fn test_iterator() {
let mut iter = journal.iter(); let mut iter = journal.iter();
assert_eq!( assert_eq!(
record.set_data(Some(RData::A(A::from_str("127.0.0.1").unwrap()))), record.set_data(RData::A(A::from_str("127.0.0.1").unwrap())),
&iter.next().unwrap() &iter.next().unwrap()
); );
assert_eq!( assert_eq!(
record.set_data(Some(RData::A(A::from_str("127.0.1.1").unwrap()))), record.set_data(RData::A(A::from_str("127.0.1.1").unwrap())),
&iter.next().unwrap() &iter.next().unwrap()
); );
assert_eq!(None, iter.next()); assert_eq!(None, iter.next());

26
crates/server/tests/txt_tests.rs
View File

@ -77,7 +77,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
assert_eq!(&Name::from_str("isi.edu").unwrap(), soa_record.name()); // i.e. the origin or domain assert_eq!(&Name::from_str("isi.edu").unwrap(), soa_record.name()); // i.e. the origin or domain
assert_eq!(3_600_000, soa_record.ttl()); assert_eq!(3_600_000, soa_record.ttl());
assert_eq!(DNSClass::IN, soa_record.dns_class()); assert_eq!(DNSClass::IN, soa_record.dns_class());
if let Some(RData::SOA(ref soa)) = soa_record.data() { if let RData::SOA(ref soa) = soa_record.data() {
// this should all be lowercased // this should all be lowercased
assert_eq!(&Name::from_str("venera.isi.edu").unwrap(), soa.mname()); assert_eq!(&Name::from_str("venera.isi.edu").unwrap(), soa.mname());
assert_eq!( assert_eq!(
@ -105,7 +105,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.unwrap(); .unwrap();
assert_eq!(&Name::from_str("tech.").unwrap(), lowercase_record.name()); assert_eq!(&Name::from_str("tech.").unwrap(), lowercase_record.name());
assert_eq!(DNSClass::IN, lowercase_record.dns_class()); assert_eq!(DNSClass::IN, lowercase_record.dns_class());
if let Some(RData::SOA(ref lower_soa)) = lowercase_record.data() { if let RData::SOA(ref lower_soa) = lowercase_record.data() {
assert_eq!( assert_eq!(
&Name::from_str("ns0.centralnic.net").unwrap(), &Name::from_str("ns0.centralnic.net").unwrap(),
lower_soa.mname() lower_soa.mname()
@ -149,7 +149,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
assert_eq!(60, record.ttl()); // TODO: should this be minimum or expire? assert_eq!(60, record.ttl()); // TODO: should this be minimum or expire?
assert_eq!(DNSClass::IN, record.dns_class()); assert_eq!(DNSClass::IN, record.dns_class());
assert_eq!(RecordType::NS, record.record_type()); assert_eq!(RecordType::NS, record.record_type());
if let Some(RData::NS(nsdname)) = record.data() { if let RData::NS(nsdname) = record.data() {
assert_eq!(name, nsdname.0); assert_eq!(name, nsdname.0);
} else { } else {
panic!("Not an NS record!!!") // valid panic, test code panic!("Not an NS record!!!") // valid panic, test code
@ -180,7 +180,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
assert_eq!(60, record.ttl()); // TODO: should this be minimum or expire? assert_eq!(60, record.ttl()); // TODO: should this be minimum or expire?
assert_eq!(DNSClass::IN, record.dns_class()); assert_eq!(DNSClass::IN, record.dns_class());
assert_eq!(RecordType::MX, record.record_type()); assert_eq!(RecordType::MX, record.record_type());
if let Some(RData::MX(ref rdata)) = record.data() { if let RData::MX(ref rdata) = record.data() {
assert_eq!(num, rdata.preference()); assert_eq!(num, rdata.preference());
assert_eq!(name, rdata.exchange()); assert_eq!(name, rdata.exchange());
} else { } else {
@ -203,7 +203,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
assert_eq!(60, a_record.ttl()); // TODO: should this be minimum or expire? assert_eq!(60, a_record.ttl()); // TODO: should this be minimum or expire?
assert_eq!(DNSClass::IN, a_record.dns_class()); assert_eq!(DNSClass::IN, a_record.dns_class());
assert_eq!(RecordType::A, a_record.record_type()); assert_eq!(RecordType::A, a_record.record_type());
if let Some(RData::A(ref address)) = a_record.data() { if let RData::A(ref address) = a_record.data() {
assert_eq!(&A::new(26u8, 3u8, 0u8, 103u8), address); assert_eq!(&A::new(26u8, 3u8, 0u8, 103u8), address);
} else { } else {
panic!("Not an A record!!!") // valid panic, test code panic!("Not an A record!!!") // valid panic, test code
@ -221,7 +221,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.cloned() .cloned()
.unwrap(); .unwrap();
assert_eq!(&Name::from_str("aaaa.isi.edu").unwrap(), aaaa_record.name()); assert_eq!(&Name::from_str("aaaa.isi.edu").unwrap(), aaaa_record.name());
if let Some(RData::AAAA(ref address)) = aaaa_record.data() { if let RData::AAAA(ref address) = aaaa_record.data() {
assert_eq!(&AAAA::from_str("4321:0:1:2:3:4:567:89ab").unwrap(), address); assert_eq!(&AAAA::from_str("4321:0:1:2:3:4:567:89ab").unwrap(), address);
} else { } else {
panic!("Not a AAAA record!!!") // valid panic, test code panic!("Not a AAAA record!!!") // valid panic, test code
@ -243,7 +243,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
short_record.name() short_record.name()
); );
assert_eq!(70, short_record.ttl()); assert_eq!(70, short_record.ttl());
if let Some(RData::A(ref address)) = short_record.data() { if let RData::A(ref address) = short_record.data() {
assert_eq!(&A::new(26u8, 3u8, 0u8, 104u8), address); assert_eq!(&A::new(26u8, 3u8, 0u8, 104u8), address);
} else { } else {
panic!("Not an A record!!!") // valid panic, test code panic!("Not an A record!!!") // valid panic, test code
@ -286,7 +286,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
let compare = txt_records.iter().zip(compare); let compare = txt_records.iter().zip(compare);
for (record, ref vector) in compare { for (record, ref vector) in compare {
if let Some(RData::TXT(ref rdata)) = record.data() { if let RData::TXT(ref rdata) = record.data() {
assert_eq!(vector as &[Box<[u8]>], rdata.txt_data()); assert_eq!(vector as &[Box<[u8]>], rdata.txt_data());
} else { } else {
panic!("Not a TXT record!!!") // valid panic, test code panic!("Not a TXT record!!!") // valid panic, test code
@ -304,7 +304,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next() .next()
.cloned() .cloned()
.unwrap(); .unwrap();
if let Some(RData::PTR(ref ptrdname)) = ptr_record.data() { if let RData::PTR(ref ptrdname) = ptr_record.data() {
assert_eq!(Name::from_str("a.isi.edu").unwrap(), ptrdname.0); assert_eq!(Name::from_str("a.isi.edu").unwrap(), ptrdname.0);
} else { } else {
panic!("Not a PTR record!!!") // valid panic, test code panic!("Not a PTR record!!!") // valid panic, test code
@ -321,7 +321,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next() .next()
.cloned() .cloned()
.unwrap(); .unwrap();
if let Some(RData::SRV(ref rdata)) = srv_record.data() { if let RData::SRV(ref rdata) = srv_record.data() {
assert_eq!(rdata.priority(), 1); assert_eq!(rdata.priority(), 1);
assert_eq!(rdata.weight(), 2); assert_eq!(rdata.weight(), 2);
assert_eq!(rdata.port(), 3); assert_eq!(rdata.port(), 3);
@ -345,7 +345,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
&Name::from_str("rust-❤️-🦀.isi.edu").unwrap(), &Name::from_str("rust-❤️-🦀.isi.edu").unwrap(),
idna_record.name() idna_record.name()
); );
if let Some(RData::A(ref address)) = idna_record.data() { if let RData::A(ref address) = idna_record.data() {
assert_eq!(&A::new(192u8, 0u8, 2u8, 1u8), address); assert_eq!(&A::new(192u8, 0u8, 2u8, 1u8), address);
} else { } else {
panic!("Not an A record!!!") // valid panic, test code panic!("Not an A record!!!") // valid panic, test code
@ -362,7 +362,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next() .next()
.cloned() .cloned()
.expect("nocerts not found"); .expect("nocerts not found");
if let Some(RData::CAA(ref rdata)) = caa_record.data() { if let RData::CAA(ref rdata) = caa_record.data() {
assert!(!rdata.issuer_critical()); assert!(!rdata.issuer_critical());
assert!(rdata.tag().is_issue()); assert!(rdata.tag().is_issue());
assert!(rdata.value().is_issuer()); assert!(rdata.value().is_issuer());
@ -385,7 +385,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next() .next()
.cloned() .cloned()
.expect("tlsa record not found"); .expect("tlsa record not found");
if let Some(RData::TLSA(ref rdata)) = tlsa_record.data() { if let RData::TLSA(ref rdata) = tlsa_record.data() {
assert_eq!(rdata.cert_usage(), CertUsage::CA); assert_eq!(rdata.cert_usage(), CertUsage::CA);
assert_eq!(rdata.selector(), Selector::Full); assert_eq!(rdata.selector(), Selector::Full);
assert_eq!(rdata.matching(), Matching::Sha256); assert_eq!(rdata.matching(), Matching::Sha256);

2
fuzz/fuzz_targets/message.rs
View File

@ -101,7 +101,7 @@ fn record_equal(record1: &Record, record2: &Record) -> bool {
// custom rules to match.. // custom rules to match..
match (record1.data(), record2.data()) { match (record1.data(), record2.data()) {
(None, Some(RData::OPT(opt))) | (Some(RData::OPT(opt)), None) => { (RData::Update0(_), RData::OPT(opt)) | (RData::OPT(opt), RData::Update0(_)) => {
if opt.as_ref().is_empty() { if opt.as_ref().is_empty() {
return true; return true;
} }

9
tests/compatibility-tests/tests/sig0_tests.rs
View File

@ -51,7 +51,7 @@ fn test_get() {
assert_eq!(result.answers()[0].record_type(), RecordType::A); assert_eq!(result.answers()[0].record_type(), RecordType::A);
let rdata = result.answers()[0].data(); let rdata = result.answers()[0].data();
if let Some(RData::A(address)) = rdata { if let RData::A(address) = rdata {
assert_eq!(address, &A::new(127, 0, 0, 1)); assert_eq!(address, &A::new(127, 0, 0, 1));
} else { } else {
panic!("RData::A wasn't here"); panic!("RData::A wasn't here");
@ -104,12 +104,11 @@ fn test_create() {
let origin = Name::from_str("example.com.").unwrap(); let origin = Name::from_str("example.com.").unwrap();
// create a record // create a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com.").unwrap(), Name::from_str("new.example.com.").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let result = client let result = client
.create(record.clone(), origin.clone()) .create(record.clone(), origin.clone())
@ -130,7 +129,7 @@ fn test_create() {
assert_eq!(result.response_code(), ResponseCode::YXRRSet); assert_eq!(result.response_code(), ResponseCode::YXRRSet);
// will fail if already set and not the same value. // will fail if already set and not the same value.
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client.create(record, origin).expect("create failed"); let result = client.create(record, origin).expect("create failed");
assert_eq!(result.response_code(), ResponseCode::YXRRSet); assert_eq!(result.response_code(), ResponseCode::YXRRSet);

7
tests/compatibility-tests/tests/tsig_tests.rs
View File

@ -60,12 +60,11 @@ fn test_create() {
let origin = Name::from_str("example.net.").unwrap(); let origin = Name::from_str("example.net.").unwrap();
// create a record // create a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.net.").unwrap(), Name::from_str("new.example.net.").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let result = client let result = client
.create(record.clone(), origin.clone()) .create(record.clone(), origin.clone())
@ -86,7 +85,7 @@ fn test_create() {
assert_eq!(result.response_code(), ResponseCode::YXRRSet); assert_eq!(result.response_code(), ResponseCode::YXRRSet);
// will fail if already set and not the same value. // will fail if already set and not the same value.
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client.create(record, origin).expect("create failed"); let result = client.create(record, origin).expect("create failed");
assert_eq!(result.response_code(), ResponseCode::YXRRSet); assert_eq!(result.response_code(), ResponseCode::YXRRSet);

9
tests/compatibility-tests/tests/zone_transfer.rs
View File

@ -26,7 +26,7 @@ use hickory_compatibility::named_process;
macro_rules! assert_serial { macro_rules! assert_serial {
( $record:expr, $serial:expr ) => {{ ( $record:expr, $serial:expr ) => {{
let rdata = $record.data(); let rdata = $record.data();
if let Some(RData::SOA(soa)) = rdata { if let RData::SOA(soa) = rdata {
assert_eq!(soa.serial(), $serial); assert_eq!(soa.serial(), $serial);
} else { } else {
assert!(false, "record was not a SOA"); assert!(false, "record was not a SOA");
@ -54,7 +54,7 @@ fn test_zone_transfer() {
2000 + 3 2000 + 3
); );
let soa = if let Some(RData::SOA(soa)) = result[0].answers()[0].data() { let soa = if let RData::SOA(soa) = result[0].answers()[0].data() {
soa soa
} else { } else {
panic!("First answer was not an SOA record") panic!("First answer was not an SOA record")
@ -72,12 +72,11 @@ fn test_zone_transfer() {
RecordType::SOA RecordType::SOA
); );
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.net.").unwrap(), Name::from_str("new.example.net.").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
client.create(record, name.clone()).expect("create failed"); client.create(record, name.clone()).expect("create failed");

158
tests/integration-tests/src/example_authority.rs
View File

@ -16,12 +16,10 @@ pub fn create_example() -> InMemoryAuthority {
// example.com. 3600 IN SOA sns.dns.icann.org. noc.dns.icann.org. 2015082403 7200 3600 1209600 3600 // example.com. 3600 IN SOA sns.dns.icann.org. noc.dns.icann.org. 2015082403 7200 3600 1209600 3600
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403, 2015082403,
@ -29,37 +27,31 @@ pub fn create_example() -> InMemoryAuthority {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"a.iana-servers.net.", .clone(),
None,
)
.unwrap()))))
.clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"b.iana-servers.net.", .clone(),
None,
)
.unwrap()))))
.clone(),
0, 0,
); );
@ -67,43 +59,37 @@ pub fn create_example() -> InMemoryAuthority {
//records.upsert(origin.clone(), Record::new().name(origin.clone()).ttl(60).rr_type(RecordType::TXT).dns_class(DNSClass::IN).rdata(RData::TXT{ txt_data: vec!["v=spf1 -all".to_string()] }).clone()); //records.upsert(origin.clone(), Record::new().name(origin.clone()).ttl(60).rr_type(RecordType::TXT).dns_class(DNSClass::IN).rdata(RData::TXT{ txt_data: vec!["v=spf1 -all".to_string()] }).clone());
// example.com. 60 IN TXT "$Id: example.com 4415 2015-08-24 20:12:23Z davids $" // example.com. 60 IN TXT "$Id: example.com 4415 2015-08-24 20:12:23Z davids $"
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(60) 60,
.set_record_type(RecordType::TXT) RData::TXT(TXT::new(vec!["$Id: example.com 4415 2015-08-24 \
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::TXT(TXT::new(vec![
"$Id: example.com 4415 2015-08-24 \
20:12:23Z davids $" 20:12:23Z davids $"
.to_string(), .to_string()])),
])))) )
.clone(), .set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
// example.com. 86400 IN A 93.184.215.14 // example.com. 86400 IN A 93.184.215.14
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(origin.clone(), 86400, RData::A(A::new(93, 184, 215, 14)))
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(93, 184, 215, 14))))
.clone(), .clone(),
0, 0,
); );
// example.com. 86400 IN AAAA 2606:2800:21f:cb07:6820:80da:af6b:8b2c // example.com. 86400 IN AAAA 2606:2800:21f:cb07:6820:80da:af6b:8b2c
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin) origin,
.set_ttl(86400) 86400,
.set_record_type(RecordType::AAAA) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
@ -126,65 +112,59 @@ pub fn create_example() -> InMemoryAuthority {
// www.example.com. 86400 IN TXT "v=spf1 -all" // www.example.com. 86400 IN TXT "v=spf1 -all"
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(www_name.clone()) www_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::TXT) RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()])),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()])))) .set_dns_class(DNSClass::IN)
.clone(), .clone(),
0, 0,
); );
// www.example.com. 86400 IN A 93.184.215.14 // www.example.com. 86400 IN A 93.184.215.14
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(93, 184, 215, 14)))
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(93, 184, 215, 14))))
.clone(), .clone(),
0, 0,
); );
// www.example.com. 86400 IN AAAA 2606:2800:21f:cb07:6820:80da:af6b:8b2c // www.example.com. 86400 IN AAAA 2606:2800:21f:cb07:6820:80da:af6b:8b2c
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(www_name.clone()) www_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::AAAA) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
// alias 86400 IN www // alias 86400 IN www
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(Name::from_str("alias.example.com.").unwrap()) Name::from_str("alias.example.com.").unwrap(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::CNAME) RData::CNAME(CNAME(www_name)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::CNAME(CNAME(www_name)))) .set_dns_class(DNSClass::IN)
.clone(), .clone(),
0, 0,
); );
// alias2 86400 IN www, multiple cname chains // alias2 86400 IN www, multiple cname chains
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(Name::from_str("alias2.example.com.").unwrap()) Name::from_str("alias2.example.com.").unwrap(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::CNAME) RData::CNAME(CNAME(Name::from_str("alias.example.com.").unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::CNAME(CNAME( .set_dns_class(DNSClass::IN)
Name::from_str("alias.example.com.").unwrap(), .clone(),
))))
.clone(),
0, 0,
); );

254
tests/integration-tests/tests/catalog_tests.rs
View File

@ -21,12 +21,10 @@ pub fn create_test() -> InMemoryAuthority {
let mut records = InMemoryAuthority::empty(origin.clone(), ZoneType::Primary, false); let mut records = InMemoryAuthority::empty(origin.clone(), ZoneType::Primary, false);
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403, 2015082403,
@ -34,84 +32,70 @@ pub fn create_test() -> InMemoryAuthority {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"a.iana-servers.net.", .clone(),
None,
)
.unwrap()))))
.clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin.clone()) origin.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"b.iana-servers.net.", .clone(),
None,
)
.unwrap()))))
.clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(origin.clone(), 86400, RData::A(A::new(94, 184, 216, 34)))
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(), .clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(origin) origin,
.set_ttl(86400) 86400,
.set_record_type(RecordType::AAAA) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
let www_name: Name = Name::parse("www.test.com.", None).unwrap(); let www_name: Name = Name::parse("www.test.com.", None).unwrap();
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(94, 184, 216, 34)))
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(), .clone(),
0, 0,
); );
records.upsert_mut( records.upsert_mut(
Record::new() Record::from_rdata(
.set_name(www_name) www_name,
.set_ttl(86400) 86400,
.set_record_type(RecordType::AAAA) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
0, 0,
); );
@ -156,7 +140,7 @@ async fn test_catalog_lookup() {
assert!(!answers.is_empty()); assert!(!answers.is_empty());
assert_eq!(answers.first().unwrap().record_type(), RecordType::A); assert_eq!(answers.first().unwrap().record_type(), RecordType::A);
assert_eq!( assert_eq!(
answers.first().unwrap().data().unwrap(), answers.first().unwrap().data(),
&RData::A(A::new(93, 184, 215, 14)) &RData::A(A::new(93, 184, 215, 14))
); );
@ -190,7 +174,7 @@ async fn test_catalog_lookup() {
assert!(!answers.is_empty()); assert!(!answers.is_empty());
assert_eq!(answers.first().unwrap().record_type(), RecordType::A); assert_eq!(answers.first().unwrap().record_type(), RecordType::A);
assert_eq!( assert_eq!(
answers.first().unwrap().data().unwrap(), answers.first().unwrap().data(),
&RData::A(A::new(94, 184, 216, 34)) &RData::A(A::new(94, 184, 216, 34))
); );
} }
@ -234,7 +218,7 @@ async fn test_catalog_lookup_soa() {
assert!(!answers.is_empty()); assert!(!answers.is_empty());
assert_eq!(answers.first().unwrap().record_type(), RecordType::SOA); assert_eq!(answers.first().unwrap().record_type(), RecordType::SOA);
assert_eq!( assert_eq!(
answers.first().unwrap().data().unwrap(), answers.first().unwrap().data(),
&RData::SOA(SOA::new( &RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
@ -253,12 +237,12 @@ async fn test_catalog_lookup_soa() {
assert_eq!(ns.len(), 2); assert_eq!(ns.len(), 2);
assert_eq!(ns.first().unwrap().record_type(), RecordType::NS); assert_eq!(ns.first().unwrap().record_type(), RecordType::NS);
assert_eq!( assert_eq!(
ns.first().unwrap().data().unwrap(), ns.first().unwrap().data(),
&RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())) &RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap()))
); );
assert_eq!(ns.last().unwrap().record_type(), RecordType::NS); assert_eq!(ns.last().unwrap().record_type(), RecordType::NS);
assert_eq!( assert_eq!(
ns.last().unwrap().data().unwrap(), ns.last().unwrap().data(),
&RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())) &RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap()))
); );
} }
@ -299,7 +283,7 @@ async fn test_catalog_nx_soa() {
assert_eq!(ns.len(), 1); assert_eq!(ns.len(), 1);
assert_eq!(ns.first().unwrap().record_type(), RecordType::SOA); assert_eq!(ns.first().unwrap().record_type(), RecordType::SOA);
assert_eq!( assert_eq!(
ns.first().unwrap().data().unwrap(), ns.first().unwrap().data(),
&RData::SOA(SOA::new( &RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
@ -355,12 +339,10 @@ async fn test_axfr() {
test.set_allow_axfr(true); test.set_allow_axfr(true);
let origin = test.origin().clone(); let origin = test.origin().clone();
let soa = Record::new() let soa = Record::from_rdata(
.set_name(origin.clone().into()) origin.clone().into(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403, 2015082403,
@ -368,8 +350,10 @@ async fn test_axfr() {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(); )
.set_dns_class(DNSClass::IN)
.clone();
let mut catalog: Catalog = Catalog::new(); let mut catalog: Catalog = Catalog::new();
catalog.upsert(origin.clone(), Box::new(Arc::new(test))); catalog.upsert(origin.clone(), Box::new(Arc::new(test)));
@ -401,12 +385,10 @@ async fn test_axfr() {
let www_name: Name = Name::parse("www.test.com.", None).unwrap(); let www_name: Name = Name::parse("www.test.com.", None).unwrap();
let mut expected_set = vec![ let mut expected_set = vec![
Record::new() Record::from_rdata(
.set_name(origin.clone().into()) origin.clone().into(),
.set_ttl(3600) 3600,
.set_record_type(RecordType::SOA) RData::SOA(SOA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403, 2015082403,
@ -414,68 +396,56 @@ async fn test_axfr() {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(), )
Record::new() .set_dns_class(DNSClass::IN)
.set_name(origin.clone().into()) .clone(),
.set_ttl(86400) Record::from_rdata(
.set_record_type(RecordType::NS) origin.clone().into(),
.set_dns_class(DNSClass::IN) 86400,
.set_data(Some(RData::NS(NS(Name::parse( RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
"a.iana-servers.net.", )
None, .set_dns_class(DNSClass::IN)
) .clone(),
.unwrap())))) Record::from_rdata(
.clone(), origin.clone().into(),
Record::new() 86400,
.set_name(origin.clone().into()) RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
.set_ttl(86400) )
.set_record_type(RecordType::NS) .set_dns_class(DNSClass::IN)
.set_dns_class(DNSClass::IN) .clone(),
.set_data(Some(RData::NS(NS(Name::parse( Record::from_rdata(
"b.iana-servers.net.", origin.clone().into(),
None, 86400,
) RData::A(A::new(94, 184, 216, 34)),
.unwrap())))) )
.clone(), .set_dns_class(DNSClass::IN)
Record::new() .clone(),
.set_name(origin.clone().into()) Record::from_rdata(
.set_ttl(86400) origin.clone().into(),
.set_record_type(RecordType::A) 86400,
.set_dns_class(DNSClass::IN) RData::AAAA(AAAA::new(
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(),
Record::new()
.set_name(origin.clone().into())
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
Record::new() .set_dns_class(DNSClass::IN)
.set_name(www_name.clone()) .clone(),
.set_ttl(86400) Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(94, 184, 216, 34)))
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(), .clone(),
Record::new() Record::from_rdata(
.set_name(www_name) www_name,
.set_ttl(86400) 86400,
.set_record_type(RecordType::AAAA) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
Record::new() .set_dns_class(DNSClass::IN)
.set_name(origin.into()) .clone(),
.set_ttl(3600) Record::from_rdata(
.set_record_type(RecordType::SOA) origin.into(),
.set_dns_class(DNSClass::IN) 3600,
.set_data(Some(RData::SOA(SOA::new( RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(), Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(), Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403, 2015082403,
@ -483,8 +453,10 @@ async fn test_axfr() {
3600, 3600,
1209600, 1209600,
3600, 3600,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
]; ];
expected_set.sort(); expected_set.sort();
@ -567,7 +539,7 @@ async fn test_cname_additionals() {
assert_eq!(answers.len(), 1); assert_eq!(answers.len(), 1);
assert_eq!(answers.first().unwrap().record_type(), RecordType::CNAME); assert_eq!(answers.first().unwrap().record_type(), RecordType::CNAME);
assert_eq!( assert_eq!(
answers.first().unwrap().data().unwrap(), answers.first().unwrap().data(),
&RData::CNAME(CNAME(Name::from_str("www.example.com.").unwrap())) &RData::CNAME(CNAME(Name::from_str("www.example.com.").unwrap()))
); );
@ -575,7 +547,7 @@ async fn test_cname_additionals() {
assert!(!additionals.is_empty()); assert!(!additionals.is_empty());
assert_eq!(additionals.first().unwrap().record_type(), RecordType::A); assert_eq!(additionals.first().unwrap().record_type(), RecordType::A);
assert_eq!( assert_eq!(
additionals.first().unwrap().data().unwrap(), additionals.first().unwrap().data(),
&RData::A(A::new(93, 184, 215, 14)) &RData::A(A::new(93, 184, 215, 14))
); );
} }
@ -614,7 +586,7 @@ async fn test_multiple_cname_additionals() {
assert_eq!(answers.len(), 1); assert_eq!(answers.len(), 1);
assert_eq!(answers.first().unwrap().record_type(), RecordType::CNAME); assert_eq!(answers.first().unwrap().record_type(), RecordType::CNAME);
assert_eq!( assert_eq!(
answers.first().unwrap().data().unwrap(), answers.first().unwrap().data(),
&RData::CNAME(CNAME(Name::from_str("alias.example.com.").unwrap())) &RData::CNAME(CNAME(Name::from_str("alias.example.com.").unwrap()))
); );
@ -626,7 +598,7 @@ async fn test_multiple_cname_additionals() {
RecordType::CNAME RecordType::CNAME
); );
assert_eq!( assert_eq!(
additionals.first().unwrap().data().unwrap(), additionals.first().unwrap().data(),
&RData::CNAME(CNAME(Name::from_str("www.example.com.").unwrap())) &RData::CNAME(CNAME(Name::from_str("www.example.com.").unwrap()))
); );
@ -635,7 +607,7 @@ async fn test_multiple_cname_additionals() {
assert!(!additionals.is_empty()); assert!(!additionals.is_empty());
assert_eq!(additionals.last().unwrap().record_type(), RecordType::A); assert_eq!(additionals.last().unwrap().record_type(), RecordType::A);
assert_eq!( assert_eq!(
additionals.last().unwrap().data().unwrap(), additionals.last().unwrap().data(),
&RData::A(A::new(93, 184, 215, 14)) &RData::A(A::new(93, 184, 215, 14))
); );
} }

81
tests/integration-tests/tests/client_future_tests.rs
View File

@ -191,7 +191,7 @@ fn test_query(client: &mut AsyncClient) -> impl Future<Output = ()> {
assert_eq!(record.record_type(), RecordType::A); assert_eq!(record.record_type(), RecordType::A);
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
if let RData::A(ref address) = record.data().unwrap() { if let RData::A(ref address) = record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();
@ -250,7 +250,7 @@ fn test_query_edns(client: &mut AsyncClient) -> impl Future<Output = ()> {
.unwrap(), .unwrap(),
&EdnsOption::Subnet("1.2.0.0/16".parse().unwrap()) &EdnsOption::Subnet("1.2.0.0/16".parse().unwrap())
); );
if let RData::A(ref address) = *record.data().unwrap() { if let RData::A(ref address) = *record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();
@ -315,12 +315,11 @@ async fn create_sig0_ready_client() -> (
let signer = SigSigner::sig0(sig0_key.clone(), key, trusted_name.clone()); let signer = SigSigner::sig0(sig0_key.clone(), key, trusted_name.clone());
// insert the KEY for the trusted.example.com // insert the KEY for the trusted.example.com
let mut auth_key = Record::with( let auth_key = Record::from_rdata(
trusted_name, trusted_name,
RecordType::KEY,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::DNSSEC(DNSSECRData::KEY(sig0_key)),
); );
auth_key.set_data(Some(RData::DNSSEC(DNSSECRData::KEY(sig0_key))));
authority.upsert_mut(auth_key, 0); authority.upsert_mut(auth_key, 0);
// setup the catalog // setup the catalog
@ -344,13 +343,11 @@ fn test_create() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// create a record // create a record
let mut record = Record::with( let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let record = record;
let result = io_loop let result = io_loop
.block_on(client.create(record.clone(), origin.clone())) .block_on(client.create(record.clone(), origin.clone()))
@ -376,7 +373,7 @@ fn test_create() {
// will fail if already set and not the same value. // will fail if already set and not the same value.
let mut record = record; let mut record = record;
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = io_loop let result = io_loop
.block_on(client.create(record, origin)) .block_on(client.create(record, origin))
@ -392,16 +389,15 @@ fn test_create_multi() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// create a record // create a record
let mut record = Record::with( let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let record = record; let record = record;
let mut record2 = record.clone(); let mut record2 = record.clone();
record2.set_data(Some(RData::A(A::new(100, 10, 100, 11)))); record2.set_data(RData::A(A::new(100, 10, 100, 11)));
let record2 = record2; let record2 = record2;
let mut rrset = RecordSet::from(record.clone()); let mut rrset = RecordSet::from(record.clone());
@ -434,7 +430,7 @@ fn test_create_multi() {
// will fail if already set and not the same value. // will fail if already set and not the same value.
let mut record = record; let mut record = record;
record.set_data(Some(RData::A(A::new(101, 11, 101, 12)))); record.set_data(RData::A(A::new(101, 11, 101, 12)));
let result = io_loop let result = io_loop
.block_on(client.create(record, origin)) .block_on(client.create(record, origin))
@ -450,13 +446,11 @@ fn test_append() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// append a record // append a record
let mut record = Record::with( let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let record = record;
// first check the must_exist option // first check the must_exist option
let result = io_loop let result = io_loop
@ -484,7 +478,7 @@ fn test_append() {
// will fail if already set and not the same value. // will fail if already set and not the same value.
let mut record2 = record.clone(); let mut record2 = record.clone();
record2.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record2.set_data(RData::A(A::new(101, 11, 101, 11)));
let record2 = record2; let record2 = record2;
let result = io_loop let result = io_loop
@ -530,12 +524,11 @@ fn test_append_multi() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// append a record // append a record
let mut record = Record::with( let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = io_loop let result = io_loop
@ -563,9 +556,9 @@ fn test_append_multi() {
// will fail if already set and not the same value. // will fail if already set and not the same value.
let mut record2 = record.clone(); let mut record2 = record.clone();
record2.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record2.set_data(RData::A(A::new(101, 11, 101, 11)));
let mut record3 = record.clone(); let mut record3 = record.clone();
record3.set_data(Some(RData::A(A::new(101, 11, 101, 12)))); record3.set_data(RData::A(A::new(101, 11, 101, 12)));
// build the append set // build the append set
let mut rrset = RecordSet::from(record2.clone()); let mut rrset = RecordSet::from(record2.clone());
@ -616,13 +609,11 @@ fn test_compare_and_swap() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// create a record // create a record
let mut record = Record::with( let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let record = record;
let result = io_loop let result = io_loop
.block_on(client.create(record.clone(), origin.clone())) .block_on(client.create(record.clone(), origin.clone()))
@ -631,7 +622,7 @@ fn test_compare_and_swap() {
let current = record; let current = record;
let mut new = current.clone(); let mut new = current.clone();
new.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); new.set_data(RData::A(A::new(101, 11, 101, 11)));
let new = new; let new = new;
let result = io_loop let result = io_loop
@ -649,7 +640,7 @@ fn test_compare_and_swap() {
// check the it fails if tried again. // check the it fails if tried again.
let mut not = new.clone(); let mut not = new.clone();
not.set_data(Some(RData::A(A::new(102, 12, 102, 12)))); not.set_data(RData::A(A::new(102, 12, 102, 12)));
let not = not; let not = not;
let result = io_loop let result = io_loop
@ -715,7 +706,7 @@ fn test_compare_and_swap_multi() {
// check the it fails if tried again. // check the it fails if tried again.
let mut not = new1.clone(); let mut not = new1.clone();
not.set_data(Some(RData::A(A::new(102, 12, 102, 12)))); not.set_data(RData::A(A::new(102, 12, 102, 12)));
let not = not; let not = not;
let result = io_loop let result = io_loop
@ -740,12 +731,11 @@ fn test_delete_by_rdata() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// append a record // append a record
let mut record1 = Record::with( let record1 = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record1.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = io_loop let result = io_loop
@ -760,7 +750,7 @@ fn test_delete_by_rdata() {
assert_eq!(result.response_code(), ResponseCode::NoError); assert_eq!(result.response_code(), ResponseCode::NoError);
let mut record2 = record1.clone(); let mut record2 = record1.clone();
record2.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record2.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = io_loop let result = io_loop
.block_on(client.append(record2.clone(), origin.clone(), true)) .block_on(client.append(record2.clone(), origin.clone(), true))
.expect("create failed"); .expect("create failed");
@ -831,8 +821,8 @@ fn test_delete_by_rdata_multi() {
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
); );
let record1 = rrset.new_record(record1.data().unwrap()).clone(); let record1 = rrset.new_record(record1.data()).clone();
let record3 = rrset.new_record(record3.data().unwrap()).clone(); let record3 = rrset.new_record(record3.data()).clone();
let rrset = rrset; let rrset = rrset;
let result = io_loop let result = io_loop
@ -869,12 +859,11 @@ fn test_delete_rrset() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// append a record // append a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = io_loop let result = io_loop
@ -888,7 +877,7 @@ fn test_delete_rrset() {
.expect("create failed"); .expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError); assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = io_loop let result = io_loop
.block_on(client.append(record.clone(), origin.clone(), true)) .block_on(client.append(record.clone(), origin.clone(), true))
.expect("create failed"); .expect("create failed");
@ -921,12 +910,11 @@ fn test_delete_all() {
hickory_proto::spawn_bg(&io_loop, bg); hickory_proto::spawn_bg(&io_loop, bg);
// append a record // append a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = io_loop let result = io_loop
@ -940,8 +928,7 @@ fn test_delete_all() {
.expect("create failed"); .expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError); assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_record_type(RecordType::AAAA); record.set_data(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8)));
record.set_data(Some(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8))));
let result = io_loop let result = io_loop
.block_on(client.create(record.clone(), origin.clone())) .block_on(client.create(record.clone(), origin.clone()))
.expect("create failed"); .expect("create failed");

80
tests/integration-tests/tests/client_tests.rs
View File

@ -125,7 +125,7 @@ where
assert_eq!(record.record_type(), RecordType::A); assert_eq!(record.record_type(), RecordType::A);
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
if let RData::A(ref address) = *record.data().unwrap() { if let RData::A(ref address) = *record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();
@ -183,7 +183,7 @@ where
&EdnsOption::Subnet("1.2.0.0/16".parse().unwrap()) &EdnsOption::Subnet("1.2.0.0/16".parse().unwrap())
); );
if let RData::A(ref address) = *record.data().unwrap() { if let RData::A(ref address) = *record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();
@ -242,7 +242,7 @@ where
assert_eq!(record.record_type(), RecordType::A); assert_eq!(record.record_type(), RecordType::A);
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
if let RData::A(ref address) = *record.data().unwrap() { if let RData::A(ref address) = *record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();
@ -462,19 +462,18 @@ fn create_sig0_ready_client(mut catalog: Catalog) -> (SyncClient<TestClientConne
); );
// insert the KEY for the trusted.example.com // insert the KEY for the trusted.example.com
let mut auth_key = Record::with( let auth_key = Record::from_rdata(
Name::from_str("trusted.example.com").unwrap(), Name::from_str("trusted.example.com").unwrap(),
RecordType::KEY,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::DNSSEC(DNSSECRData::KEY(KEY::new(
Default::default(),
Default::default(),
Default::default(),
Default::default(),
signer.algorithm(),
signer.key().to_public_bytes().expect("to_vec failed"),
))),
); );
auth_key.set_data(Some(RData::DNSSEC(DNSSECRData::KEY(KEY::new(
Default::default(),
Default::default(),
Default::default(),
Default::default(),
signer.algorithm(),
signer.key().to_public_bytes().expect("to_vec failed"),
)))));
authority.upsert_mut(auth_key, 0); authority.upsert_mut(auth_key, 0);
catalog.upsert(authority.origin().clone(), Box::new(Arc::new(authority))); catalog.upsert(authority.origin().clone(), Box::new(Arc::new(authority)));
@ -490,12 +489,11 @@ fn test_create() {
let (client, origin) = create_sig0_ready_client(catalog); let (client, origin) = create_sig0_ready_client(catalog);
// create a record // create a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let result = client let result = client
.create(record.clone(), origin.clone()) .create(record.clone(), origin.clone())
@ -516,7 +514,7 @@ fn test_create() {
assert_eq!(result.response_code(), ResponseCode::YXRRSet); assert_eq!(result.response_code(), ResponseCode::YXRRSet);
// will fail if already set and not the same value. // will fail if already set and not the same value.
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client.create(record, origin).expect("create failed"); let result = client.create(record, origin).expect("create failed");
assert_eq!(result.response_code(), ResponseCode::YXRRSet); assert_eq!(result.response_code(), ResponseCode::YXRRSet);
@ -529,12 +527,11 @@ fn test_append() {
let (client, origin) = create_sig0_ready_client(catalog); let (client, origin) = create_sig0_ready_client(catalog);
// append a record // append a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = client let result = client
@ -557,7 +554,7 @@ fn test_append() {
assert_eq!(result.answers()[0], record); assert_eq!(result.answers()[0], record);
// will fail if already set and not the same value. // will fail if already set and not the same value.
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client let result = client
.append(record.clone(), origin.clone(), true) .append(record.clone(), origin.clone(), true)
@ -573,7 +570,7 @@ fn test_append() {
assert!(result assert!(result
.answers() .answers()
.iter() .iter()
.any(|rr| if let RData::A(ip) = *rr.data().unwrap() { .any(|rr| if let RData::A(ip) = *rr.data() {
ip == A::new(100, 10, 100, 10) ip == A::new(100, 10, 100, 10)
} else { } else {
false false
@ -581,7 +578,7 @@ fn test_append() {
assert!(result assert!(result
.answers() .answers()
.iter() .iter()
.any(|rr| if let RData::A(ip) = rr.data().unwrap() { .any(|rr| if let RData::A(ip) = rr.data() {
*ip == A::new(101, 11, 101, 11) *ip == A::new(101, 11, 101, 11)
} else { } else {
false false
@ -607,12 +604,11 @@ fn test_compare_and_swap() {
let (client, origin) = create_sig0_ready_client(catalog); let (client, origin) = create_sig0_ready_client(catalog);
// create a record // create a record
let mut record = Record::with( let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
let result = client let result = client
.create(record.clone(), origin.clone()) .create(record.clone(), origin.clone())
@ -621,7 +617,7 @@ fn test_compare_and_swap() {
let current = record; let current = record;
let mut new = current.clone(); let mut new = current.clone();
new.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); new.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client let result = client
.compare_and_swap(current.clone(), new.clone(), origin.clone()) .compare_and_swap(current.clone(), new.clone(), origin.clone())
@ -636,14 +632,14 @@ fn test_compare_and_swap() {
assert!(result assert!(result
.answers() .answers()
.iter() .iter()
.any(|rr| if let RData::A(ip) = rr.data().unwrap() { .any(|rr| if let RData::A(ip) = rr.data() {
*ip == A::new(101, 11, 101, 11) *ip == A::new(101, 11, 101, 11)
} else { } else {
false false
})); }));
// check the it fails if tried again. // check the it fails if tried again.
new.set_data(Some(RData::A(A::new(102, 12, 102, 12)))); new.set_data(RData::A(A::new(102, 12, 102, 12)));
let result = client let result = client
.compare_and_swap(current, new.clone(), origin) .compare_and_swap(current, new.clone(), origin)
@ -658,7 +654,7 @@ fn test_compare_and_swap() {
assert!(result assert!(result
.answers() .answers()
.iter() .iter()
.any(|rr| if let RData::A(ip) = rr.data().unwrap() { .any(|rr| if let RData::A(ip) = rr.data() {
*ip == A::new(101, 11, 101, 11) *ip == A::new(101, 11, 101, 11)
} else { } else {
false false
@ -672,12 +668,11 @@ fn test_delete_by_rdata() {
let (client, origin) = create_sig0_ready_client(catalog); let (client, origin) = create_sig0_ready_client(catalog);
// append a record // append a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = client let result = client
@ -691,7 +686,7 @@ fn test_delete_by_rdata() {
.expect("create failed"); .expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError); assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client let result = client
.append(record.clone(), origin.clone(), true) .append(record.clone(), origin.clone(), true)
.expect("create failed"); .expect("create failed");
@ -711,7 +706,7 @@ fn test_delete_by_rdata() {
assert!(result assert!(result
.answers() .answers()
.iter() .iter()
.any(|rr| if let RData::A(ip) = rr.data().unwrap() { .any(|rr| if let RData::A(ip) = rr.data() {
*ip == A::new(100, 10, 100, 10) *ip == A::new(100, 10, 100, 10)
} else { } else {
false false
@ -725,12 +720,11 @@ fn test_delete_rrset() {
let (client, origin) = create_sig0_ready_client(catalog); let (client, origin) = create_sig0_ready_client(catalog);
// append a record // append a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = client let result = client
@ -744,7 +738,7 @@ fn test_delete_rrset() {
.expect("create failed"); .expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError); assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_data(Some(RData::A(A::new(101, 11, 101, 11)))); record.set_data(RData::A(A::new(101, 11, 101, 11)));
let result = client let result = client
.append(record.clone(), origin.clone(), true) .append(record.clone(), origin.clone(), true)
.expect("create failed"); .expect("create failed");
@ -772,12 +766,11 @@ fn test_delete_all() {
let (client, origin) = create_sig0_ready_client(catalog); let (client, origin) = create_sig0_ready_client(catalog);
// append a record // append a record
let mut record = Record::with( let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(), Name::from_str("new.example.com").unwrap(),
RecordType::A,
Duration::minutes(5).whole_seconds() as u32, Duration::minutes(5).whole_seconds() as u32,
RData::A(A::new(100, 10, 100, 10)),
); );
record.set_data(Some(RData::A(A::new(100, 10, 100, 10))));
// first check the must_exist option // first check the must_exist option
let result = client let result = client
@ -791,8 +784,7 @@ fn test_delete_all() {
.expect("create failed"); .expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError); assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_record_type(RecordType::AAAA); record.set_data(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8)));
record.set_data(Some(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8))));
let result = client let result = client
.create(record.clone(), origin.clone()) .create(record.clone(), origin.clone())
.expect("create failed"); .expect("create failed");

2
tests/integration-tests/tests/dnssec_client_handle_tests.rs
View File

@ -64,7 +64,7 @@ where
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
assert_eq!(record.proof(), Proof::Secure); assert_eq!(record.proof(), Proof::Secure);
if let RData::A(ref address) = *record.data().unwrap() { if let RData::A(ref address) = *record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();

18
tests/integration-tests/tests/lookup_tests.rs
View File

@ -99,13 +99,13 @@ fn test_lookup_hosts() {
fn create_ip_like_example() -> InMemoryAuthority { fn create_ip_like_example() -> InMemoryAuthority {
let mut authority = create_example(); let mut authority = create_example();
authority.upsert_mut( authority.upsert_mut(
Record::new() Record::from_rdata(
.set_name(Name::from_str("1.2.3.4.example.com.").unwrap()) Name::from_str("1.2.3.4.example.com.").unwrap(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::A) RData::A(A::new(198, 51, 100, 35)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(A::new(198, 51, 100, 35)))) .set_dns_class(DNSClass::IN)
.clone(), .clone(),
0, 0,
); );
@ -261,7 +261,7 @@ fn test_cname_lookup_preserve() {
let lookup = io_loop.block_on(lookup).unwrap(); let lookup = io_loop.block_on(lookup).unwrap();
let mut iter = lookup.iter(); let mut iter = lookup.iter();
assert_eq!(iter.next().unwrap(), cname_record.data().unwrap()); assert_eq!(iter.next().unwrap(), cname_record.data());
assert_eq!(*iter.next().unwrap(), RData::A(A::new(93, 184, 215, 14))); assert_eq!(*iter.next().unwrap(), RData::A(A::new(93, 184, 215, 14)));
} }
@ -341,7 +341,7 @@ fn test_chained_cname_lookup_preserve() {
let lookup = io_loop.block_on(lookup).unwrap(); let lookup = io_loop.block_on(lookup).unwrap();
let mut iter = lookup.iter(); let mut iter = lookup.iter();
assert_eq!(iter.next().unwrap(), cname_record.data().unwrap()); assert_eq!(iter.next().unwrap(), cname_record.data());
assert_eq!(*iter.next().unwrap(), RData::A(A::new(93, 184, 215, 14))); assert_eq!(*iter.next().unwrap(), RData::A(A::new(93, 184, 215, 14)));
} }

2
tests/integration-tests/tests/server_future_tests.rs
View File

@ -350,7 +350,7 @@ where
assert_eq!(record.record_type(), RecordType::A); assert_eq!(record.record_type(), RecordType::A);
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
if let RData::A(ref address) = *record.data().unwrap() { if let RData::A(ref address) = *record.data() {
assert_eq!(address, &A::new(93, 184, 215, 14)) assert_eq!(address, &A::new(93, 184, 215, 14))
} else { } else {
panic!(); panic!();

580
tests/integration-tests/tests/sqlite_authority_tests.rs
View File

@ -52,7 +52,7 @@ async fn test_search() {
let record = result.iter().next().unwrap(); let record = result.iter().next().unwrap();
assert_eq!(record.record_type(), RecordType::A); assert_eq!(record.record_type(), RecordType::A);
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
assert_eq!(record.data().unwrap(), &RData::A(A::new(93, 184, 215, 14))); assert_eq!(record.data(), &RData::A(A::new(93, 184, 215, 14)));
} else { } else {
panic!("expected a result"); // valid panic, in test panic!("expected a result"); // valid panic, in test
} }
@ -82,7 +82,7 @@ async fn test_search_www() {
let record = result.iter().next().unwrap(); let record = result.iter().next().unwrap();
assert_eq!(record.record_type(), RecordType::A); assert_eq!(record.record_type(), RecordType::A);
assert_eq!(record.dns_class(), DNSClass::IN); assert_eq!(record.dns_class(), DNSClass::IN);
assert_eq!(record.data().unwrap(), &RData::A(A::new(93, 184, 215, 14))); assert_eq!(record.data(), &RData::A(A::new(93, 184, 215, 14)));
} else { } else {
panic!("expected a result"); // valid panic, in test panic!("expected a result"); // valid panic, in test
} }
@ -121,31 +121,23 @@ async fn test_authority() {
assert_eq!( assert_eq!(
*lookup.first().unwrap(), *lookup.first().unwrap(),
Record::new() Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"a.iana-servers.net.", .clone()
None
)
.unwrap()))))
.clone()
); );
assert_eq!( assert_eq!(
*lookup.last().unwrap(), *lookup.last().unwrap(),
Record::new() Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::NS) RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::NS(NS(Name::parse( .set_dns_class(DNSClass::IN)
"b.iana-servers.net.", .clone()
None
)
.unwrap()))))
.clone()
); );
assert!(!authority assert!(!authority
@ -173,17 +165,15 @@ async fn test_authority() {
assert_eq!( assert_eq!(
*lookup.first().unwrap(), *lookup.first().unwrap(),
Record::new() Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(60) 60,
.set_record_type(RecordType::TXT) RData::TXT(TXT::new(vec!["$Id: example.com 4415 2015-08-24 \
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::TXT(TXT::new(vec![
"$Id: example.com 4415 2015-08-24 \
20:12:23Z davids $" 20:12:23Z davids $"
.to_string(), .to_string(),])),
])))) )
.clone() .set_dns_class(DNSClass::IN)
.clone()
); );
assert_eq!( assert_eq!(
@ -194,13 +184,13 @@ async fn test_authority() {
.iter() .iter()
.next() .next()
.unwrap(), .unwrap(),
Record::new() Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::A) RData::A(A::new(93, 184, 215, 14)),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::A(A::new(93, 184, 215, 14)))) .set_dns_class(DNSClass::IN)
.clone() .clone()
); );
} }
@ -243,24 +233,16 @@ async fn test_prerequisites() {
// first check the initial negatives, ttl = 0, and the zone is the same // first check the initial negatives, ttl = 0, and the zone is the same
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(not_in_zone.clone(), 86400, RecordType::A)
.set_name(not_in_zone.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(not_zone, 0, RecordType::A)
.set_name(not_zone)
.set_ttl(0)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::NotZone) Err(ResponseCode::NotZone)
@ -268,47 +250,43 @@ async fn test_prerequisites() {
// * ANY ANY empty Name is in use // * ANY ANY empty Name is in use
assert!(authority assert!(authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::ANY) RecordType::ANY,
.set_record_type(RecordType::ANY) )
.set_data(Some(RData::NULL(NULL::new()))) .set_dns_class(DNSClass::ANY)
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::from_rdata(
.set_name(not_in_zone.clone()) not_in_zone.clone(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::ANY) RData::Update0(RecordType::ANY)
.set_record_type(RecordType::ANY) )
.set_data(Some(RData::NULL(NULL::new()))) .set_dns_class(DNSClass::ANY)
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::NXDomain) Err(ResponseCode::NXDomain)
); );
// * ANY rrset empty RRset exists (value independent) // * ANY rrset empty RRset exists (value independent)
assert!(authority assert!(authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::ANY) RecordType::A,
.set_record_type(RecordType::A) )
.set_data(Some(RData::NULL(NULL::new()))) .set_dns_class(DNSClass::ANY)
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(not_in_zone.clone(), 0, RecordType::A,)
.set_name(not_in_zone.clone())
.set_ttl(0)
.set_dns_class(DNSClass::ANY) .set_dns_class(DNSClass::ANY)
.set_record_type(RecordType::A)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::NXRRSet) Err(ResponseCode::NXRRSet)
@ -316,99 +294,91 @@ async fn test_prerequisites() {
// * NONE ANY empty Name is not in use // * NONE ANY empty Name is not in use
assert!(authority assert!(authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(not_in_zone.clone(), 0, RecordType::ANY,)
.set_name(not_in_zone.clone())
.set_ttl(0)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_record_type(RecordType::ANY)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::NONE) RecordType::ANY,
.set_record_type(RecordType::ANY) )
.set_data(Some(RData::NULL(NULL::new()))) .set_dns_class(DNSClass::NONE)
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::YXDomain) Err(ResponseCode::YXDomain)
); );
// * NONE rrset empty RRset does not exist // * NONE rrset empty RRset does not exist
assert!(authority assert!(authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(not_in_zone.clone(), 0, RecordType::A,)
.set_name(not_in_zone.clone())
.set_ttl(0)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_record_type(RecordType::A)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::update0(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::NONE) RecordType::A,
.set_record_type(RecordType::A) )
.set_data(Some(RData::NULL(NULL::new()))) .set_dns_class(DNSClass::NONE)
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::YXRRSet) Err(ResponseCode::YXRRSet)
); );
// * zone rrset rr RRset exists (value dependent) // * zone rrset rr RRset exists (value dependent)
assert!(authority assert!(authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::IN) RData::A(A::new(93, 184, 215, 14)),
.set_record_type(RecordType::A) )
.set_data(Some(RData::A(A::new(93, 184, 215, 14)))) .set_dns_class(DNSClass::IN)
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
// wrong class // wrong class
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::CH) RData::A(A::new(93, 184, 215, 14)),
.set_record_type(RecordType::A) )
.set_data(Some(RData::A(A::new(93, 184, 215, 14)))) .set_dns_class(DNSClass::CH)
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
// wrong Name // wrong Name
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::from_rdata(
.set_name(not_in_zone) not_in_zone,
.set_ttl(0) 0,
.set_dns_class(DNSClass::IN) RData::A(A::new(93, 184, 216, 24)),
.set_record_type(RecordType::A) )
.set_data(Some(RData::A(A::new(93, 184, 216, 24)))) .set_dns_class(DNSClass::IN)
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::NXRRSet) Err(ResponseCode::NXRRSet)
); );
// wrong IP // wrong IP
assert_eq!( assert_eq!(
authority authority
.verify_prerequisites(&[Record::new() .verify_prerequisites(&[Record::from_rdata(
.set_name(authority.origin().clone().into()) authority.origin().clone().into(),
.set_ttl(0) 0,
.set_dns_class(DNSClass::IN) RData::A(A::new(93, 184, 216, 24)),
.set_record_type(RecordType::A) )
.set_data(Some(RData::A(A::new(93, 184, 216, 24)))) .set_dns_class(DNSClass::IN)
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::NXRRSet) Err(ResponseCode::NXRRSet)
); );
@ -423,220 +393,156 @@ async fn test_pre_scan() {
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[
.set_name(not_zone) Record::from_rdata(not_zone, 86400, RData::A(A::new(93, 184, 216, 24)),)
.set_ttl(86400) .set_dns_class(DNSClass::IN)
.set_record_type(RecordType::A) .clone()
.set_dns_class(DNSClass::IN) ],)
.set_data(Some(RData::A(A::new(93, 184, 216, 24))))
.clone()],)
.await, .await,
Err(ResponseCode::NotZone) Err(ResponseCode::NotZone)
); );
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 86400, RecordType::ANY,)
.set_name(up_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::ANY)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 86400, RecordType::AXFR,)
.set_name(up_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::AXFR)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 86400, RecordType::IXFR,)
.set_name(up_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::IXFR)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert!(authority assert!(authority
.pre_scan(&[Record::new() .pre_scan(&[
.set_name(up_name.clone()) Record::from_rdata(up_name.clone(), 86400, RData::A(A::new(93, 184, 216, 24)),)
.set_ttl(86400) .set_dns_class(DNSClass::IN)
.set_record_type(RecordType::A) .clone()
])
.await
.is_ok());
assert!(authority
.pre_scan(&[Record::update0(up_name.clone(), 86400, RecordType::A,)
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(93, 184, 216, 24))))
.clone()])
.await
.is_ok());
assert!(authority
.pre_scan(&[Record::new()
.set_name(up_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::from_rdata(
.set_name(up_name.clone()) up_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::A) RData::A(A::new(93, 184, 216, 24)),
.set_dns_class(DNSClass::ANY) )
.set_data(Some(RData::A(A::new(93, 184, 216, 24))))
.clone()],)
.await,
Err(ResponseCode::FormErr)
);
assert_eq!(
authority
.pre_scan(&[Record::new()
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::ANY)
.set_data(Some(RData::A(A::new(93, 184, 216, 24))))
.clone()],)
.await,
Err(ResponseCode::FormErr)
);
assert_eq!(
authority
.pre_scan(&[Record::new()
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::AXFR)
.set_dns_class(DNSClass::ANY)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],)
.await,
Err(ResponseCode::FormErr)
);
assert_eq!(
authority
.pre_scan(&[Record::new()
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::IXFR)
.set_dns_class(DNSClass::ANY)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],)
.await,
Err(ResponseCode::FormErr)
);
assert!(authority
.pre_scan(&[Record::new()
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::ANY)
.set_dns_class(DNSClass::ANY) .set_dns_class(DNSClass::ANY)
.set_data(Some(RData::NULL(NULL::new()))) .clone()],)
.clone()]) .await,
.await Err(ResponseCode::FormErr)
.is_ok()); );
assert_eq!(
authority
.pre_scan(&[
Record::from_rdata(up_name.clone(), 0, RData::A(A::new(93, 184, 216, 24)),)
.set_dns_class(DNSClass::ANY)
.clone()
],)
.await,
Err(ResponseCode::FormErr)
);
assert_eq!(
authority
.pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::AXFR,)
.set_dns_class(DNSClass::ANY)
.clone()],)
.await,
Err(ResponseCode::FormErr)
);
assert_eq!(
authority
.pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::IXFR,)
.set_dns_class(DNSClass::ANY)
.clone()],)
.await,
Err(ResponseCode::FormErr)
);
assert!(authority assert!(authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::ANY,)
.set_name(up_name.clone()) .set_dns_class(DNSClass::ANY)
.set_ttl(0) .clone()])
.set_record_type(RecordType::A) .await
.is_ok());
assert!(authority
.pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::A,)
.set_dns_class(DNSClass::ANY) .set_dns_class(DNSClass::ANY)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 86400, RecordType::A,)
.set_name(up_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::ANY,)
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::ANY)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::AXFR,)
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::AXFR)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::IXFR,)
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::IXFR)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
); );
assert!(authority assert!(authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name.clone(), 0, RecordType::A,)
.set_name(up_name.clone())
.set_ttl(0)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::NONE) .set_dns_class(DNSClass::NONE)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]) .clone()])
.await .await
.is_ok()); .is_ok());
assert!(authority assert!(authority
.pre_scan(&[Record::new() .pre_scan(&[
.set_name(up_name.clone()) Record::from_rdata(up_name.clone(), 0, RData::A(A::new(93, 184, 216, 24)),)
.set_ttl(0) .set_dns_class(DNSClass::NONE)
.set_record_type(RecordType::A) .clone()
.set_dns_class(DNSClass::NONE) ])
.set_data(Some(RData::A(A::new(93, 184, 216, 24))))
.clone()])
.await .await
.is_ok()); .is_ok());
assert_eq!( assert_eq!(
authority authority
.pre_scan(&[Record::new() .pre_scan(&[Record::update0(up_name, 86400, RecordType::A,)
.set_name(up_name)
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::CH) .set_dns_class(DNSClass::CH)
.set_data(Some(RData::NULL(NULL::new())))
.clone()],) .clone()],)
.await, .await,
Err(ResponseCode::FormErr) Err(ResponseCode::FormErr)
@ -653,29 +559,25 @@ async fn test_update() {
authority.set_allow_update(true); authority.set_allow_update(true);
let mut original_vec: Vec<Record> = vec![ let mut original_vec: Vec<Record> = vec![
Record::new() Record::from_rdata(
.set_name(www_name.clone()) www_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::TXT) RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()])),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(93, 184, 215, 14)))
.set_dns_class(DNSClass::IN) .set_dns_class(DNSClass::IN)
.set_data(Some(RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()]))))
.clone(), .clone(),
Record::new() Record::from_rdata(
.set_name(www_name.clone()) www_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::A) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(93, 184, 215, 14))))
.clone(),
Record::new()
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
]; ];
original_vec.sort(); original_vec.sort();
@ -711,13 +613,12 @@ async fn test_update() {
// //
// zone rrset rr Add to an RRset // zone rrset rr Add to an RRset
let add_record = &[Record::new() let add_record =
.set_name(new_name.clone()) &[
.set_ttl(86400) Record::from_rdata(new_name.clone(), 86400, RData::A(A::new(93, 184, 216, 24)))
.set_record_type(RecordType::A) .set_dns_class(DNSClass::IN)
.set_dns_class(DNSClass::IN) .clone(),
.set_data(Some(RData::A(A::new(93, 184, 216, 24)))) ];
.clone()];
assert!(authority assert!(authority
.update_records(add_record, true,) .update_records(add_record, true,)
.await .await
@ -737,13 +638,12 @@ async fn test_update() {
); );
assert_eq!(serial + 1, authority.serial().await); assert_eq!(serial + 1, authority.serial().await);
let add_www_record = &[Record::new() let add_www_record =
.set_name(www_name.clone()) &[
.set_ttl(86400) Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(10, 0, 0, 1)))
.set_record_type(RecordType::A) .set_dns_class(DNSClass::IN)
.set_dns_class(DNSClass::IN) .clone(),
.set_data(Some(RData::A(A::new(10, 0, 0, 1)))) ];
.clone()];
assert!(authority assert!(authority
.update_records(add_www_record, true,) .update_records(add_www_record, true,)
.await .await
@ -772,13 +672,12 @@ async fn test_update() {
// //
// NONE rrset rr Delete an RR from an RRset // NONE rrset rr Delete an RR from an RRset
let del_record = &[Record::new() let del_record =
.set_name(new_name.clone()) &[
.set_ttl(86400) Record::from_rdata(new_name.clone(), 86400, RData::A(A::new(93, 184, 216, 24)))
.set_record_type(RecordType::A) .set_dns_class(DNSClass::NONE)
.set_dns_class(DNSClass::NONE) .clone(),
.set_data(Some(RData::A(A::new(93, 184, 216, 24)))) ];
.clone()];
assert!(authority assert!(authority
.update_records(del_record, true,) .update_records(del_record, true,)
.await .await
@ -795,13 +694,11 @@ async fn test_update() {
} }
// remove one from www // remove one from www
let del_record = &[Record::new() let del_record = &[
.set_name(www_name.clone()) Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(10, 0, 0, 1)))
.set_ttl(86400) .set_dns_class(DNSClass::NONE)
.set_record_type(RecordType::A) .clone(),
.set_dns_class(DNSClass::NONE) ];
.set_data(Some(RData::A(A::new(10, 0, 0, 1))))
.clone()];
assert!(authority assert!(authority
.update_records(del_record, true,) .update_records(del_record, true,)
.await .await
@ -826,12 +723,8 @@ async fn test_update() {
// //
// ANY rrset empty Delete an RRset // ANY rrset empty Delete an RRset
let del_record = &[Record::new() let del_record = &[Record::update0(www_name.clone(), 86400, RecordType::A)
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::ANY) .set_dns_class(DNSClass::ANY)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]; .clone()];
assert!(authority assert!(authority
.update_records(del_record, true,) .update_records(del_record, true,)
@ -839,22 +732,22 @@ async fn test_update() {
.expect("update failed",)); .expect("update failed",));
assert_eq!(serial + 5, authority.serial().await); assert_eq!(serial + 5, authority.serial().await);
let mut removed_a_vec: Vec<_> = vec![ let mut removed_a_vec: Vec<_> = vec![
Record::new() Record::from_rdata(
.set_name(www_name.clone()) www_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::TXT) RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()])),
.set_dns_class(DNSClass::IN) )
.set_data(Some(RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()])))) .set_dns_class(DNSClass::IN)
.clone(), .clone(),
Record::new() Record::from_rdata(
.set_name(www_name.clone()) www_name.clone(),
.set_ttl(86400) 86400,
.set_record_type(RecordType::AAAA) RData::AAAA(AAAA::new(
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c, 0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)))) )),
.clone(), )
.set_dns_class(DNSClass::IN)
.clone(),
]; ];
removed_a_vec.sort(); removed_a_vec.sort();
@ -878,12 +771,8 @@ async fn test_update() {
// //
// ANY ANY empty Delete all RRsets from a name // ANY ANY empty Delete all RRsets from a name
println!("deleting all records"); println!("deleting all records");
let del_record = &[Record::new() let del_record = &[Record::update0(www_name.clone(), 86400, RecordType::ANY)
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::ANY)
.set_dns_class(DNSClass::ANY) .set_dns_class(DNSClass::ANY)
.set_data(Some(RData::NULL(NULL::new())))
.clone()]; .clone()];
assert!(authority assert!(authority
@ -957,7 +846,7 @@ async fn test_zone_signing() {
.filter_map(|r| { .filter_map(|r| {
match r.record_type() { match r.record_type() {
RecordType::RRSIG if r.name() == record.name() => { RecordType::RRSIG if r.name() == record.name() => {
r.data().and_then(RRSIG::try_borrow) RRSIG::try_borrow(r.data())
} }
_ => None, _ => None,
} }
@ -1002,17 +891,12 @@ async fn test_journal() {
let new_name = Name::from_str("new.example.com").unwrap(); let new_name = Name::from_str("new.example.com").unwrap();
let delete_name = Name::from_str("www.example.com").unwrap(); let delete_name = Name::from_str("www.example.com").unwrap();
let new_record = Record::new() let new_record =
.set_name(new_name.clone()) Record::from_rdata(new_name.clone(), 0, RData::A(A::new(10, 11, 12, 13))).clone();
.set_record_type(RecordType::A) let delete_record =
.set_data(Some(RData::A(A::new(10, 11, 12, 13)))) Record::from_rdata(delete_name.clone(), 0, RData::A(A::new(93, 184, 215, 14)))
.clone(); .set_dns_class(DNSClass::NONE)
let delete_record = Record::new() .clone();
.set_name(delete_name.clone())
.set_record_type(RecordType::A)
.set_data(Some(RData::A(A::new(93, 184, 215, 14))))
.set_dns_class(DNSClass::NONE)
.clone();
authority authority
.update_records(&[new_record.clone(), delete_record], true) .update_records(&[new_record.clone(), delete_record], true)
.await .await

9
util/src/bin/recurse.rs
View File

@ -179,18 +179,13 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
for r in lookup.record_iter().filter(|r| r.record_type() == ty) { for r in lookup.record_iter().filter(|r| r.record_type() == ty) {
print!( print!(
"\t{name} {ttl} {class} {ty}", "\t{name} {ttl} {class} {ty} {rdata}",
name = style(r.name()).blue(), name = style(r.name()).blue(),
ttl = style(r.ttl()).blue(), ttl = style(r.ttl()).blue(),
class = style(r.dns_class()).blue(), class = style(r.dns_class()).blue(),
ty = style(r.record_type()).blue(), ty = style(r.record_type()).blue(),
rdata = r.data()
); );
if let Some(rdata) = r.data() {
println!(" {rdata}");
} else {
println!("NULL")
}
} }
Ok(()) Ok(())

8
util/src/bin/resolve.rs
View File

@ -148,17 +148,13 @@ struct Opts {
fn print_record<D: RecordData, R: Deref<Target = Record<D>>>(r: &R) { fn print_record<D: RecordData, R: Deref<Target = Record<D>>>(r: &R) {
print!( print!(
"\t{name} {ttl} {class} {ty}", "\t{name} {ttl} {class} {ty} {rdata}",
name = style(r.name()).blue(), name = style(r.name()).blue(),
ttl = style(r.ttl()).blue(), ttl = style(r.ttl()).blue(),
class = style(r.dns_class()).blue(), class = style(r.dns_class()).blue(),
ty = style(r.record_type()).blue(), ty = style(r.record_type()).blue(),
rdata = r.data(),
); );
if let Some(rdata) = r.data() {
println!(" {rdata}");
} else {
println!("NULL")
}
} }
fn print_ok(lookup: Lookup) { fn print_ok(lookup: Lookup) {