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();
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)
);
@ -334,7 +334,7 @@ fn test_forward() {
)
.unwrap();
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)
);
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 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))
} else {
panic!("wrong RDATA")
@ -296,7 +296,7 @@ pub fn query_all_dnssec(
let dnskey = response
.answers()
.iter()
.filter_map(Record::data)
.map(Record::data)
.filter_map(DNSKEY::try_borrow)
.find(|d| d.algorithm() == algorithm);
assert!(dnskey.is_some(), "DNSKEY not found");
@ -306,7 +306,7 @@ pub fn query_all_dnssec(
let rrsig = response
.answers()
.iter()
.filter_map(Record::data)
.map(Record::data)
.filter_map(RRSIG::try_borrow)
.filter(|rrsig| rrsig.algorithm() == algorithm)
.find(|rrsig| rrsig.type_covered() == RecordType::DNSKEY);

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

@ -34,7 +34,7 @@ use crate::{
},
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.
@ -709,7 +709,7 @@ impl<R> ClientStreamXfrState<R> {
fn process(&mut self, answers: &[Record]) -> Result<(), ClientError> {
use ClientStreamXfrState::*;
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() {
@ -864,6 +864,7 @@ mod tests {
use crate::rr::rdata::{A, SOA};
use futures_util::stream::iter;
use hickory_proto::rr::RData;
use ClientStreamXfrState::*;
fn soa_record(serial: u32) -> Record {
@ -1116,7 +1117,7 @@ mod tests {
let (message_returned, buffer) = query.await.unwrap().into_parts();
// 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));
}
@ -1124,7 +1125,7 @@ mod tests {
.expect("buffer was parsed already by AsyncClient so we should be able to do it again");
// 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));
}
}

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

@ -128,7 +128,7 @@
//! // 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 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))
//! } else {
//! assert!(false, "unexpected result")
@ -263,7 +263,7 @@
//! let response = query.await.unwrap();
//!
//! // 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));
//! }
//! }

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

@ -540,7 +540,7 @@ mod tests {
use crate::iocompat::AsyncIoTokioAsStd;
use crate::op::{Message, Query, ResponseCode};
use crate::rr::rdata::{A, AAAA};
use crate::rr::{Name, RData, RecordType};
use crate::rr::{Name, RecordType};
use crate::xfer::{DnsRequestOptions, FirstAnswer};
use super::*;
@ -572,10 +572,7 @@ mod tests {
.expect("send_message failed");
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_a)
.expect("Expected A record");
let addr = record.data().as_a().expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -600,7 +597,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("invalid response, expected A record");
assert_eq!(
@ -637,10 +634,7 @@ mod tests {
.expect("send_message failed");
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_a)
.expect("Expected A record");
let addr = record.data().as_a().expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -665,7 +659,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("invalid response, expected A record");
assert_eq!(
@ -705,7 +699,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_a)
.as_a()
.expect("invalid response, expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -727,7 +721,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("invalid response, expected A record");
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::rr::rdata::{A, AAAA};
use crate::rr::{Name, RData, RecordType};
use crate::rr::{Name, RecordType};
use crate::xfer::{DnsRequestOptions, FirstAnswer};
use super::*;
@ -507,10 +507,7 @@ mod tests {
.expect("send_message failed");
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_a)
.expect("Expected A record");
let addr = record.data().as_a().expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -535,7 +532,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("invalid response, expected A record");
assert_eq!(
@ -572,10 +569,7 @@ mod tests {
.expect("send_message failed");
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_a)
.expect("Expected A record");
let addr = record.data().as_a().expect("Expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -600,7 +594,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("invalid response, expected A record");
assert_eq!(
@ -641,7 +635,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_a)
.as_a()
.expect("invalid response, expected A record");
assert_eq!(addr, &A::new(93, 184, 215, 14));
@ -663,7 +657,7 @@ mod tests {
let record = &response.answers()[0];
let addr = record
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("invalid response, expected A record");
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 options: OPT = match value.data() {
Some(RData::NULL(..)) | None => {
RData::Update0(..) | RData::NULL(..) => {
// NULL, there was no data in the OPT
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
}
_ => {
@ -183,24 +183,18 @@ impl<'a> From<&'a Edns> for Record {
/// 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
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
let mut ttl: u32 = u32::from(value.rcode_high()) << 24;
ttl |= u32::from(value.version()) << 16;
ttl |= u32::from(value.flags);
record.set_ttl(ttl);
// 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
// the original binary format.
// 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
}

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

@ -1191,9 +1191,9 @@ mod tests {
.set_checking_disabled(true)
.set_response_code(ResponseCode::ServFail);
message.add_answer(Record::new());
message.add_name_server(Record::new());
message.add_additional(Record::new());
message.add_answer(Record::stub());
message.add_name_server(Record::stub());
message.add_additional(Record::stub());
message.update_counts();
test_emit_and_read(message);
@ -1229,9 +1229,9 @@ mod tests {
.set_checking_disabled(true)
.set_response_code(ResponseCode::ServFail);
message.add_answer(Record::new());
message.add_name_server(Record::new());
message.add_additional(Record::new());
message.add_answer(Record::stub());
message.add_name_server(Record::stub());
message.add_additional(Record::stub());
// 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

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

@ -11,10 +11,7 @@ use std::fmt::Debug;
use crate::{
op::{Edns, Message, MessageType, OpCode, Query},
rr::{
rdata::{NULL, SOA},
DNSClass, Name, RData, Record, RecordSet, RecordType,
},
rr::{rdata::SOA, DNSClass, Name, RData, Record, RecordSet, RecordType},
};
/// 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);
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);
message.add_pre_requisite(prerequisite);
message.add_pre_requisite(prerequisite.into_record_of_rdata());
message.add_updates(rrset);
// Extended dns
@ -251,9 +248,9 @@ pub fn append(rrset: RecordSet, zone_origin: Name, must_exist: bool, use_edns: b
message.add_zone(zone);
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);
message.add_pre_requisite(prerequisite);
message.add_pre_requisite(prerequisite.into_record_of_rdata());
}
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
record.set_ttl(0);
// 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);
// Extended dns
@ -557,12 +554,12 @@ pub fn delete_all(
// the TTL should be 0
// the rdata must be null to delete all rrsets
// 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
record.set_dns_class(DNSClass::ANY);
message.add_update(record);
message.add_update(record.into_record_of_rdata());
// Extended dns
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
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())
{
tsig_data
@ -795,17 +795,17 @@ pub fn signed_bitmessage_to_buf(
pub fn make_tsig_record(name: Name, rdata: TSIG) -> Record {
// https://tools.ietf.org/html/rfc8945#section-4.2
let mut tsig = Record::new();
// NAME: The name of the key used, in domain name syntax
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)
let mut tsig = Record::from_rdata(
// NAME: The name of the key used, in domain name syntax
name,
// TTL: This MUST be 0.
.set_ttl(0)
.set_data(Some(DNSSECRData::TSIG(rdata).into()));
0,
// TYPE: This MUST be TSIG (250: Transaction SIGnature).
DNSSECRData::TSIG(rdata).into(),
);
// CLASS: This MUST be ANY.
tsig.set_dns_class(DNSClass::ANY);
tsig
}
@ -864,7 +864,7 @@ mod tests {
#[test]
fn test_sign_encode() {
let mut message = Message::new();
message.add_answer(Record::new());
message.add_answer(Record::stub());
let key_name = Name::from_ascii("some.name").unwrap();
@ -899,7 +899,7 @@ mod tests {
#[test]
fn test_sign_encode_id_changed() {
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();

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
// '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).
sig0.set_name(Name::root());
let num_labels = sig0.name().num_labels();
let name = Name::root();
// 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
sig0.set_record_type(RecordType::SIG);
let pre_sig0 = SIG::new(
// type covered in SIG(0) is 0 which is what makes this SIG0 vs a standard SIG
RecordType::ZERO,
@ -565,9 +557,14 @@ impl MessageFinalizer for SigSigner {
Vec::new(),
);
let signature: Vec<u8> = self.sign_message(message, &pre_sig0)?;
sig0.set_data(Some(RData::DNSSEC(DNSSECRData::SIG(
pre_sig0.set_sig(signature),
))));
let rdata = RData::DNSSEC(DNSSECRData::SIG(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))
}
@ -659,7 +656,7 @@ mod tests {
let sig = signer.sign_message(&question, &pre_sig0);
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());
}
}
@ -692,28 +689,20 @@ mod tests {
);
let rrset = vec![
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.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(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin,
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
];
let tbs = tbs::rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap();
@ -829,87 +818,61 @@ MC0CAQACBQC+L6pNAgMBAAECBQCYj0ZNAgMA9CsCAwDHZwICeEUCAnE/AgMA3u0=
),
);
let rrset = vec![
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.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.clone())
.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(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
];
let tbs = rrset_tbs_with_rrsig(&rrsig, &rrset).unwrap();
assert!(!tbs.as_ref().is_empty());
let rrset = vec![
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::CNAME)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(
Name::parse("a.iana-servers.net.", None).unwrap(),
))))
.clone(), // different type
Record::new()
.set_name(Name::parse("www.example.com.", None).unwrap())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"a.iana-servers.net.",
None,
)
.unwrap()))))
.clone(), // different name
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::CH)
.set_data(Some(RData::NS(NS(Name::parse(
"a.iana-servers.net.",
None,
)
.unwrap()))))
.clone(), // different class
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.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(),
Record::from_rdata(
origin.clone(),
86400,
RData::CNAME(CNAME(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(), // different type
Record::from_rdata(
Name::parse("www.example.com.", None).unwrap(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(), // different name
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::CH)
.clone(), // different class
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin,
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
];
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);
rdata_encoder.set_canonical_names(true);
if let Some(rdata) = record.data() {
assert!(rdata.emit(&mut rdata_encoder).is_ok());
}
assert!(record.data().emit(&mut rdata_encoder).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>,
records: &[B],
) -> ProtoResult<TBS> {
if let Some(sig) = rrsig.data() {
rrset_tbs_with_sig(rrsig.name(), rrsig.dns_class(), sig, records)
} else {
Err(format!("could not determine name from {}", rrsig.name()).into())
}
rrset_tbs_with_sig(rrsig.name(), rrsig.dns_class(), rrsig.data(), records)
}
/// 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,
) -> ProtoResult<(Vec<u8>, Range<u64>, u64)> {
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
} else {
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
fn into_rdata(self) -> RData;
/// RDLENGTH = 0
fn is_update(&self) -> bool {
false
}
}
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,
},
/// Update record with RDLENGTH = 0 (RFC2136)
Update0(RecordType),
/// This corresponds to a record type of 0, unspecified
#[deprecated(note = "Use None for the RData in the resource record instead")]
ZERO,
@ -735,6 +738,7 @@ impl RData {
#[cfg(feature = "dnssec")]
Self::DNSSEC(ref rdata) => DNSSECRData::to_record_type(rdata),
Self::Unknown { code, .. } => code,
Self::Update0(record_type) => record_type,
Self::ZERO => RecordType::ZERO,
}
}
@ -975,6 +979,7 @@ impl BinEncodable for RData {
#[cfg(feature = "dnssec")]
Self::DNSSEC(ref rdata) => encoder.with_canonical_names(|encoder| 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 {
self
}
fn is_update(&self) -> bool {
matches!(self, RData::Update0(_))
}
}
impl fmt::Display for RData {
@ -1034,6 +1043,7 @@ impl fmt::Display for RData {
#[cfg(feature = "dnssec")]
Self::DNSSEC(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")]
RData::DNSSEC(ref rdata) => rdata.to_record_type(),
RData::Unknown { code, .. } => code,
RData::Update0(record_type) => record_type,
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
pub struct Record<R: RecordData = RData> {
name_labels: Name,
rr_type: RecordType,
dns_class: DNSClass,
ttl: u32,
rdata: Option<R>,
rdata: R,
#[cfg(feature = "mdns")]
mdns_cache_flush: bool,
#[cfg(feature = "dnssec")]
proof: Proof,
}
impl Default for Record<RData> {
fn default() -> Self {
impl Record {
#[cfg(test)]
pub fn stub() -> Self {
Self {
// TODO: make these part of a Builder instead to cleanup Records at runtime?
name_labels: Name::new(),
rr_type: RecordType::NULL,
dns_class: DNSClass::IN,
ttl: 0,
rdata: None,
rdata: RData::Update0(RecordType::NULL),
#[cfg(feature = "mdns")]
mdns_cache_flush: false,
#[cfg(feature = "dnssec")]
@ -102,62 +100,20 @@ impl Default for Record<RData> {
}
}
impl Record<RData> {
/// Creates a default record, use the setters to build a more useful object.
///
/// 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 {
impl Record {
/// Creates an update record with RDLENGTH=0
pub fn update0(name: Name, ttl: u32, rr_type: RecordType) -> Self {
Self {
name_labels: name,
rr_type,
dns_class: DNSClass::IN,
ttl,
rdata: None,
rdata: RData::Update0(rr_type),
#[cfg(feature = "mdns")]
mdns_cache_flush: false,
#[cfg(feature = "dnssec")]
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> {
@ -171,10 +127,9 @@ impl<R: RecordData> Record<R> {
pub fn from_rdata(name: Name, ttl: u32, rdata: R) -> Self {
Self {
name_labels: name,
rr_type: rdata.record_type(),
dns_class: DNSClass::IN,
ttl,
rdata: Some(rdata),
rdata,
#[cfg(feature = "mdns")]
mdns_cache_flush: false,
#[cfg(feature = "dnssec")]
@ -187,7 +142,6 @@ impl<R: RecordData> Record<R> {
pub fn try_from(record: Record<RData>) -> Result<Self, Record<RData>> {
let Record {
name_labels,
rr_type,
dns_class,
ttl,
rdata,
@ -197,35 +151,22 @@ impl<R: RecordData> Record<R> {
proof,
} = record;
match rdata.map(R::try_from_rdata) {
None => Err(Record {
match R::try_from_rdata(rdata) {
Ok(rdata) => Ok(Self {
name_labels,
rr_type,
dns_class,
ttl,
rdata: None,
rdata,
#[cfg(feature = "mdns")]
mdns_cache_flush,
#[cfg(feature = "dnssec")]
proof,
}),
Some(Ok(rdata)) => Ok(Self {
Err(rdata) => Err(Record {
name_labels,
rr_type: rdata.record_type(),
dns_class,
ttl,
rdata: Some(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),
rdata,
#[cfg(feature = "mdns")]
mdns_cache_flush,
#[cfg(feature = "dnssec")]
@ -238,7 +179,6 @@ impl<R: RecordData> Record<R> {
pub fn into_record_of_rdata(self) -> Record<RData> {
let Self {
name_labels,
rr_type,
dns_class,
ttl,
rdata,
@ -248,11 +188,10 @@ impl<R: RecordData> Record<R> {
proof,
} = self;
let rdata: Option<RData> = rdata.map(RecordData::into_rdata);
let rdata: RData = RecordData::into_rdata(rdata);
Record {
name_labels,
rr_type,
dns_class,
ttl,
rdata,
@ -300,18 +239,7 @@ impl<R: RecordData> Record<R> {
/// the RDATA field is a 4 octet ARPA Internet address.
/// ```
#[track_caller]
pub fn set_data(&mut self, rdata: Option<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())
);
pub fn set_data(&mut self, rdata: R) -> &mut Self {
self.rdata = rdata;
self
}
@ -342,7 +270,7 @@ impl<R: RecordData> Record<R> {
/// Returns the type of the RecordData in the record
#[inline]
pub fn record_type(&self) -> RecordType {
self.rr_type
self.rdata.record_type()
}
/// 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
#[inline]
pub fn data(&self) -> Option<&R> {
self.rdata.as_ref()
pub fn data(&self) -> &R {
&self.rdata
}
/// Returns a mutable reference to the Record Data
#[inline]
pub fn data_mut(&mut self) -> Option<&mut R> {
self.rdata.as_mut()
pub fn data_mut(&mut self) -> &mut R {
&mut self.rdata
}
/// Returns the RData consuming the Record
#[inline]
pub fn into_data(self) -> Option<R> {
pub fn into_data(self) -> R {
self.rdata
}
@ -405,14 +333,12 @@ impl<R: RecordData> Record<R> {
pub struct RecordParts<R: RecordData = RData> {
/// label names
pub name_labels: Name,
/// record type
pub rr_type: RecordType,
/// dns class
pub dns_class: DNSClass,
/// time to live
pub ttl: u32,
/// rdata
pub rdata: Option<R>,
pub rdata: R,
/// mDNS cache flush
#[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 {
let Record {
name_labels,
rr_type,
dns_class,
ttl,
rdata,
@ -439,7 +364,6 @@ impl<R: RecordData> From<Record<R>> for RecordParts<R> {
Self {
name_labels,
rr_type,
dns_class,
ttl,
rdata,
@ -461,7 +385,7 @@ impl IntoRecordSet for Record {
impl<R: RecordData> BinEncodable for Record<R> {
fn emit(&self, encoder: &mut BinEncoder<'_>) -> ProtoResult<()> {
self.name_labels.emit(encoder)?;
self.rr_type.emit(encoder)?;
self.record_type().emit(encoder)?;
#[cfg(not(feature = "mdns"))]
self.dns_class.emit(encoder)?;
@ -483,8 +407,8 @@ impl<R: RecordData> BinEncodable for Record<R> {
// write 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.
if let Some(rdata) = &self.rdata {
rdata.emit(encoder)?;
if !self.rdata.is_update() {
self.rdata.emit(encoder)?;
}
// 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
// Null represents any data.
let rdata = if rd_length == 0 {
None
RData::Update0(record_type)
} else {
// RDATA a variable length string of octets that describes the
// resource. The format of this information varies
// according to the TYPE and CLASS of the resource record.
// Adding restrict to the rdata length because it's used for many calculations later
// 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 {
name_labels,
rr_type: record_type,
dns_class: class,
ttl,
rdata,
@ -649,17 +561,14 @@ impl<R: RecordData> fmt::Display for Record<R> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
write!(
f,
"{name} {ttl} {class} {ty}",
"{name} {ttl} {class} {ty} {rdata}",
name = self.name_labels,
ttl = self.ttl,
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(())
}
}
@ -679,7 +588,6 @@ impl<R: RecordData> PartialEq for Record<R> {
fn eq(&self, other: &Self) -> bool {
// self == other && // the same pointer
self.name_labels == other.name_labels
&& self.rr_type == other.rr_type
&& self.dns_class == other.dns_class
&& self.rdata == other.rdata
}
@ -732,7 +640,10 @@ impl Ord for Record {
// resource records be maintained in binary?
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, ttl);
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
pub struct RecordRef<'a, R: RecordData> {
name_labels: &'a Name,
rr_type: RecordType,
dns_class: DNSClass,
ttl: u32,
rdata: Option<&'a R>,
rdata: &'a R,
#[cfg(feature = "mdns")]
mdns_cache_flush: bool,
#[cfg(feature = "dnssec")]
@ -809,10 +719,9 @@ impl<'a, R: RecordData> RecordRef<'a, R> {
pub fn to_owned(&self) -> Record<R> {
Record {
name_labels: self.name_labels.to_owned(),
rr_type: self.rr_type,
dns_class: self.dns_class,
ttl: self.ttl,
rdata: self.rdata.cloned(),
rdata: self.rdata.clone(),
#[cfg(feature = "mdns")]
mdns_cache_flush: self.mdns_cache_flush,
#[cfg(feature = "dnssec")]
@ -829,7 +738,7 @@ impl<'a, R: RecordData> RecordRef<'a, R> {
/// Returns the type of the RecordData in the record
#[inline]
pub fn record_type(&self) -> RecordType {
self.rr_type
self.rdata.record_type()
}
/// 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
#[inline]
pub fn data(&self) -> Option<&R> {
pub fn data(&self) -> &R {
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> {
let Record {
name_labels,
rr_type,
dns_class,
ttl,
rdata,
@ -884,24 +792,13 @@ impl<'a, R: RecordData> TryFrom<&'a Record> for RecordRef<'a, R> {
proof,
} = record;
match rdata.as_ref().and_then(R::try_borrow) {
None => Ok(Self {
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,
}),
match R::try_borrow(rdata) {
None => Err(record),
Some(rdata) => Ok(Self {
name_labels,
rr_type: *rr_type,
dns_class: *dns_class,
ttl: *ttl,
rdata: Some(rdata),
rdata,
#[cfg(feature = "mdns")]
mdns_cache_flush: *mdns_cache_flush,
#[cfg(feature = "dnssec")]
@ -920,9 +817,8 @@ mod tests {
use super::*;
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_type::RecordType;
use crate::rr::Name;
#[allow(clippy::useless_attribute)]
#[allow(unused)]
@ -930,13 +826,11 @@ mod tests {
#[test]
fn test_emit_and_read() {
let mut record = Record::new();
record
.set_name(Name::from_str("www.example.com").unwrap())
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.set_ttl(5)
.set_data(Some(RData::A(A::new(192, 168, 0, 1))));
let record = Record::from_rdata(
Name::from_str("www.example.com").unwrap(),
5,
RData::A(A::new(192, 168, 0, 1)),
);
let mut vec_bytes: Vec<u8> = Vec::with_capacity(512);
{
@ -953,25 +847,24 @@ mod tests {
#[test]
fn test_order() {
let mut record = Record::new();
record
.set_name(Name::from_str("www.example.com").unwrap())
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.set_ttl(5)
.set_data(Some(RData::A(A::new(192, 168, 0, 1))));
let mut record = Record::from_rdata(
Name::from_str("www.example.com").unwrap(),
5,
RData::A(A::new(192, 168, 0, 1)),
);
record.set_dns_class(DNSClass::IN);
let mut greater_name = record.clone();
greater_name.set_name(Name::from_str("zzz.example.com").unwrap());
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();
greater_class.set_dns_class(DNSClass::NONE);
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![
(&record, &greater_name),
@ -993,7 +886,7 @@ mod tests {
const RR_CLASS_OFFSET: usize = 1 /* empty name */ +
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);
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
.iter()
.find(|r| r.data().map(|r| r == rdata).unwrap_or(false))
.find(|r| r.data() == rdata)
.expect("insert failed")
}
@ -239,8 +239,7 @@ impl RecordSet {
pub fn add_rdata(&mut self, rdata: RData) -> bool {
debug_assert_eq!(self.record_type, rdata.record_type());
let mut record = Record::with(self.name.clone(), self.record_type, self.ttl);
record.set_data(Some(rdata));
let record = Record::from_rdata(self.name.clone(), self.ttl, rdata);
self.insert(record, 0)
}
@ -295,8 +294,8 @@ impl RecordSet {
if let Some(soa_record) = self.records.first() {
match soa_record.data() {
Some(RData::SOA(ref existing_soa)) => {
if let Some(RData::SOA(ref new_soa)) = record.data() {
RData::SOA(ref existing_soa) => {
if let RData::SOA(ref new_soa) = record.data() {
if new_soa.serial() <= existing_soa.serial() {
info!(
"update ignored serial out of data: {:?} <= {:?}",
@ -561,14 +560,14 @@ impl<'r> Iterator for RrsigsByAlgorithms<'r> {
self.rrsigs
.by_ref()
.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())
} else {
false
}
})
.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()
} else {
#[allow(deprecated)]
@ -626,13 +625,13 @@ mod test {
let record_type = RecordType::A;
let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new()
.set_name(name.clone())
.set_ttl(86400)
.set_record_type(record_type)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 24).into())))
.clone();
let insert = Record::from_rdata(
name.clone(),
86400,
RData::A(Ipv4Addr::new(93, 184, 216, 24).into()),
)
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert.clone(), 0));
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));
// add one
let insert1 = Record::new()
.set_name(name)
.set_ttl(86400)
.set_record_type(record_type)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 25).into())))
.clone();
let insert1 = Record::from_rdata(
name,
86400,
RData::A(Ipv4Addr::new(93, 184, 216, 25).into()),
)
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert1.clone(), 0));
assert_eq!(rr_set.records_without_rrsigs().count(), 2);
assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert));
@ -664,12 +663,10 @@ mod test {
let record_type = RecordType::SOA;
let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
let insert = Record::from_rdata(
name.clone(),
3600,
RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.org.").unwrap(),
Name::from_str("noc.dns.icann.org.").unwrap(),
2015082403,
@ -677,14 +674,14 @@ mod test {
3600,
1209600,
3600,
))))
.clone();
let same_serial = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
)),
)
.set_dns_class(DNSClass::IN)
.clone();
let same_serial = Record::from_rdata(
name.clone(),
3600,
RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.net.").unwrap(),
Name::from_str("noc.dns.icann.net.").unwrap(),
2015082403,
@ -692,14 +689,14 @@ mod test {
3600,
1209600,
3600,
))))
.clone();
let new_serial = Record::new()
.set_name(name)
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
)),
)
.set_dns_class(DNSClass::IN)
.clone();
let new_serial = Record::from_rdata(
name,
3600,
RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.net.").unwrap(),
Name::from_str("noc.dns.icann.net.").unwrap(),
2015082404,
@ -707,8 +704,10 @@ mod test {
3600,
1209600,
3600,
))))
.clone();
)),
)
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert.clone(), 0));
assert!(rr_set.records_without_rrsigs().any(|ref x| x == &&insert));
@ -741,19 +740,11 @@ mod test {
let record_type = RecordType::CNAME;
let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::CNAME)
let insert = Record::from_rdata(name.clone(), 3600, RData::CNAME(CNAME(cname)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(cname))))
.clone();
let new_record = Record::new()
.set_name(name)
.set_ttl(3600)
.set_record_type(RecordType::CNAME)
let new_record = Record::from_rdata(name, 3600, RData::CNAME(CNAME(new_cname)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(new_cname))))
.clone();
assert!(rr_set.insert(insert.clone(), 0));
@ -773,20 +764,20 @@ mod test {
let record_type = RecordType::A;
let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new()
.set_name(name.clone())
.set_ttl(86400)
.set_record_type(record_type)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 24).into())))
.clone();
let insert1 = Record::new()
.set_name(name)
.set_ttl(86400)
.set_record_type(record_type)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 216, 25).into())))
.clone();
let insert = Record::from_rdata(
name.clone(),
86400,
RData::A(Ipv4Addr::new(93, 184, 216, 24).into()),
)
.set_dns_class(DNSClass::IN)
.clone();
let insert1 = Record::from_rdata(
name,
86400,
RData::A(Ipv4Addr::new(93, 184, 216, 25).into()),
)
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert.clone(), 0));
assert!(rr_set.insert(insert1.clone(), 0));
@ -804,12 +795,10 @@ mod test {
let record_type = RecordType::SOA;
let mut rr_set = RecordSet::new(&name, record_type, 0);
let insert = Record::new()
.set_name(name)
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
let insert = Record::from_rdata(
name,
3600,
RData::SOA(SOA::new(
Name::from_str("sns.dns.icann.org.").unwrap(),
Name::from_str("noc.dns.icann.org.").unwrap(),
2015082403,
@ -817,8 +806,10 @@ mod test {
3600,
1209600,
3600,
))))
.clone();
)),
)
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(insert.clone(), 0));
assert!(!rr_set.remove(&insert, 0));
@ -831,24 +822,20 @@ mod test {
let record_type = RecordType::NS;
let mut rr_set = RecordSet::new(&name, record_type, 0);
let ns1 = Record::new()
.set_name(name.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(
Name::from_str("a.iana-servers.net.").unwrap()
))))
.clone();
let ns2 = Record::new()
.set_name(name)
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(
Name::from_str("b.iana-servers.net.").unwrap()
))))
.clone();
let ns1 = Record::from_rdata(
name.clone(),
86400,
RData::NS(NS(Name::from_str("a.iana-servers.net.").unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone();
let ns2 = Record::from_rdata(
name,
86400,
RData::NS(NS(Name::from_str("b.iana-servers.net.").unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone();
assert!(rr_set.insert(ns1.clone(), 0));
assert!(rr_set.insert(ns2.clone(), 0));
@ -918,41 +905,37 @@ mod test {
vec![],
);
let rrsig_rsa = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::RRSIG)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(rsasha256))))
.clone();
let rrsig_ecp256 = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::RRSIG)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(ecp256))))
.clone();
let rrsig_ecp384 = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::RRSIG)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(ecp384))))
.clone();
let rrsig_ed25519 = Record::new()
.set_name(name.clone())
.set_ttl(3600)
.set_record_type(RecordType::RRSIG)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::DNSSEC(DNSSECRData::RRSIG(ed25519))))
.clone();
let rrsig_rsa = Record::from_rdata(
name.clone(),
3600,
RData::DNSSEC(DNSSECRData::RRSIG(rsasha256)),
)
.set_dns_class(DNSClass::IN)
.clone();
let rrsig_ecp256 = Record::from_rdata(
name.clone(),
3600,
RData::DNSSEC(DNSSECRData::RRSIG(ecp256)),
)
.set_dns_class(DNSClass::IN)
.clone();
let rrsig_ecp384 = Record::from_rdata(
name.clone(),
3600,
RData::DNSSEC(DNSSECRData::RRSIG(ecp384)),
)
.set_dns_class(DNSClass::IN)
.clone();
let rrsig_ed25519 = Record::from_rdata(
name.clone(),
3600,
RData::DNSSEC(DNSSECRData::RRSIG(ed25519)),
)
.set_dns_class(DNSClass::IN)
.clone();
let a = Record::new()
.set_name(name)
.set_ttl(3600)
.set_record_type(RecordType::A)
let a = Record::from_rdata(name, 3600, 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())))
.clone();
let mut rrset = RecordSet::from(a);
@ -964,7 +947,7 @@ mod test {
assert!(rrset
.records_with_rrsigs(SupportedAlgorithms::all(),)
.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
} else {
false
@ -974,7 +957,7 @@ mod test {
let mut supported_algorithms = SupportedAlgorithms::new();
supported_algorithms.set(Algorithm::ECDSAP384SHA384);
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
} else {
false
@ -984,7 +967,7 @@ mod test {
let mut supported_algorithms = SupportedAlgorithms::new();
supported_algorithms.set(Algorithm::ED25519);
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
} else {
false

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

@ -377,12 +377,7 @@ mod tests {
.expect("failed to parse record")
.1;
let record_set = records.into_iter().next().expect("no record found").1;
record_set
.into_iter()
.next()
.unwrap()
.data()
.and_then(D::try_borrow)
D::try_borrow(record_set.into_iter().next().unwrap().data())
.expect("Not the correct record")
.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
let mut record = Record::new();
// 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
// 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"))
})?);
record.set_record_type(rtype);
record.set_dns_class(class);
})?;
// slightly annoying, need to grab the TTL, then move rdata into the record,
// then check the Type again and have custom add logic.
match rtype {
let set_ttl = match rtype {
RecordType::SOA => {
// TTL for the SOA is set internally...
// expire is for the SOA, minimum is default for records
if let RData::SOA(ref soa) = rdata {
// 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() {
*ttl = Some(soa.minimum());
} // TODO: should this only set it if it's not set?
set_ttl
} else {
let msg = format!("Invalid RData here, expected SOA: {rdata:?}");
return ParseResult::Err(ParseError::from(ParseErrorKind::Msg(msg)));
}
}
_ => {
record.set_ttl(ttl.ok_or_else(|| {
ParseError::from(ParseErrorKind::Message("record ttl not specified"))
})?);
}
}
_ => ttl.ok_or_else(|| {
ParseError::from(ParseErrorKind::Message("record ttl not specified"))
})?,
};
// TODO: validate record, e.g. the name of SRV record allows _ but others do not.
// 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
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}");
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);
} else {
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();
msg.set_message_type(MessageType::Response).add_answer(
Record::new()
.set_name(name)
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into())))
.clone(),
Record::from_rdata(
name,
86400,
RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
)
.set_dns_class(DNSClass::IN)
.clone(),
);
(
DnsRequest::new(query, DnsRequestOptions::default()),
@ -580,12 +580,10 @@ mod test {
fn axfr_response() -> Vec<Record> {
use crate::rr::rdata::*;
let origin = Name::from_ascii("example.com").unwrap();
let soa = Record::new()
.set_name(origin.clone())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
let soa = Record::from_rdata(
origin.clone(),
3600,
RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403,
@ -593,52 +591,46 @@ mod test {
3600,
1209600,
3600,
))))
.clone();
)),
)
.set_dns_class(DNSClass::IN)
.clone();
vec![
soa.clone(),
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.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.clone())
.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(),
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.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(
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone(),
86400,
RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin,
86400,
RData::AAAA(
Ipv6Addr::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
)
.into(),
)))
.clone(),
),
)
.set_dns_class(DNSClass::IN)
.clone(),
soa,
]
}

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

@ -22,7 +22,7 @@ use futures_util::{ready, stream::Stream};
use crate::{
error::{ProtoError, ProtoErrorKind, ProtoResult},
op::{Message, ResponseCode},
rr::{rdata::SOA, resource::RecordRef, RData, RecordType},
rr::{rdata::SOA, resource::RecordRef, RecordType},
};
/// A stream returning DNS responses
@ -217,12 +217,7 @@ impl DnsResponse {
// TODO: should this ensure that the SOA zone matches the Queried Zone?
self.name_servers()
.iter()
.filter_map(|record| {
record
.data()
.and_then(RData::as_soa)
.map(|soa| (record.ttl(), soa))
})
.filter_map(|record| record.data().as_soa().map(|soa| (record.ttl(), soa)))
.next()
.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,
},
rdata::opt::EdnsOption,
DNSClass, Name, RData, Record, RecordData, RecordType,
DNSClass, Name, Record, RecordData, RecordType,
},
xfer::{dns_handle::DnsHandle, DnsRequest, DnsRequestOptions, DnsResponse, FirstAnswer},
};
@ -320,7 +320,7 @@ where
let rrsigs: Vec<&RRSIG> = records
.iter()
.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(|rrsig| rrsig.type_covered() == record_type)
.collect();
@ -426,7 +426,7 @@ where
let anchored_keys: Vec<&DNSKEY> = rrset
.records
.iter()
.filter_map(|r| r.data())
.map(|r| r.data())
.filter_map(DNSKEY::try_borrow)
.filter(|dnskey| {
if handle
@ -458,12 +458,12 @@ where
.records
.iter()
.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(|&(_, key_rdata)| {
ds_records
.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
.any(|(ds_rdata, ds_name)| {
if ds_rdata.covers(&rrset.name, key_rdata).unwrap_or(false) {
@ -640,7 +640,7 @@ where
rrset
.records
.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)))
.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
@ -687,7 +687,7 @@ where
message
.answers()
.iter()
.filter_map(|r| r.data().map(|data| (r.name(), data)))
.map(|r| (r.name(), r.data()))
.filter_map(|(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 nsec
.data()
.and_then(RData::as_dnssec)
.as_dnssec()
.and_then(DNSSECRData::as_nsec)
.map_or(false, |rdata| {
// 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)
name >= nsec.name() && {
nsec.data()
.and_then(RData::as_dnssec)
.as_dnssec()
.and_then(DNSSECRData::as_nsec)
.map_or(false, |rdata| {
// 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
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
// .iter()
// .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.request_options(),
hosts,
finally_ip_addr.and_then(Record::into_data),
finally_ip_addr.map(Record::into_data),
)
.await
}

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

@ -345,7 +345,7 @@ where
(Cow::Borrowed(query.name()), INITIAL_TTL, false),
|(search_name, cname_ttl, was_cname), r| {
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
let ttl = cname_ttl.min(r.ttl());
debug_assert_eq!(r.record_type(), RecordType::CNAME);
@ -353,7 +353,7 @@ where
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
let ttl = cname_ttl.min(r.ttl());
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;
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>;
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;
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;
rdata.cloned()
}
@ -658,7 +658,6 @@ pub mod tests {
.unwrap()
.records()[0]
)
.unwrap()
.ip_addr()
.unwrap(),
Ipv4Addr::new(127, 0, 0, 1)
@ -769,11 +768,11 @@ pub mod tests {
assert_eq!(
*lookup.next().unwrap().require(Proof::Secure).unwrap(),
*a1.data().unwrap()
*a1.data()
);
assert_eq!(
*lookup.next().unwrap().require(Proof::Insecure).unwrap(),
*a2.data().unwrap()
*a2.data()
);
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 hickory_proto::rr::RData;
use proto::op::Query;
use proto::rr::{Name, RecordType};
use proto::xfer::{DnsHandle, DnsRequestOptions};
@ -619,7 +618,7 @@ mod tests {
assert_eq!(
*response.answers()[0]
.data()
.and_then(RData::as_a)
.as_a()
.expect("no a record available"),
Ipv4Addr::new(93, 184, 215, 14).into()
);
@ -643,7 +642,7 @@ mod tests {
assert_eq!(
*response.answers()[0]
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("no aaaa record available"),
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 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 super::*;
@ -269,12 +269,13 @@ mod tests {
let mut encoder = BinEncoder::new(&mut buf);
encoder.set_max_size(512);
let answer = Record::new()
.set_record_type(RecordType::A)
.set_name(Name::from_str("www.example.com.").unwrap())
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into())))
.set_dns_class(DNSClass::NONE)
.clone();
let answer = Record::from_rdata(
Name::from_str("www.example.com.").unwrap(),
0,
RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
)
.set_dns_class(DNSClass::NONE)
.clone();
let message = MessageResponse {
header: Header::new(),
@ -306,12 +307,13 @@ mod tests {
let mut encoder = BinEncoder::new(&mut buf);
encoder.set_max_size(512);
let answer = Record::new()
.set_record_type(RecordType::A)
.set_name(Name::from_str("www.example.com.").unwrap())
.set_data(Some(RData::A(Ipv4Addr::new(93, 184, 215, 14).into())))
.set_dns_class(DNSClass::NONE)
.clone();
let answer = Record::from_rdata(
Name::from_str("www.example.com.").unwrap(),
0,
RData::A(Ipv4Addr::new(93, 184, 215, 14).into()),
)
.set_dns_class(DNSClass::NONE)
.clone();
let message = MessageResponse {
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")
.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"),
}
@ -295,7 +295,7 @@ mod tests {
.expect("A record not found in authority")
.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"),
}
}

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

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

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

@ -65,7 +65,7 @@ impl RecursiveConfig {
Ok(roots_zone
.values()
.flat_map(RecordSet::records_without_rrsigs)
.filter_map(Record::data)
.map(Record::data)
.filter_map(RData::ip_addr) // we only want IPs
.map(|ip| SocketAddr::from((ip, 53))) // all the roots only have tradition DNS ports
.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);
// 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() {
// TODO: should we preserve rr_sets or not?
@ -323,7 +326,7 @@ impl SqliteAuthority {
match require.dns_class() {
DNSClass::ANY => {
if let None | Some(RData::NULL(..)) = require.data() {
if let RData::Update0(_) | RData::NULL(..) = require.data() {
match require.record_type() {
// ANY ANY empty Name is in use
RecordType::ANY => {
@ -361,7 +364,7 @@ impl SqliteAuthority {
}
}
DNSClass::NONE => {
if let None | Some(RData::NULL(..)) = require.data() {
if let RData::Update0(_) | RData::NULL(..) = require.data() {
match require.record_type() {
// NONE ANY empty Name is not in use
RecordType::ANY => {
@ -477,11 +480,10 @@ impl SqliteAuthority {
debug!("authorizing with: {:?}", sig0s);
if !sig0s.is_empty() {
let mut found_key = false;
for sig in sig0s.iter().filter_map(|sig0| {
sig0.data()
.and_then(RData::as_dnssec)
.and_then(DNSSECRData::as_sig)
}) {
for sig in sig0s
.iter()
.filter_map(|sig0| sig0.data().as_dnssec().and_then(DNSSECRData::as_sig))
{
let name = LowerName::from(sig.signer_name());
let keys = self
.lookup(&name, RecordType::KEY, LookupOptions::default())
@ -496,12 +498,7 @@ impl SqliteAuthority {
// TODO: check key usage flags and restrictions
found_key = keys
.iter()
.filter_map(|rr_set| {
rr_set
.data()
.and_then(RData::as_dnssec)
.and_then(DNSSECRData::as_key)
})
.filter_map(|rr_set| rr_set.data().as_dnssec().and_then(DNSSECRData::as_key))
.any(|key| {
key.verify_message(update_message, sig.sig(), sig)
.map(|_| {
@ -598,7 +595,7 @@ impl SqliteAuthority {
if rr.ttl() != 0 {
return Err(ResponseCode::FormErr);
}
if let None | Some(RData::NULL(..)) = rr.data() {
if let RData::Update0(_) | RData::NULL(..) = rr.data() {
()
} else {
return Err(ResponseCode::FormErr);
@ -773,7 +770,7 @@ impl SqliteAuthority {
// SOA or NS RRs will be deleted.
// 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);
info!("deleted rrset: {:?}", deleted);
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()
.expect("A record not found in authority")
.data()
.and_then(RData::as_a)
.as_a()
{
Some(ip) => assert_eq!(A4::new(127, 0, 0, 1), *ip),
_ => 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")
.data()
{
Some(RData::SOA(soa)) => {
RData::SOA(soa) => {
assert_eq!(Name::from_str("hickory-dns.org.").unwrap(), *soa.mname());
assert_eq!(
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")
.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"),
}
}
@ -104,7 +104,7 @@ pub fn test_ns_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("NS record not found in authority")
.data()
.and_then(RData::as_ns)
.as_ns()
.expect("Not an NS record");
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()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 2), *a);
}
@ -139,7 +139,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("MX record not found in authority")
.data()
.and_then(RData::as_mx)
.as_mx()
.expect("Not an MX record");
assert_eq!(
@ -154,7 +154,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("CNAME record not found")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not an CNAME record");
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()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a);
@ -170,7 +170,7 @@ pub fn test_mx<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("AAAA record not found")
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("Not an AAAA record");
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()
.expect("MX record not found in authority")
.data()
.and_then(RData::as_mx)
.as_mx()
.expect("Not an MX record");
assert_eq!(Name::from_str(".").unwrap(), *mx.exchange());
@ -224,7 +224,7 @@ pub fn test_cname<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("CNAME record not found in authority")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not an A record");
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()
.expect("CNAME record not found in authority")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not a CNAME record");
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()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
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()
.expect("CNAME record not found in authority")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not a CNAME record");
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()
.expect("CNAME record not found")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not an CNAME record");
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()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a);
}
@ -339,7 +339,7 @@ pub fn test_aname<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("ANAME record not found in authority")
.data()
.and_then(RData::as_aname)
.as_aname()
.expect("Not an ANAME record");
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
.iter()
.find(|r| r.record_type() == RecordType::A)
.and_then(Record::data)
.map(Record::data)
.and_then(RData::as_a)
.expect("A not found");
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
.iter()
.find(|r| r.record_type() == RecordType::AAAA)
.and_then(Record::data)
.map(Record::data)
.and_then(RData::as_aaaa)
.expect("AAAA not found");
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()))
.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!(Name::from_str("example.com.").unwrap(), *name);
@ -395,7 +395,7 @@ pub fn test_aname_a_lookup<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("ANAME record not found in authority")
.data()
.and_then(RData::as_aname)
.as_aname()
.expect("Not an ANAME record");
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()))
.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!(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()
.expect("ANAME record not found in authority")
.data()
.and_then(RData::as_aname)
.as_aname()
.expect("Not an ANAME record");
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()
.expect("CNAME record not found")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not an CNAME record");
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()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
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()
.expect("A record not found in authority")
.data()
.and_then(RData::as_a)
.as_a()
.expect("wrong rdata type returned"),
A4::new(127, 0, 0, 3)
);
@ -567,7 +567,7 @@ pub fn test_wildcard<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("CNAME record not found in authority")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("wrong rdata type returned")
.0,
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")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("wrong rdata type returned")
.0,
Name::from_str("www.example.com.").unwrap()
@ -635,7 +635,7 @@ pub fn test_wildcard_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("CNAME record not found in authority")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("wrong rdata type returned")
.0,
Name::from_str("www.example.com.").unwrap()
@ -646,7 +646,7 @@ pub fn test_wildcard_chain<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a);
}
@ -675,7 +675,7 @@ pub fn test_srv<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("SRV record not found in authority")
.data()
.and_then(RData::as_srv)
.as_srv()
.expect("Not an SRV record");
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()
.expect("CNAME record not found")
.data()
.and_then(RData::as_cname)
.as_cname()
.expect("Not an CNAME record");
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()
.expect("A record not found")
.data()
.and_then(RData::as_a)
.as_a()
.expect("Not an A record");
assert_eq!(A4::new(127, 0, 0, 1), *a);
@ -703,7 +703,7 @@ pub fn test_srv<A: Authority<Lookup = AuthLookup>>(authority: A) {
.next()
.expect("AAAA record not found")
.data()
.and_then(RData::as_aaaa)
.as_aaaa()
.expect("Not an AAAA record");
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);
let soa = soa_records
.first()
.unwrap()
.data()
.and_then(RData::as_soa)
.unwrap();
let soa = soa_records.first().unwrap().data().as_soa().unwrap();
assert_eq!(Name::from_str("hickory-dns.org.").unwrap(), *soa.mname());
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);
assert_eq!(
ns_records
.first()
.unwrap()
.data()
.and_then(RData::as_ns)
.unwrap()
.0,
ns_records.first().unwrap().data().as_ns().unwrap().0,
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
assert!(keys.iter().all(|key| rrsig_records
.iter()
.filter_map(|rrsig| rrsig.data())
.map(|rrsig| rrsig.data())
.filter(|rrsig| rrsig.algorithm() == key.algorithm())
.filter(|rrsig| rrsig.key_tag() == key.calculate_key_tag().unwrap())
.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")
.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"),
}
@ -93,12 +93,10 @@ pub fn test_create_multi<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
.append_name(&name)
.unwrap();
// create a record
let mut record = Record::with(name.clone(), RecordType::A, 8);
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let record = record;
let record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
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 mut rrset = RecordSet::from(record.clone());
@ -140,8 +138,7 @@ pub fn test_append<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys: &[
.unwrap();
// append a record
let mut record = Record::with(name.clone(), RecordType::A, 8);
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
// first check the must_exist option
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.
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(
record2.clone().into(),
@ -240,8 +237,7 @@ pub fn test_append_multi<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
.unwrap();
// append a record
let mut record = Record::with(name.clone(), RecordType::A, 8);
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
// next append to a non-existent RRset
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.
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();
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
let mut rrset = RecordSet::from(record2.clone());
@ -326,8 +322,7 @@ pub fn test_compare_and_swap<A: Authority<Lookup = AuthLookup>>(
.unwrap();
// create a record
let mut record = Record::with(name.clone(), RecordType::A, 8);
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let mut record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
let record = record;
let message = update_message::create(
@ -339,7 +334,7 @@ pub fn test_compare_and_swap<A: Authority<Lookup = AuthLookup>>(
let current = record;
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 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.
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 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.
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 message = update_message::compare_and_swap(
@ -499,8 +494,7 @@ pub fn test_delete_by_rdata<A: Authority<Lookup = AuthLookup>>(
.unwrap();
// append a record
let mut record1 = Record::with(name.clone(), RecordType::A, 8);
record1.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let record1 = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
// first check the must_exist option
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"));
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(
record2.clone().into(),
Name::from_str("example.com.").unwrap(),
@ -595,8 +589,8 @@ pub fn test_delete_by_rdata_multi<A: Authority<Lookup = AuthLookup>>(
// append a record
let mut rrset = RecordSet::with_ttl(name.clone(), RecordType::A, 8);
let record1 = rrset.new_record(record1.data().unwrap()).clone();
let record3 = rrset.new_record(record3.data().unwrap()).clone();
let record1 = rrset.new_record(record1.data()).clone();
let record3 = rrset.new_record(record3.data()).clone();
let rrset = rrset;
let message = update_message::append(
@ -642,8 +636,7 @@ pub fn test_delete_rrset<A: Authority<Lookup = AuthLookup>>(mut authority: A, ke
.unwrap();
// append a record
let mut record = Record::with(name.clone(), RecordType::A, 8);
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let mut record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
// first check the must_exist option
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"));
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(
record.clone().into(),
Name::from_str("example.com.").unwrap(),
@ -705,8 +698,7 @@ pub fn test_delete_all<A: Authority<Lookup = AuthLookup>>(mut authority: A, keys
.unwrap();
// append a record
let mut record = Record::with(name.clone(), RecordType::A, 8);
record.set_data(Some(RData::A(A4::new(100, 10, 100, 10))));
let mut record = Record::from_rdata(name.clone(), 8, RData::A(A4::new(100, 10, 100, 10)));
// first check the must_exist option
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"));
let mut record = record.clone();
record.set_record_type(RecordType::AAAA);
record.set_data(Some(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8))));
record.set_data(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8)));
let message = update_message::create(
record.clone().into(),
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 hickory_proto::rr::{Name, RData, RecordType};
use hickory_proto::rr::{Name, RecordType};
use hickory_resolver::name_server::TokioConnectionProvider;
use hickory_server::{
authority::{Authority, LookupObject},
@ -29,9 +29,6 @@ fn test_lookup() {
.unwrap();
let address = lookup.iter().next().expect("no addresses returned!");
let address = address
.data()
.and_then(RData::as_a)
.expect("not an A record");
let address = address.data().as_a().expect("not an A record");
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.data(),
Some(&RData::CNAME(CNAME(
Name::from_str("foo.example.com.").unwrap()
)))
&RData::CNAME(CNAME(Name::from_str("foo.example.com.").unwrap()))
);
assert!(
@ -100,9 +98,7 @@ fn test_cname_loop() {
assert_eq!(record.name(), &Name::from_str("bar.example.com.").unwrap());
assert_eq!(
record.data(),
Some(&RData::CNAME(CNAME(
Name::from_str("foo.example.com.").unwrap()
)))
&RData::CNAME(CNAME(Name::from_str("foo.example.com.").unwrap()))
);
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.data(),
Some(&RData::CNAME(CNAME(
Name::from_str("foo.example.com.").unwrap()
)))
&RData::CNAME(CNAME(Name::from_str("foo.example.com.").unwrap()))
);
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.data(),
Some(&RData::CNAME(CNAME(
Name::from_str("boz.example.com.").unwrap()
)))
&RData::CNAME(CNAME(Name::from_str("boz.example.com.").unwrap()))
);
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.data(),
Some(&RData::CNAME(CNAME(
Name::from_str("biz.example.com.").unwrap()
)))
&RData::CNAME(CNAME(Name::from_str("biz.example.com.").unwrap()))
);
let record = additionals[1];
assert_eq!(record.name(), &Name::from_str("biz.example.com.").unwrap());
assert_eq!(
record.data(),
Some(&RData::CNAME(CNAME(
Name::from_str("baz.example.com.").unwrap()
)))
&RData::CNAME(CNAME(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) {
let www = Name::from_str("www.example.com").unwrap();
let mut record = Record::new();
record.set_name(www);
record.set_record_type(RecordType::A);
record.set_data(Some(RData::A(A::from_str("127.0.0.1").unwrap())));
let mut record = Record::from_rdata(www, 0, RData::A(A::from_str("127.0.0.1").unwrap()));
// test that this message can be inserted
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();
// 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();
(record, journal)
@ -61,7 +58,7 @@ fn test_insert_and_select_record() {
.select_record(0)
.expect("persistence error")
.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);
// test another
@ -69,7 +66,7 @@ fn test_insert_and_select_record() {
.select_record(row_id + 1)
.expect("persistence error")
.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);
// check that we get nothing for id over row_id
@ -86,11 +83,11 @@ fn test_iterator() {
let mut iter = journal.iter();
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()
);
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()
);
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!(3_600_000, soa_record.ttl());
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
assert_eq!(&Name::from_str("venera.isi.edu").unwrap(), soa.mname());
assert_eq!(
@ -105,7 +105,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.unwrap();
assert_eq!(&Name::from_str("tech.").unwrap(), lowercase_record.name());
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!(
&Name::from_str("ns0.centralnic.net").unwrap(),
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!(DNSClass::IN, record.dns_class());
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);
} else {
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!(DNSClass::IN, record.dns_class());
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!(name, rdata.exchange());
} 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!(DNSClass::IN, a_record.dns_class());
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);
} else {
panic!("Not an A record!!!") // valid panic, test code
@ -221,7 +221,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.cloned()
.unwrap();
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);
} else {
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()
);
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);
} else {
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);
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());
} else {
panic!("Not a TXT record!!!") // valid panic, test code
@ -304,7 +304,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next()
.cloned()
.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);
} else {
panic!("Not a PTR record!!!") // valid panic, test code
@ -321,7 +321,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next()
.cloned()
.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.weight(), 2);
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(),
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);
} else {
panic!("Not an A record!!!") // valid panic, test code
@ -362,7 +362,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next()
.cloned()
.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.tag().is_issue());
assert!(rdata.value().is_issuer());
@ -385,7 +385,7 @@ tech. 3600 in soa ns0.centralnic.net. hostmaster.centralnic.ne
.next()
.cloned()
.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.selector(), Selector::Full);
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..
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() {
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);
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));
} else {
panic!("RData::A wasn't here");
@ -104,12 +104,11 @@ fn test_create() {
let origin = Name::from_str("example.com.").unwrap();
// create a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com.").unwrap(),
RecordType::A,
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
.create(record.clone(), origin.clone())
@ -130,7 +129,7 @@ fn test_create() {
assert_eq!(result.response_code(), ResponseCode::YXRRSet);
// 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");
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();
// create a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.net.").unwrap(),
RecordType::A,
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
.create(record.clone(), origin.clone())
@ -86,7 +85,7 @@ fn test_create() {
assert_eq!(result.response_code(), ResponseCode::YXRRSet);
// 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");
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 {
( $record:expr, $serial:expr ) => {{
let rdata = $record.data();
if let Some(RData::SOA(soa)) = rdata {
if let RData::SOA(soa) = rdata {
assert_eq!(soa.serial(), $serial);
} else {
assert!(false, "record was not a SOA");
@ -54,7 +54,7 @@ fn test_zone_transfer() {
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
} else {
panic!("First answer was not an SOA record")
@ -72,12 +72,11 @@ fn test_zone_transfer() {
RecordType::SOA
);
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.net.").unwrap(),
RecordType::A,
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");

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
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Record::from_rdata(
origin.clone(),
3600,
RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403,
@ -29,37 +27,31 @@ pub fn create_example() -> InMemoryAuthority {
3600,
1209600,
3600,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"a.iana-servers.net.",
None,
)
.unwrap()))))
.clone(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.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(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
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());
// example.com. 60 IN TXT "$Id: example.com 4415 2015-08-24 20:12:23Z davids $"
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(60)
.set_record_type(RecordType::TXT)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::TXT(TXT::new(vec![
"$Id: example.com 4415 2015-08-24 \
Record::from_rdata(
origin.clone(),
60,
RData::TXT(TXT::new(vec!["$Id: example.com 4415 2015-08-24 \
20:12:23Z davids $"
.to_string(),
]))))
.clone(),
.to_string()])),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
// example.com. 86400 IN A 93.184.215.14
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
Record::from_rdata(origin.clone(), 86400, RData::A(A::new(93, 184, 215, 14)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(93, 184, 215, 14))))
.clone(),
0,
);
// example.com. 86400 IN AAAA 2606:2800:21f:cb07:6820:80da:af6b:8b2c
records.upsert_mut(
Record::new()
.set_name(origin)
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
Record::from_rdata(
origin,
86400,
RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
@ -126,65 +112,59 @@ pub fn create_example() -> InMemoryAuthority {
// www.example.com. 86400 IN TXT "v=spf1 -all"
records.upsert_mut(
Record::new()
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::TXT)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()]))))
.clone(),
Record::from_rdata(
www_name.clone(),
86400,
RData::TXT(TXT::new(vec!["v=spf1 -all".to_string()])),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
// www.example.com. 86400 IN A 93.184.215.14
records.upsert_mut(
Record::new()
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(93, 184, 215, 14)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(93, 184, 215, 14))))
.clone(),
0,
);
// www.example.com. 86400 IN AAAA 2606:2800:21f:cb07:6820:80da:af6b:8b2c
records.upsert_mut(
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(
Record::from_rdata(
www_name.clone(),
86400,
RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
// alias 86400 IN www
records.upsert_mut(
Record::new()
.set_name(Name::from_str("alias.example.com.").unwrap())
.set_ttl(86400)
.set_record_type(RecordType::CNAME)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(www_name))))
.clone(),
Record::from_rdata(
Name::from_str("alias.example.com.").unwrap(),
86400,
RData::CNAME(CNAME(www_name)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
// alias2 86400 IN www, multiple cname chains
records.upsert_mut(
Record::new()
.set_name(Name::from_str("alias2.example.com.").unwrap())
.set_ttl(86400)
.set_record_type(RecordType::CNAME)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::CNAME(CNAME(
Name::from_str("alias.example.com.").unwrap(),
))))
.clone(),
Record::from_rdata(
Name::from_str("alias2.example.com.").unwrap(),
86400,
RData::CNAME(CNAME(Name::from_str("alias.example.com.").unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
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);
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Record::from_rdata(
origin.clone(),
3600,
RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403,
@ -34,84 +32,70 @@ pub fn create_test() -> InMemoryAuthority {
3600,
1209600,
3600,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::NS(NS(Name::parse(
"a.iana-servers.net.",
None,
)
.unwrap()))))
.clone(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.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(),
Record::from_rdata(
origin.clone(),
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(origin.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
Record::from_rdata(origin.clone(), 86400, RData::A(A::new(94, 184, 216, 34)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(origin)
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
Record::from_rdata(
origin,
86400,
RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
let www_name: Name = Name::parse("www.test.com.", None).unwrap();
records.upsert_mut(
Record::new()
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(94, 184, 216, 34)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(),
0,
);
records.upsert_mut(
Record::new()
.set_name(www_name)
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
Record::from_rdata(
www_name,
86400,
RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
@ -156,7 +140,7 @@ async fn test_catalog_lookup() {
assert!(!answers.is_empty());
assert_eq!(answers.first().unwrap().record_type(), RecordType::A);
assert_eq!(
answers.first().unwrap().data().unwrap(),
answers.first().unwrap().data(),
&RData::A(A::new(93, 184, 215, 14))
);
@ -190,7 +174,7 @@ async fn test_catalog_lookup() {
assert!(!answers.is_empty());
assert_eq!(answers.first().unwrap().record_type(), RecordType::A);
assert_eq!(
answers.first().unwrap().data().unwrap(),
answers.first().unwrap().data(),
&RData::A(A::new(94, 184, 216, 34))
);
}
@ -234,7 +218,7 @@ async fn test_catalog_lookup_soa() {
assert!(!answers.is_empty());
assert_eq!(answers.first().unwrap().record_type(), RecordType::SOA);
assert_eq!(
answers.first().unwrap().data().unwrap(),
answers.first().unwrap().data(),
&RData::SOA(SOA::new(
Name::parse("sns.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.first().unwrap().record_type(), RecordType::NS);
assert_eq!(
ns.first().unwrap().data().unwrap(),
ns.first().unwrap().data(),
&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().data().unwrap(),
ns.last().unwrap().data(),
&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.first().unwrap().record_type(), RecordType::SOA);
assert_eq!(
ns.first().unwrap().data().unwrap(),
ns.first().unwrap().data(),
&RData::SOA(SOA::new(
Name::parse("sns.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);
let origin = test.origin().clone();
let soa = Record::new()
.set_name(origin.clone().into())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
let soa = Record::from_rdata(
origin.clone().into(),
3600,
RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403,
@ -368,8 +350,10 @@ async fn test_axfr() {
3600,
1209600,
3600,
))))
.clone();
)),
)
.set_dns_class(DNSClass::IN)
.clone();
let mut catalog: Catalog = Catalog::new();
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 mut expected_set = vec![
Record::new()
.set_name(origin.clone().into())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
Record::from_rdata(
origin.clone().into(),
3600,
RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403,
@ -414,68 +396,56 @@ async fn test_axfr() {
3600,
1209600,
3600,
))))
.clone(),
Record::new()
.set_name(origin.clone().into())
.set_ttl(86400)
.set_record_type(RecordType::NS)
.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.clone().into())
.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(),
Record::new()
.set_name(origin.clone().into())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.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(
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone().into(),
86400,
RData::NS(NS(Name::parse("a.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone().into(),
86400,
RData::NS(NS(Name::parse("b.iana-servers.net.", None).unwrap())),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone().into(),
86400,
RData::A(A::new(94, 184, 216, 34)),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.clone().into(),
86400,
RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
))))
.clone(),
Record::new()
.set_name(www_name.clone())
.set_ttl(86400)
.set_record_type(RecordType::A)
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(www_name.clone(), 86400, RData::A(A::new(94, 184, 216, 34)))
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(94, 184, 216, 34))))
.clone(),
Record::new()
.set_name(www_name)
.set_ttl(86400)
.set_record_type(RecordType::AAAA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::AAAA(AAAA::new(
Record::from_rdata(
www_name,
86400,
RData::AAAA(AAAA::new(
0x2606, 0x2800, 0x21f, 0xcb07, 0x6820, 0x80da, 0xaf6b, 0x8b2c,
))))
.clone(),
Record::new()
.set_name(origin.into())
.set_ttl(3600)
.set_record_type(RecordType::SOA)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::SOA(SOA::new(
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
Record::from_rdata(
origin.into(),
3600,
RData::SOA(SOA::new(
Name::parse("sns.dns.icann.org.", None).unwrap(),
Name::parse("noc.dns.icann.org.", None).unwrap(),
2015082403,
@ -483,8 +453,10 @@ async fn test_axfr() {
3600,
1209600,
3600,
))))
.clone(),
)),
)
.set_dns_class(DNSClass::IN)
.clone(),
];
expected_set.sort();
@ -567,7 +539,7 @@ async fn test_cname_additionals() {
assert_eq!(answers.len(), 1);
assert_eq!(answers.first().unwrap().record_type(), RecordType::CNAME);
assert_eq!(
answers.first().unwrap().data().unwrap(),
answers.first().unwrap().data(),
&RData::CNAME(CNAME(Name::from_str("www.example.com.").unwrap()))
);
@ -575,7 +547,7 @@ async fn test_cname_additionals() {
assert!(!additionals.is_empty());
assert_eq!(additionals.first().unwrap().record_type(), RecordType::A);
assert_eq!(
additionals.first().unwrap().data().unwrap(),
additionals.first().unwrap().data(),
&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.first().unwrap().record_type(), RecordType::CNAME);
assert_eq!(
answers.first().unwrap().data().unwrap(),
answers.first().unwrap().data(),
&RData::CNAME(CNAME(Name::from_str("alias.example.com.").unwrap()))
);
@ -626,7 +598,7 @@ async fn test_multiple_cname_additionals() {
RecordType::CNAME
);
assert_eq!(
additionals.first().unwrap().data().unwrap(),
additionals.first().unwrap().data(),
&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_eq!(additionals.last().unwrap().record_type(), RecordType::A);
assert_eq!(
additionals.last().unwrap().data().unwrap(),
additionals.last().unwrap().data(),
&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.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))
} else {
panic!();
@ -250,7 +250,7 @@ fn test_query_edns(client: &mut AsyncClient) -> impl Future<Output = ()> {
.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))
} else {
panic!();
@ -315,12 +315,11 @@ async fn create_sig0_ready_client() -> (
let signer = SigSigner::sig0(sig0_key.clone(), key, trusted_name.clone());
// insert the KEY for the trusted.example.com
let mut auth_key = Record::with(
let auth_key = Record::from_rdata(
trusted_name,
RecordType::KEY,
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);
// setup the catalog
@ -344,13 +343,11 @@ fn test_create() {
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut record = Record::with(
let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
.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.
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
.block_on(client.create(record, origin))
@ -392,16 +389,15 @@ fn test_create_multi() {
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut record = Record::with(
let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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 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 mut rrset = RecordSet::from(record.clone());
@ -434,7 +430,7 @@ fn test_create_multi() {
// will fail if already set and not the same value.
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
.block_on(client.create(record, origin))
@ -450,13 +446,11 @@ fn test_append() {
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = io_loop
@ -484,7 +478,7 @@ fn test_append() {
// will fail if already set and not the same value.
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 result = io_loop
@ -530,12 +524,11 @@ fn test_append_multi() {
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = io_loop
@ -563,9 +556,9 @@ fn test_append_multi() {
// will fail if already set and not the same value.
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();
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
let mut rrset = RecordSet::from(record2.clone());
@ -616,13 +609,11 @@ fn test_compare_and_swap() {
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut record = Record::with(
let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
.block_on(client.create(record.clone(), origin.clone()))
@ -631,7 +622,7 @@ fn test_compare_and_swap() {
let current = record;
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 result = io_loop
@ -649,7 +640,7 @@ fn test_compare_and_swap() {
// check the it fails if tried again.
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 result = io_loop
@ -715,7 +706,7 @@ fn test_compare_and_swap_multi() {
// check the it fails if tried again.
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 result = io_loop
@ -740,12 +731,11 @@ fn test_delete_by_rdata() {
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record1 = Record::with(
let record1 = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = io_loop
@ -760,7 +750,7 @@ fn test_delete_by_rdata() {
assert_eq!(result.response_code(), ResponseCode::NoError);
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
.block_on(client.append(record2.clone(), origin.clone(), true))
.expect("create failed");
@ -831,8 +821,8 @@ fn test_delete_by_rdata_multi() {
Duration::minutes(5).whole_seconds() as u32,
);
let record1 = rrset.new_record(record1.data().unwrap()).clone();
let record3 = rrset.new_record(record3.data().unwrap()).clone();
let record1 = rrset.new_record(record1.data()).clone();
let record3 = rrset.new_record(record3.data()).clone();
let rrset = rrset;
let result = io_loop
@ -869,12 +859,11 @@ fn test_delete_rrset() {
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = io_loop
@ -888,7 +877,7 @@ fn test_delete_rrset() {
.expect("create failed");
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
.block_on(client.append(record.clone(), origin.clone(), true))
.expect("create failed");
@ -921,12 +910,11 @@ fn test_delete_all() {
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = io_loop
@ -940,8 +928,7 @@ fn test_delete_all() {
.expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_record_type(RecordType::AAAA);
record.set_data(Some(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8))));
record.set_data(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8)));
let result = io_loop
.block_on(client.create(record.clone(), origin.clone()))
.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.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))
} else {
panic!();
@ -183,7 +183,7 @@ where
&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))
} else {
panic!();
@ -242,7 +242,7 @@ where
assert_eq!(record.record_type(), RecordType::A);
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))
} else {
panic!();
@ -462,19 +462,18 @@ fn create_sig0_ready_client(mut catalog: Catalog) -> (SyncClient<TestClientConne
);
// 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(),
RecordType::KEY,
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);
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);
// create a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
.create(record.clone(), origin.clone())
@ -516,7 +514,7 @@ fn test_create() {
assert_eq!(result.response_code(), ResponseCode::YXRRSet);
// 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");
assert_eq!(result.response_code(), ResponseCode::YXRRSet);
@ -529,12 +527,11 @@ fn test_append() {
let (client, origin) = create_sig0_ready_client(catalog);
// append a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = client
@ -557,7 +554,7 @@ fn test_append() {
assert_eq!(result.answers()[0], record);
// 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
.append(record.clone(), origin.clone(), true)
@ -573,7 +570,7 @@ fn test_append() {
assert!(result
.answers()
.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)
} else {
false
@ -581,7 +578,7 @@ fn test_append() {
assert!(result
.answers()
.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)
} else {
false
@ -607,12 +604,11 @@ fn test_compare_and_swap() {
let (client, origin) = create_sig0_ready_client(catalog);
// create a record
let mut record = Record::with(
let record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
.create(record.clone(), origin.clone())
@ -621,7 +617,7 @@ fn test_compare_and_swap() {
let current = record;
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
.compare_and_swap(current.clone(), new.clone(), origin.clone())
@ -636,14 +632,14 @@ fn test_compare_and_swap() {
assert!(result
.answers()
.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)
} else {
false
}));
// 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
.compare_and_swap(current, new.clone(), origin)
@ -658,7 +654,7 @@ fn test_compare_and_swap() {
assert!(result
.answers()
.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)
} else {
false
@ -672,12 +668,11 @@ fn test_delete_by_rdata() {
let (client, origin) = create_sig0_ready_client(catalog);
// append a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = client
@ -691,7 +686,7 @@ fn test_delete_by_rdata() {
.expect("create failed");
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
.append(record.clone(), origin.clone(), true)
.expect("create failed");
@ -711,7 +706,7 @@ fn test_delete_by_rdata() {
assert!(result
.answers()
.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)
} else {
false
@ -725,12 +720,11 @@ fn test_delete_rrset() {
let (client, origin) = create_sig0_ready_client(catalog);
// append a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = client
@ -744,7 +738,7 @@ fn test_delete_rrset() {
.expect("create failed");
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
.append(record.clone(), origin.clone(), true)
.expect("create failed");
@ -772,12 +766,11 @@ fn test_delete_all() {
let (client, origin) = create_sig0_ready_client(catalog);
// append a record
let mut record = Record::with(
let mut record = Record::from_rdata(
Name::from_str("new.example.com").unwrap(),
RecordType::A,
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
let result = client
@ -791,8 +784,7 @@ fn test_delete_all() {
.expect("create failed");
assert_eq!(result.response_code(), ResponseCode::NoError);
record.set_record_type(RecordType::AAAA);
record.set_data(Some(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8))));
record.set_data(RData::AAAA(AAAA::new(1, 2, 3, 4, 5, 6, 7, 8)));
let result = client
.create(record.clone(), origin.clone())
.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.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))
} else {
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 {
let mut authority = create_example();
authority.upsert_mut(
Record::new()
.set_name(Name::from_str("1.2.3.4.example.com.").unwrap())
.set_ttl(86400)
.set_record_type(RecordType::A)
.set_dns_class(DNSClass::IN)
.set_data(Some(RData::A(A::new(198, 51, 100, 35))))
.clone(),
Record::from_rdata(
Name::from_str("1.2.3.4.example.com.").unwrap(),
86400,
RData::A(A::new(198, 51, 100, 35)),
)
.set_dns_class(DNSClass::IN)
.clone(),
0,
);
@ -261,7 +261,7 @@ fn test_cname_lookup_preserve() {
let lookup = io_loop.block_on(lookup).unwrap();
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)));
}
@ -341,7 +341,7 @@ fn test_chained_cname_lookup_preserve() {
let lookup = io_loop.block_on(lookup).unwrap();
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)));
}

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