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

Prepare 0.24 release with branding change to Hickory DNS (#2054)

Browse Source 
* update all READMEs with notices about the name change

* update changelog for 0.24

* bump crate versions to 0.24

* update version notice information

* update readmes to back reference trust-dns

* rename all crates to hickory counterparts

* replace all Trust-DNS references in code and comments with Hickory DNS

* rename all Trust-DNS references to Hickory DNS in non-code

* rename all trust-dns-resolver references to hickory-resolver

* rename all trust-dns-client references to hickory-client

* rename all trust-dns-proto references to hickory-proto

* rename all trust-dns-server references to hickory-server

* rename all trust-dns-compatibility references to hickory-compatability

* rename all trust-dns-integration references to hickory-integration

* rename all trust-dns-util references to hickory-util

* Update MIT licenses to reference Hickory DNS

* update all trust-dns references to hickory-dns

* update all bluejekyll github references to hickorydns org

* Update name in Changelog

* make sure hickory-dns logs during tests

* add changelogs for recent main additions

* fix references to trust-dns and hickory in architecture

* update a few trust-dns references in READMEs

* fixup some dangling trust_dns references

* replace fka with formerly in change log

* replace all hickoydns org references to hickory-dns

* replace all http links with https

* update logos

* update hickorydns to hickory-dns for all other org references

* fix Notices of Trust-DNS to Hickory in each Readme
This commit is contained in:
Benjamin Fry
2023-10-13 21:39:28 -04:00
committed by GitHub
parent dac1009503
commit 408d0baca0
369 changed files with 2241 additions and 1905 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
tests/compatibility-tests/Cargo.toml
View File

@@ -1,15 +1,15 @@
[package]
name = "trust-dns-compatibility"
name = "hickory-compatibility"
publish = false
# A short blurb about the package. This is not rendered in any format when
# uploaded to crates.io (aka this is not markdown)
description = """
Trust-DNS compatability testing library.
Hickory DNS compatability testing library.
"""
# These URLs point to more information about the repository
documentation = "https://docs.rs/trust-dns"
documentation = "https://docs.rs/hickory-dns"
# This points to a file in the repository (relative to this Cargo.toml). The
# contents of this file are stored and indexed in the registry.
@@ -26,18 +26,18 @@ categories.workspace = true
license.workspace = true
[badges]
#github-actions = { repository = "bluejekyll/trust-dns", branch = "main", workflow = "test" }
codecov = { repository = "bluejekyll/trust-dns", branch = "main", service = "github" }
#github-actions = { repository = "bluejekyll/hickory", branch = "main", workflow = "test" }
codecov = { repository = "hickory-dns/hickory-dns", branch = "main", service = "github" }
maintenance = { status = "actively-developed" }
[features]
default = ["none"]
none = []
bind = []
trust_dns_client = []
hickory_client = []
[lib]
name = "trust_dns_compatibility"
name = "hickory_compatibility"
path = "src/lib.rs"
[dependencies]
@@ -48,4 +48,4 @@ rand.workspace = true
futures.workspace = true
openssl = { workspace = true, features = ["v102", "v110"] }
time.workspace = true
trust-dns-client= { workspace = true, features = ["dnssec-openssl"] }
hickory-client = { workspace = true, features = ["dnssec-openssl"] }

6
tests/compatibility-tests/src/bind.rs
View File

@@ -1,8 +1,8 @@
// Copyright 2015-2017 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
use std::env;
@@ -38,7 +38,7 @@ pub fn named_process() -> (NamedProcess, u16) {
.arg("../../tests/compatibility-tests/tests/conf/bind-example.conf")
//.arg("-d").arg("0") // uncomment for debugging information
.arg("-D")
.arg("Trust-DNS compatibility")
.arg("Hickory DNS compatibility")
.arg("-g")
.arg("-p")
.arg(&format!("{test_port}"))

4
tests/compatibility-tests/src/lib.rs
View File

@@ -2,8 +2,8 @@
// Copyright 2017 Google LLC.
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
#![allow(dead_code)]

6
tests/compatibility-tests/tests/conf/bind-example.com.zone
View File

@@ -1,11 +1,11 @@
; replace the trust-dns.org with your own name
@ 86400 IN SOA trust-dns.org. root.trust-dns.org. (
; replace the hickory-dns.org with your own name
@ 86400 IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.
www A 127.0.0.1
AAAA ::1

4
tests/compatibility-tests/tests/conf/bind-example.conf
View File

@@ -1,6 +1,6 @@
/*
Trust-DNS bench setup:
this is meant to mimic the trust-dns-server config
Hickory DNS bench setup:
this is meant to mimic the hickory-server config
which is in tests/test-data/test_configs/example.toml
*/

4
tests/compatibility-tests/tests/conf/bind-example.net.zone
View File

@@ -1,11 +1,11 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
@ 86400 IN SOA example.net. root.example.net. (
20210101 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.
www1 A 127.0.0.1
AAAA ::1

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

@@ -1,8 +1,8 @@
// Copyright 2015-2017 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
use std::env;
@@ -17,25 +17,25 @@ use openssl::rsa::Rsa;
use time::Duration;
#[cfg(not(feature = "none"))]
use trust_dns_client::client::Client;
use trust_dns_client::client::{ClientConnection, SyncClient};
use hickory_client::client::Client;
use hickory_client::client::{ClientConnection, SyncClient};
#[cfg(not(feature = "none"))]
use trust_dns_client::proto::op::ResponseCode;
use trust_dns_client::proto::rr::dnssec::rdata::key::{KeyUsage, KEY};
use trust_dns_client::proto::rr::dnssec::{Algorithm, KeyPair, SigSigner};
use trust_dns_client::proto::rr::Name;
use hickory_client::proto::op::ResponseCode;
use hickory_client::proto::rr::dnssec::rdata::key::{KeyUsage, KEY};
use hickory_client::proto::rr::dnssec::{Algorithm, KeyPair, SigSigner};
use hickory_client::proto::rr::Name;
#[cfg(not(feature = "none"))]
use trust_dns_client::proto::rr::{DNSClass, RData, Record, RecordType};
use hickory_client::proto::rr::{DNSClass, RData, Record, RecordType};
#[cfg(not(feature = "none"))]
use trust_dns_client::udp::UdpClientConnection;
use hickory_client::udp::UdpClientConnection;
#[cfg(not(feature = "none"))]
use trust_dns_compatibility::named_process;
use hickory_compatibility::named_process;
#[cfg(not(feature = "none"))]
#[test]
#[allow(unused)]
fn test_get() {
use trust_dns_client::rr::rdata::A;
use hickory_client::rr::rdata::A;
let (process, port) = named_process();
let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), port);
@@ -94,7 +94,7 @@ where
#[test]
#[allow(unused)]
fn test_create() {
use trust_dns_client::rr::rdata::A;
use hickory_client::rr::rdata::A;
let (process, port) = named_process();
let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), port);

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

@@ -1,8 +1,8 @@
// Copyright 2015-2017 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
#![allow(unused_imports)]
@@ -15,16 +15,16 @@ use std::str::FromStr;
use time::Duration;
use trust_dns_client::client::Client;
use trust_dns_client::client::{ClientConnection, SyncClient};
use trust_dns_client::proto::op::ResponseCode;
use trust_dns_client::proto::rr::dnssec::rdata::tsig::TsigAlgorithm;
use trust_dns_client::proto::rr::dnssec::tsig::TSigner;
use trust_dns_client::proto::rr::Name;
use trust_dns_client::proto::rr::{RData, Record, RecordType};
use trust_dns_client::tcp::TcpClientConnection;
use trust_dns_client::udp::UdpClientConnection;
use trust_dns_compatibility::named_process;
use hickory_client::client::Client;
use hickory_client::client::{ClientConnection, SyncClient};
use hickory_client::proto::op::ResponseCode;
use hickory_client::proto::rr::dnssec::rdata::tsig::TsigAlgorithm;
use hickory_client::proto::rr::dnssec::tsig::TSigner;
use hickory_client::proto::rr::Name;
use hickory_client::proto::rr::{RData, Record, RecordType};
use hickory_client::tcp::TcpClientConnection;
use hickory_client::udp::UdpClientConnection;
use hickory_compatibility::named_process;
#[allow(dead_code)]
pub fn create_tsig_ready_client<CC>(conn: CC) -> SyncClient<CC>
@@ -50,7 +50,7 @@ where
#[cfg(not(feature = "none"))]
#[test]
fn test_create() {
use trust_dns_client::rr::rdata::A;
use hickory_client::rr::rdata::A;
let (_process, port) = named_process();
let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), port);

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

@@ -1,8 +1,8 @@
// Copyright 2021 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
#[cfg(not(feature = "none"))]
@@ -14,13 +14,13 @@ use std::str::FromStr;
use time::Duration;
#[cfg(not(feature = "none"))]
use trust_dns_client::client::{Client, SyncClient};
use hickory_client::client::{Client, SyncClient};
#[cfg(not(feature = "none"))]
use trust_dns_client::rr::{Name, RData, Record, RecordType};
use hickory_client::rr::{Name, RData, Record, RecordType};
#[cfg(not(feature = "none"))]
use trust_dns_client::tcp::TcpClientConnection;
use hickory_client::tcp::TcpClientConnection;
#[cfg(not(feature = "none"))]
use trust_dns_compatibility::named_process;
use hickory_compatibility::named_process;
#[allow(unused)]
macro_rules! assert_serial {
@@ -38,7 +38,7 @@ macro_rules! assert_serial {
#[test]
#[allow(unused)]
fn test_zone_transfer() {
use trust_dns_client::rr::rdata::A;
use hickory_client::rr::rdata::A;
let (process, port) = named_process();
let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), port);

94
tests/integration-tests/Cargo.toml
View File

@@ -1,15 +1,15 @@
[package]
name = "trust-dns-integration"
name = "hickory-integration"
publish = false
# A short blurb about the package. This is not rendered in any format when
# uploaded to crates.io (aka this is not markdown)
description = """
Trust-DNS integration testing library.
Hickory DNS integration testing library.
"""
# These URLs point to more information about the repository
documentation = "https://docs.rs/trust-dns"
documentation = "https://docs.rs/hickory-dns"
# This points to a file in the repository (relative to this Cargo.toml). The
# contents of this file are stored and indexed in the registry.
@@ -26,44 +26,74 @@ categories.workspace = true
license.workspace = true
[badges]
#github-actions = { repository = "bluejekyll/trust-dns", branch = "main", workflow = "test" }
codecov = { repository = "bluejekyll/trust-dns", branch = "main", service = "github" }
#github-actions = { repository = "bluejekyll/hickory", branch = "main", workflow = "test" }
codecov = { repository = "hickory-dns/hickory-dns", branch = "main", service = "github" }
maintenance = { status = "actively-developed" }
[lib]
name = "trust_dns_integration"
name = "hickory_integration"
path = "src/lib.rs"
[features]
dnssec-openssl = ["dnssec",
"trust-dns-resolver/dnssec-openssl",
"trust-dns-server/dnssec-openssl",
"trust-dns-client/dnssec-openssl",
"trust-dns-proto/dnssec-openssl"]
dnssec-openssl = [
"dnssec",
"hickory-resolver/dnssec-openssl",
"hickory-server/dnssec-openssl",
"hickory-client/dnssec-openssl",
"hickory-proto/dnssec-openssl",
]
# TODO: dnssec-openssl is enabled for RSA support, we should add testing support for just the Ring toolchain
dnssec-ring = ["dnssec",
"trust-dns-resolver/dnssec-ring",
"trust-dns-server/dnssec-ring",
"trust-dns-client/dnssec-ring", "trust-dns-client/dnssec-openssl",
"trust-dns-proto/dnssec-ring"]
dnssec-ring = [
"dnssec",
"hickory-resolver/dnssec-ring",
"hickory-server/dnssec-ring",
"hickory-client/dnssec-ring",
"hickory-client/dnssec-openssl",
"hickory-proto/dnssec-ring",
]
dnssec = ["dep:openssl"]
# enables experimental the mDNS (multicast) feature
# TODO: revisit how mdns is implemented in resolver
# mdns = ["trust-dns-client/mdns", "trust-dns-proto/mdns", "trust-dns-resolver/mdns"]
# mdns = ["hickory-client/mdns", "hickory-proto/mdns", "hickory-resolver/mdns"]
dns-over-https-rustls = ["trust-dns-client/dns-over-https-rustls", "trust-dns-resolver/dns-over-https-rustls", "dns-over-https", "dep:rustls", "dep:webpki-roots"]
dns-over-https = ["trust-dns-proto/dns-over-https"]
dns-over-quic = ["dns-over-rustls", "trust-dns-proto/dns-over-quic", "trust-dns-resolver/dns-over-quic"]
dns-over-h3 = ["dns-over-rustls", "trust-dns-proto/dns-over-h3", "trust-dns-resolver/dns-over-h3"]
dns-over-https-rustls = [
"hickory-client/dns-over-https-rustls",
"hickory-resolver/dns-over-https-rustls",
"dns-over-https",
"dep:rustls",
"dep:webpki-roots",
]
dns-over-https = ["hickory-proto/dns-over-https"]
dns-over-quic = [
"dns-over-rustls",
"hickory-proto/dns-over-quic",
"hickory-resolver/dns-over-quic",
]
dns-over-h3 = [
"dns-over-rustls",
"hickory-proto/dns-over-h3",
"hickory-resolver/dns-over-h3",
]
# TODO: need to make server support rustls and native-tls
# dns-over-native-tls = ["dns-over-tls", "trust-dns-resolver/dns-over-native-tls", "trust-dns-server/dns-over-native-tls"]
dns-over-openssl = ["dns-over-tls", "trust-dns-proto/dns-over-openssl", "trust-dns-resolver/dns-over-openssl", "trust-dns-server/dns-over-openssl"]
dns-over-rustls = ["dns-over-tls", "trust-dns-proto/dns-over-rustls", "trust-dns-resolver/dns-over-rustls", "trust-dns-server/dns-over-rustls", "dep:rustls"]
# dns-over-native-tls = ["dns-over-tls", "hickory-resolver/dns-over-native-tls", "hickory-server/dns-over-native-tls"]
dns-over-openssl = [
"dns-over-tls",
"hickory-proto/dns-over-openssl",
"hickory-resolver/dns-over-openssl",
"hickory-server/dns-over-openssl",
]
dns-over-rustls = [
"dns-over-tls",
"hickory-proto/dns-over-rustls",
"hickory-resolver/dns-over-rustls",
"hickory-server/dns-over-rustls",
"dep:rustls",
]
dns-over-tls = []
sqlite = ["rusqlite", "trust-dns-server/sqlite"]
sqlite = ["rusqlite", "hickory-server/sqlite"]
[dependencies]
async-trait.workspace = true
@@ -76,13 +106,17 @@ rustls = { workspace = true, optional = true }
time.workspace = true
tokio = { workspace = true, features = ["time", "rt"] }
tracing.workspace = true
trust-dns-client.workspace = true
trust-dns-proto = { workspace = true, features = ["testing"] }
trust-dns-resolver = { workspace = true, features = ["tokio-runtime"] }
trust-dns-server = { workspace = true, features = ["testing"] }
hickory-client.workspace = true
hickory-proto = { workspace = true, features = ["testing"] }
hickory-resolver = { workspace = true, features = ["tokio-runtime"] }
hickory-server = { workspace = true, features = ["testing"] }
webpki-roots = { workspace = true, optional = true }
[dev-dependencies]
futures = { workspace = true, features = ["thread-pool"] }
tokio = { workspace = true, features = ["macros", "rt"] }
tracing-subscriber = { workspace = true, features = ["std", "fmt", "env-filter"] }
tracing-subscriber = { workspace = true, features = [
"std",
"fmt",
"env-filter",
] }

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

@@ -1,15 +1,15 @@
use std::str::FromStr;
use trust_dns_proto::rr::*;
use hickory_proto::rr::*;
use trust_dns_server::authority::ZoneType;
use trust_dns_server::store::in_memory::InMemoryAuthority;
use hickory_server::authority::ZoneType;
use hickory_server::store::in_memory::InMemoryAuthority;
#[allow(unused)]
#[allow(clippy::unreadable_literal)]
pub fn create_example() -> InMemoryAuthority {
use hickory_client::rr::rdata::*;
use std::net::*;
use trust_dns_client::rr::rdata::*;
let origin: Name = Name::parse("example.com.", None).unwrap();
let mut records = InMemoryAuthority::empty(origin.clone(), ZoneType::Primary, false);
@@ -200,10 +200,10 @@ pub fn create_example() -> InMemoryAuthority {
#[cfg(feature = "dnssec")]
#[allow(unused)]
pub fn create_secure_example() -> InMemoryAuthority {
use hickory_proto::rr::dnssec::*;
use hickory_server::authority::{Authority, DnssecAuthority};
use openssl::rsa::Rsa;
use time::Duration;
use trust_dns_proto::rr::dnssec::*;
use trust_dns_server::authority::{Authority, DnssecAuthority};
let mut authority = create_example();
let rsa = Rsa::generate(2048).unwrap();

6
tests/integration-tests/src/lib.rs
View File

@@ -19,19 +19,19 @@ use futures::{
};
use tokio::time::{Duration, Instant, Sleep};
use trust_dns_client::{
use hickory_client::{
client::{ClientConnection, Signer},
error::ClientResult,
op::*,
serialize::binary::*,
};
use trust_dns_proto::{
use hickory_proto::{
error::ProtoError,
rr::Record,
xfer::{DnsClientStream, DnsMultiplexer, DnsMultiplexerConnect, SerialMessage, StreamReceiver},
BufDnsStreamHandle, TokioTime,
};
use trust_dns_server::{
use hickory_server::{
authority::{Catalog, MessageRequest, MessageResponse},
server::{Protocol, Request, RequestHandler, ResponseHandler, ResponseInfo},
};

30
tests/integration-tests/src/mock_client.rs
View File

@@ -1,8 +1,8 @@
// Copyright 2015-2023 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
use std::error::Error;
@@ -15,20 +15,20 @@ use std::task::{Context, Poll};
use futures::stream::{once, Stream};
use futures::{future, AsyncRead, AsyncWrite, Future};
use trust_dns_client::op::{Message, Query};
use trust_dns_client::rr::rdata::{CNAME, SOA};
use trust_dns_client::rr::{Name, RData, Record};
use trust_dns_proto::error::ProtoError;
use trust_dns_proto::tcp::DnsTcpStream;
use trust_dns_proto::udp::DnsUdpSocket;
use hickory_client::op::{Message, Query};
use hickory_client::rr::rdata::{CNAME, SOA};
use hickory_client::rr::{Name, RData, Record};
use hickory_proto::error::ProtoError;
use hickory_proto::tcp::DnsTcpStream;
use hickory_proto::udp::DnsUdpSocket;
#[cfg(any(feature = "dns-over-quic", feature = "dns-over-h3"))]
use trust_dns_proto::udp::QuicLocalAddr;
use trust_dns_proto::xfer::{DnsHandle, DnsRequest, DnsResponse};
use trust_dns_proto::TokioTime;
use trust_dns_resolver::config::{NameServerConfig, ResolverOpts};
use trust_dns_resolver::error::ResolveError;
use trust_dns_resolver::name_server::{ConnectionProvider, RuntimeProvider};
use trust_dns_resolver::TokioHandle;
use hickory_proto::udp::QuicLocalAddr;
use hickory_proto::xfer::{DnsHandle, DnsRequest, DnsResponse};
use hickory_proto::TokioTime;
use hickory_resolver::config::{NameServerConfig, ResolverOpts};
use hickory_resolver::error::ResolveError;
use hickory_resolver::name_server::{ConnectionProvider, RuntimeProvider};
use hickory_resolver::TokioHandle;
pub struct TcpPlaceholder;

20
tests/integration-tests/src/tls_client_connection.rs
View File

@@ -1,12 +1,12 @@
// Copyright 2015-2021 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// https://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// https://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
//! TLS based DNS client connection for Client impls
//! TODO: This modules was moved from trust-dns-rustls, it really doesn't need to exist if tests are refactored...
//! TODO: This modules was moved from hickory-dns-rustls, it really doesn't need to exist if tests are refactored...
use std::marker::PhantomData;
use std::net::SocketAddr;
@@ -16,16 +16,16 @@ use std::sync::Arc;
use futures::Future;
use rustls::ClientConfig;
use trust_dns_client::client::ClientConnection;
use trust_dns_client::client::Signer;
use trust_dns_proto::error::ProtoError;
use trust_dns_proto::rustls::{tls_client_connect_with_bind_addr, TlsClientStream};
use trust_dns_proto::tcp::Connect;
use trust_dns_proto::xfer::{DnsMultiplexer, DnsMultiplexerConnect};
use hickory_client::client::ClientConnection;
use hickory_client::client::Signer;
use hickory_proto::error::ProtoError;
use hickory_proto::rustls::{tls_client_connect_with_bind_addr, TlsClientStream};
use hickory_proto::tcp::Connect;
use hickory_proto::xfer::{DnsMultiplexer, DnsMultiplexerConnect};
/// Tls client connection
///
/// Use with `trust_dns_client::client::Client` impls
/// Use with `hickory_client::client::Client` impls
pub struct TlsClientConnection<T> {
name_server: SocketAddr,
bind_addr: Option<SocketAddr>,

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

@@ -1,18 +1,18 @@
use std::{str::FromStr, sync::Arc};
use trust_dns_client::{
use hickory_client::{
op::*,
rr::{rdata::*, *},
serialize::binary::{BinDecodable, BinEncodable},
};
use trust_dns_server::{
use hickory_server::{
authority::{Authority, Catalog, MessageRequest, ZoneType},
server::{Protocol, Request},
store::in_memory::InMemoryAuthority,
};
use trust_dns_integration::{example_authority::create_example, *};
use hickory_integration::{example_authority::create_example, *};
#[allow(clippy::unreadable_literal)]
pub fn create_test() -> InMemoryAuthority {

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

@@ -13,8 +13,8 @@ use tokio::{
};
#[cfg(all(feature = "dnssec", feature = "sqlite"))]
use trust_dns_client::client::Signer;
use trust_dns_client::{
use hickory_client::client::Signer;
use hickory_client::{
client::{AsyncClient, ClientHandle},
error::ClientErrorKind,
op::{Edns, Message, MessageType, OpCode, Query, ResponseCode},
@@ -29,16 +29,16 @@ use trust_dns_client::{
udp::UdpClientStream,
};
#[cfg(feature = "dnssec")]
use trust_dns_proto::rr::{dnssec::SigSigner, Record};
use hickory_proto::rr::{dnssec::SigSigner, Record};
#[cfg(feature = "dnssec")]
use trust_dns_proto::xfer::{DnsExchangeBackground, DnsMultiplexer};
use hickory_proto::xfer::{DnsExchangeBackground, DnsMultiplexer};
#[cfg(all(feature = "dnssec", feature = "sqlite"))]
use trust_dns_proto::TokioTime;
use trust_dns_proto::{iocompat::AsyncIoTokioAsStd, xfer::FirstAnswer, DnsHandle};
use hickory_proto::TokioTime;
use hickory_proto::{iocompat::AsyncIoTokioAsStd, xfer::FirstAnswer, DnsHandle};
use trust_dns_server::authority::{Authority, Catalog};
use hickory_server::authority::{Authority, Catalog};
use trust_dns_integration::{
use hickory_integration::{
example_authority::create_example, NeverReturnsClientStream, TestClientStream,
};
@@ -54,7 +54,7 @@ fn test_query_nonet() {
let (stream, sender) = TestClientStream::new(Arc::new(StdMutex::new(catalog)));
let client = AsyncClient::new(stream, sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
io_loop.block_on(test_query(&mut client));
io_loop.block_on(test_query(&mut client));
@@ -67,7 +67,7 @@ fn test_query_udp_ipv4() {
let stream = UdpClientStream::<TokioUdpSocket>::new(addr);
let client = AsyncClient::connect(stream);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// TODO: timeouts on these requests so that the test doesn't hang
io_loop.block_on(test_query(&mut client));
@@ -87,7 +87,7 @@ fn test_query_udp_ipv6() {
let stream = UdpClientStream::<TokioUdpSocket>::new(addr);
let client = AsyncClient::connect(stream);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// TODO: timeouts on these requests so that the test doesn't hang
io_loop.block_on(test_query(&mut client));
@@ -102,7 +102,7 @@ fn test_query_tcp_ipv4() {
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(stream, sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// TODO: timeouts on these requests so that the test doesn't hang
io_loop.block_on(test_query(&mut client));
@@ -121,7 +121,7 @@ fn test_query_tcp_ipv6() {
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(stream, sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// TODO: timeouts on these requests so that the test doesn't hang
io_loop.block_on(test_query(&mut client));
@@ -131,8 +131,8 @@ fn test_query_tcp_ipv6() {
#[test]
#[cfg(feature = "dns-over-https-rustls")]
fn test_query_https() {
use hickory_proto::h2::HttpsClientStreamBuilder;
use rustls::{ClientConfig, OwnedTrustAnchor, RootCertStore};
use trust_dns_proto::h2::HttpsClientStreamBuilder;
const ALPN_H2: &[u8] = b"h2";
@@ -164,7 +164,7 @@ fn test_query_https() {
.build::<AsyncIoTokioAsStd<TokioTcpStream>>(addr, "cloudflare-dns.com".to_string()),
);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// TODO: timeouts on these requests so that the test doesn't hang
io_loop.block_on(test_query(&mut client));
@@ -269,7 +269,7 @@ fn test_notify() {
let (stream, sender) = TestClientStream::new(Arc::new(StdMutex::new(catalog)));
let client = AsyncClient::new(stream, sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let name = Name::from_str("ping.example.com").unwrap();
@@ -297,10 +297,10 @@ async fn create_sig0_ready_client() -> (
),
Name,
) {
use hickory_proto::rr::dnssec::rdata::DNSSECRData;
use hickory_proto::rr::dnssec::{Algorithm, KeyPair};
use hickory_server::store::sqlite::SqliteAuthority;
use openssl::rsa::Rsa;
use trust_dns_proto::rr::dnssec::rdata::DNSSECRData;
use trust_dns_proto::rr::dnssec::{Algorithm, KeyPair};
use trust_dns_server::store::sqlite::SqliteAuthority;
let authority = create_example();
let mut authority = SqliteAuthority::new(authority, true, false);
@@ -341,7 +341,7 @@ async fn create_sig0_ready_client() -> (
fn test_create() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut record = Record::with(
@@ -389,7 +389,7 @@ fn test_create() {
fn test_create_multi() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut record = Record::with(
@@ -447,7 +447,7 @@ fn test_create_multi() {
fn test_append() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
@@ -527,7 +527,7 @@ fn test_append() {
fn test_append_multi() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
@@ -613,7 +613,7 @@ fn test_append_multi() {
fn test_compare_and_swap() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut record = Record::with(
@@ -671,7 +671,7 @@ fn test_compare_and_swap() {
fn test_compare_and_swap_multi() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// create a record
let mut current = RecordSet::with_ttl(
@@ -737,7 +737,7 @@ fn test_compare_and_swap_multi() {
fn test_delete_by_rdata() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record1 = Record::with(
@@ -789,7 +789,7 @@ fn test_delete_by_rdata() {
fn test_delete_by_rdata_multi() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut rrset = RecordSet::with_ttl(
@@ -866,7 +866,7 @@ fn test_delete_by_rdata_multi() {
fn test_delete_rrset() {
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
@@ -914,11 +914,11 @@ fn test_delete_rrset() {
#[cfg(all(feature = "dnssec", feature = "sqlite"))]
#[test]
fn test_delete_all() {
use trust_dns_proto::rr::rdata::AAAA;
use hickory_proto::rr::rdata::AAAA;
let io_loop = Runtime::new().unwrap();
let ((mut client, bg), origin) = io_loop.block_on(create_sig0_ready_client());
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// append a record
let mut record = Record::with(
@@ -1000,7 +1000,7 @@ fn test_timeout_query_nonet() {
let client =
AsyncClient::with_timeout(stream, sender, std::time::Duration::from_millis(1), None);
let (client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
test_timeout_query(client, io_loop);
}
@@ -1021,7 +1021,7 @@ fn test_timeout_query_udp() {
UdpClientStream::<TokioUdpSocket>::with_timeout(addr, std::time::Duration::from_millis(1));
let client = AsyncClient::connect(stream);
let (client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
test_timeout_query(client, io_loop);
}

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

@@ -8,26 +8,26 @@ use futures::Future;
#[cfg(feature = "dnssec")]
use time::Duration;
use trust_dns_client::client::Signer;
use hickory_client::client::Signer;
#[cfg(feature = "dnssec")]
use trust_dns_client::client::SyncDnssecClient;
use hickory_client::client::SyncDnssecClient;
#[allow(deprecated)]
use trust_dns_client::client::{Client, ClientConnection, SyncClient};
use trust_dns_client::tcp::TcpClientConnection;
use trust_dns_client::udp::UdpClientConnection;
use trust_dns_client::{
use hickory_client::client::{Client, ClientConnection, SyncClient};
use hickory_client::tcp::TcpClientConnection;
use hickory_client::udp::UdpClientConnection;
use hickory_client::{
error::ClientErrorKind,
rr::rdata::opt::{EdnsCode, EdnsOption},
};
use trust_dns_integration::example_authority::create_example;
use trust_dns_integration::{NeverReturnsClientConnection, TestClientStream};
use trust_dns_proto::error::ProtoError;
use trust_dns_proto::op::*;
use hickory_integration::example_authority::create_example;
use hickory_integration::{NeverReturnsClientConnection, TestClientStream};
use hickory_proto::error::ProtoError;
use hickory_proto::op::*;
#[cfg(feature = "dnssec")]
use trust_dns_proto::rr::Record;
use trust_dns_proto::rr::{rdata::A, DNSClass, Name, RData, RecordType};
use trust_dns_proto::xfer::{DnsMultiplexer, DnsMultiplexerConnect};
use trust_dns_server::authority::{Authority, Catalog};
use hickory_proto::rr::Record;
use hickory_proto::rr::{rdata::A, DNSClass, Name, RData, RecordType};
use hickory_proto::xfer::{DnsMultiplexer, DnsMultiplexerConnect};
use hickory_server::authority::{Authority, Catalog};
pub struct TestClientConnection {
catalog: Arc<StdMutex<Catalog>>,
@@ -438,10 +438,10 @@ fn test_nsec_query_type() {
#[allow(deprecated)]
#[cfg(all(feature = "dnssec", feature = "sqlite"))]
fn create_sig0_ready_client(mut catalog: Catalog) -> (SyncClient<TestClientConnection>, Name) {
use hickory_proto::rr::dnssec::rdata::{DNSSECRData, KEY};
use hickory_proto::rr::dnssec::{Algorithm, KeyPair, Signer as SigSigner};
use hickory_server::store::sqlite::SqliteAuthority;
use openssl::rsa::Rsa;
use trust_dns_proto::rr::dnssec::rdata::{DNSSECRData, KEY};
use trust_dns_proto::rr::dnssec::{Algorithm, KeyPair, Signer as SigSigner};
use trust_dns_server::store::sqlite::SqliteAuthority;
let authority = create_example();
let mut authority = SqliteAuthority::new(authority, true, false);
@@ -766,7 +766,7 @@ fn test_delete_rrset() {
#[cfg(all(feature = "dnssec", feature = "sqlite"))]
#[test]
fn test_delete_all() {
use trust_dns_proto::rr::rdata::AAAA;
use hickory_proto::rr::rdata::AAAA;
let catalog = Catalog::new();
let (client, origin) = create_sig0_ready_client(catalog);

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

@@ -9,21 +9,21 @@ use tokio::net::TcpStream as TokioTcpStream;
use tokio::net::UdpSocket as TokioUdpSocket;
use tokio::runtime::Runtime;
use trust_dns_client::client::{AsyncClient, ClientHandle, MemoizeClientHandle};
use trust_dns_client::tcp::TcpClientStream;
use hickory_client::client::{AsyncClient, ClientHandle, MemoizeClientHandle};
use hickory_client::tcp::TcpClientStream;
use trust_dns_proto::iocompat::AsyncIoTokioAsStd;
use trust_dns_proto::op::ResponseCode;
use trust_dns_proto::rr::dnssec::TrustAnchor;
use trust_dns_proto::rr::rdata::A;
use trust_dns_proto::rr::Name;
use trust_dns_proto::rr::{DNSClass, RData, RecordType};
use trust_dns_proto::udp::{UdpClientConnect, UdpClientStream};
use trust_dns_proto::DnssecDnsHandle;
use trust_dns_server::authority::{Authority, Catalog};
use hickory_proto::iocompat::AsyncIoTokioAsStd;
use hickory_proto::op::ResponseCode;
use hickory_proto::rr::dnssec::TrustAnchor;
use hickory_proto::rr::rdata::A;
use hickory_proto::rr::Name;
use hickory_proto::rr::{DNSClass, RData, RecordType};
use hickory_proto::udp::{UdpClientConnect, UdpClientStream};
use hickory_proto::DnssecDnsHandle;
use hickory_server::authority::{Authority, Catalog};
use trust_dns_integration::example_authority::create_secure_example;
use trust_dns_integration::TestClientStream;
use hickory_integration::example_authority::create_secure_example;
use hickory_integration::TestClientStream;
#[test]
fn test_secure_query_example_nonet() {
@@ -99,7 +99,7 @@ where
assert_eq!(response.response_code(), ResponseCode::NXDomain);
}
// TODO: NSEC response code wrong in Trust-DNS? Issue #53
// TODO: NSEC response code wrong in Hickory DNS? Issue #53
// #[test]
// fn test_nsec_query_type_nonet() {
// with_nonet(test_nsec_query_type);
@@ -242,7 +242,7 @@ where
.block_on(client)
.expect("failed to create new client");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let client = MemoizeClientHandle::new(client);
let secure_client = DnssecDnsHandle::with_trust_anchor(client, trust_anchor);
@@ -278,7 +278,7 @@ where
let stream: UdpClientConnect<TokioUdpSocket> = UdpClientStream::new(addr);
let client = AsyncClient::connect(stream);
let (client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let client = MemoizeClientHandle::new(client);
let secure_client = DnssecDnsHandle::new(client);
@@ -315,7 +315,7 @@ where
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let client = MemoizeClientHandle::new(client);
let secure_client = DnssecDnsHandle::new(client);

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

@@ -6,13 +6,13 @@ use std::{
use tokio::runtime::Runtime;
use trust_dns_proto::{
use hickory_proto::{
op::{NoopMessageFinalizer, Query},
rr::{rdata::A, DNSClass, Name, RData, Record, RecordType},
xfer::{DnsExchange, DnsMultiplexer, DnsResponse},
TokioTime,
};
use trust_dns_resolver::{
use hickory_resolver::{
caching_client::CachingClient,
config::LookupIpStrategy,
error::ResolveError,
@@ -20,12 +20,12 @@ use trust_dns_resolver::{
lookup_ip::LookupIpFuture,
Hosts,
};
use trust_dns_server::{
use hickory_server::{
authority::{Authority, Catalog},
store::in_memory::InMemoryAuthority,
};
use trust_dns_integration::{example_authority::create_example, mock_client::*, TestClientStream};
use hickory_integration::{example_authority::create_example, mock_client::*, TestClientStream};
#[test]
fn test_lookup() {
@@ -39,7 +39,7 @@ fn test_lookup() {
let client = DnsExchange::connect::<_, _, TokioTime>(dns_conn);
let (client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let lookup = LookupFuture::lookup(
vec![Name::from_str("www.example.com.").unwrap()],
@@ -67,7 +67,7 @@ fn test_lookup_hosts() {
let client = DnsExchange::connect::<_, _, TokioTime>(dns_conn);
let (client, bg) = io_loop.block_on(client).expect("client connect failed");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let mut hosts = Hosts::default();
let record = Record::from_rdata(
@@ -125,7 +125,7 @@ fn test_lookup_ipv4_like() {
let client = DnsExchange::connect::<_, _, TokioTime>(dns_conn);
let (client, bg) = io_loop.block_on(client).expect("client connect failed");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let lookup = LookupIpFuture::lookup(
vec![Name::from_str("1.2.3.4.example.com.").unwrap()],
@@ -155,7 +155,7 @@ fn test_lookup_ipv4_like_fall_through() {
let client = DnsExchange::connect::<_, _, TokioTime>(dns_conn);
let (client, bg) = io_loop.block_on(client).expect("client connect failed");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
let lookup = LookupIpFuture::lookup(
vec![Name::from_str("198.51.100.35.example.com.").unwrap()],

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

@@ -11,13 +11,13 @@ use futures::{future, StreamExt};
use once_cell::sync::Lazy;
use tokio::runtime::Runtime;
use trust_dns_client::client::{AsyncClient, ClientHandle};
use trust_dns_client::multicast::MdnsQueryType;
use trust_dns_client::multicast::{MdnsClientStream, MdnsStream};
use trust_dns_client::op::Message;
use trust_dns_client::rr::{DNSClass, Name, RecordType};
use trust_dns_client::serialize::binary::BinDecodable;
use trust_dns_proto::xfer::SerialMessage;
use hickory_client::client::{AsyncClient, ClientHandle};
use hickory_client::multicast::MdnsQueryType;
use hickory_client::multicast::{MdnsClientStream, MdnsStream};
use hickory_client::op::Message;
use hickory_client::rr::{DNSClass, Name, RecordType};
use hickory_client::serialize::binary::BinDecodable;
use hickory_proto::xfer::SerialMessage;
const MDNS_PORT: u16 = 5363;
@@ -113,7 +113,7 @@ fn test_query_mdns_ipv4() {
let (stream, sender) = MdnsClientStream::new(addr, MdnsQueryType::OneShot, None, None, None);
let client = AsyncClient::new(stream, sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("failed to connect mDNS");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// A PTR request is the DNS-SD method for doing a directory listing...
let name = Name::from_ascii("_dns._udp.local.").unwrap();
@@ -137,7 +137,7 @@ fn test_query_mdns_ipv6() {
let (stream, sender) = MdnsClientStream::new(addr, MdnsQueryType::OneShot, None, None, Some(5));
let client = AsyncClient::new(stream, sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("failed to connect client");
trust_dns_proto::spawn_bg(&io_loop, bg);
hickory_proto::spawn_bg(&io_loop, bg);
// A PTR request is the DNS-SD method for doing a directory listing...
let name = Name::from_ascii("_dns._udp.local.").unwrap();

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

@@ -10,14 +10,14 @@ use std::task::Poll;
use futures::executor::block_on;
use futures::{future, Future};
use trust_dns_client::op::{Query, ResponseCode};
use trust_dns_client::rr::{Name, RecordType};
use trust_dns_integration::mock_client::*;
use trust_dns_proto::error::ProtoError;
use trust_dns_proto::xfer::{DnsHandle, DnsResponse, FirstAnswer};
use trust_dns_resolver::config::*;
use trust_dns_resolver::error::{ResolveError, ResolveErrorKind};
use trust_dns_resolver::name_server::{NameServer, NameServerPool};
use hickory_client::op::{Query, ResponseCode};
use hickory_client::rr::{Name, RecordType};
use hickory_integration::mock_client::*;
use hickory_proto::error::ProtoError;
use hickory_proto::xfer::{DnsHandle, DnsResponse, FirstAnswer};
use hickory_resolver::config::*;
use hickory_resolver::error::{ResolveError, ResolveErrorKind};
use hickory_resolver::name_server::{NameServer, NameServerPool};
const DEFAULT_SERVER_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
@@ -521,7 +521,7 @@ fn test_distrust_nx_responses() {
#[test]
fn test_user_provided_server_order() {
use trust_dns_proto::rr::Record;
use hickory_proto::rr::Record;
let mut options = ResolverOpts::default();

4
tests/integration-tests/tests/retry_dns_handle_tests.rs
View File

@@ -5,12 +5,12 @@ use std::sync::{
use futures::{executor::block_on, future, stream, Stream};
use trust_dns_proto::{
use hickory_proto::{
op::{Message, MessageType, OpCode, ResponseCode},
xfer::{DnsRequest, DnsResponse, FirstAnswer},
DnsHandle, RetryDnsHandle,
};
use trust_dns_resolver::error::ResolveError;
use hickory_resolver::error::ResolveError;
#[derive(Clone)]
struct TestClient {

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

@@ -10,24 +10,24 @@ use tokio::net::TcpListener;
use tokio::net::UdpSocket;
use tokio::runtime::Runtime;
use trust_dns_client::client::*;
use trust_dns_client::op::*;
use trust_dns_client::rr::*;
use trust_dns_client::tcp::TcpClientConnection;
use trust_dns_client::udp::UdpClientConnection;
use trust_dns_proto::error::ProtoError;
use trust_dns_proto::rr::rdata::A;
use trust_dns_proto::xfer::DnsRequestSender;
use hickory_client::client::*;
use hickory_client::op::*;
use hickory_client::rr::*;
use hickory_client::tcp::TcpClientConnection;
use hickory_client::udp::UdpClientConnection;
use hickory_proto::error::ProtoError;
use hickory_proto::rr::rdata::A;
use hickory_proto::xfer::DnsRequestSender;
use trust_dns_server::authority::{Authority, Catalog};
use trust_dns_server::ServerFuture;
use hickory_server::authority::{Authority, Catalog};
use hickory_server::ServerFuture;
use trust_dns_integration::example_authority::create_example;
use hickory_integration::example_authority::create_example;
#[cfg(feature = "dns-over-rustls")]
use hickory_integration::tls_client_connection::TlsClientConnection;
#[cfg(feature = "dns-over-rustls")]
use rustls::RootCertStore;
#[cfg(feature = "dns-over-rustls")]
use trust_dns_integration::tls_client_connection::TlsClientConnection;
#[test]
#[allow(clippy::uninlined_format_args)]
@@ -234,9 +234,9 @@ fn read_file(path: &str) -> Vec<u8> {
#[test]
#[allow(clippy::uninlined_format_args)]
fn test_server_www_tls() {
use hickory_proto::rustls::tls_server;
use std::env;
use std::path::Path;
use trust_dns_proto::rustls::tls_server;
let dns_name = "ns.example.com";
@@ -303,7 +303,7 @@ fn lazy_tls_client(
ipaddr: SocketAddr,
dns_name: String,
cert_chain: Vec<rustls::Certificate>,
) -> TlsClientConnection<trust_dns_proto::iocompat::AsyncIoTokioAsStd<tokio::net::TcpStream>> {
) -> TlsClientConnection<hickory_proto::iocompat::AsyncIoTokioAsStd<tokio::net::TcpStream>> {
use rustls::ClientConfig;
let mut root_store = RootCertStore::empty();
@@ -409,8 +409,8 @@ fn server_thread_tls(
cert_chain: (Vec<rustls::Certificate>, rustls::PrivateKey),
io_loop: Runtime,
) {
use hickory_server::config::dnssec::{self, CertType, PrivateKeyType, TlsCertConfig};
use std::path::Path;
use trust_dns_server::config::dnssec::{self, CertType, PrivateKeyType, TlsCertConfig};
let catalog = new_catalog();
let mut server = ServerFuture::new(catalog);

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

@@ -4,28 +4,28 @@ use std::str::FromStr;
use rusqlite::*;
use trust_dns_proto::op::*;
use trust_dns_proto::rr::dnssec::*;
use trust_dns_proto::rr::rdata::*;
use trust_dns_proto::rr::*;
use hickory_proto::op::*;
use hickory_proto::rr::dnssec::*;
use hickory_proto::rr::rdata::*;
use hickory_proto::rr::*;
use trust_dns_server::authority::LookupOptions;
use trust_dns_server::authority::{Authority, ZoneType};
use trust_dns_server::server::Protocol;
use trust_dns_server::server::RequestInfo;
use trust_dns_server::store::in_memory::InMemoryAuthority;
use trust_dns_server::store::sqlite::{Journal, SqliteAuthority};
use hickory_server::authority::LookupOptions;
use hickory_server::authority::{Authority, ZoneType};
use hickory_server::server::Protocol;
use hickory_server::server::RequestInfo;
use hickory_server::store::in_memory::InMemoryAuthority;
use hickory_server::store::sqlite::{Journal, SqliteAuthority};
const TEST_HEADER: &Header = &Header::new();
fn create_example() -> SqliteAuthority {
let authority = trust_dns_integration::example_authority::create_example();
let authority = hickory_integration::example_authority::create_example();
SqliteAuthority::new(authority, true, false)
}
#[cfg(feature = "dnssec")]
fn create_secure_example() -> SqliteAuthority {
let authority = trust_dns_integration::example_authority::create_secure_example();
let authority = hickory_integration::example_authority::create_secure_example();
SqliteAuthority::new(authority, true, true)
}
@@ -207,8 +207,8 @@ async fn test_authority() {
#[cfg(feature = "dnssec")]
#[tokio::test]
async fn test_authorize() {
use trust_dns_client::serialize::binary::{BinDecodable, BinEncodable};
use trust_dns_server::authority::MessageRequest;
use hickory_client::serialize::binary::{BinDecodable, BinEncodable};
use hickory_server::authority::MessageRequest;
let authority = create_example();
@@ -904,7 +904,7 @@ async fn test_update() {
#[tokio::test]
#[allow(clippy::uninlined_format_args)]
async fn test_zone_signing() {
use trust_dns_proto::rr::dnssec::rdata::RRSIG;
use hickory_proto::rr::dnssec::rdata::RRSIG;
let authority = create_secure_example();

20
tests/integration-tests/tests/truncation_tests.rs
View File

@@ -1,18 +1,18 @@
use hickory_client::client::AsyncClient;
use hickory_proto::op::{Edns, Message, MessageType, OpCode, Query};
use hickory_proto::rr::rdata::{A, SOA};
use hickory_proto::rr::{DNSClass, Name, RData, Record, RecordSet, RecordType, RrKey};
use hickory_proto::udp::UdpClientStream;
use hickory_proto::xfer::FirstAnswer;
use hickory_proto::DnsHandle;
use hickory_server::authority::{Catalog, ZoneType};
use hickory_server::store::in_memory::InMemoryAuthority;
use hickory_server::ServerFuture;
use std::collections::BTreeMap;
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
use std::str::FromStr;
use std::sync::Arc;
use tokio::net::UdpSocket;
use trust_dns_client::client::AsyncClient;
use trust_dns_proto::op::{Edns, Message, MessageType, OpCode, Query};
use trust_dns_proto::rr::rdata::{A, SOA};
use trust_dns_proto::rr::{DNSClass, Name, RData, Record, RecordSet, RecordType, RrKey};
use trust_dns_proto::udp::UdpClientStream;
use trust_dns_proto::xfer::FirstAnswer;
use trust_dns_proto::DnsHandle;
use trust_dns_server::authority::{Catalog, ZoneType};
use trust_dns_server::store::in_memory::InMemoryAuthority;
use trust_dns_server::ServerFuture;
#[tokio::test]
async fn test_truncation() {

6
tests/test-data/test_configs/default/0.zone
View File

@@ -1,9 +1,9 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ IN SOA trust-dns.org. root.trust-dns.org. (
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.

6
tests/test-data/test_configs/default/127.0.0.1.zone
View File

@@ -1,11 +1,11 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ IN SOA trust-dns.org. root.trust-dns.org. (
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.
1 PTR localhost.

6
tests/test-data/test_configs/default/255.zone
View File

@@ -1,9 +1,9 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ IN SOA trust-dns.org. root.trust-dns.org. (
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.

4
tests/test-data/test_configs/default/implicitclass.zone
View File

@@ -1,6 +1,6 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ SOA trust-dns.org. root.trust-dns.org. (
@ SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry

6
tests/test-data/test_configs/default/ipv6_1.zone
View File

@@ -1,11 +1,11 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ IN SOA trust-dns.org. root.trust-dns.org. (
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.
1 PTR localhost.

6
tests/test-data/test_configs/default/localhost.zone
View File

@@ -1,12 +1,12 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ IN SOA trust-dns.org. root.trust-dns.org. (
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry
604800 ; Expire
86400) ; Minimum TTL
NS trust-dns.org.
NS hickory-dns.org.
localhost. A 127.0.0.1
AAAA ::1

4
tests/test-data/test_configs/default/nonewline.zone
View File

@@ -1,6 +1,6 @@
; replace the trust-dns.org with your own name
; replace the hickory-dns.org with your own name
$TTL 3D
@ IN SOA trust-dns.org. root.trust-dns.org. (
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry

4
tests/test-data/test_configs/dnssec/example.com.zone
View File

@@ -1,5 +1,5 @@
; replace the trust-dns.org with your own name
@ IN SOA trust-dns.org. root.trust-dns.org. (
; replace the hickory-dns.org with your own name
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
28800 ; Refresh
7200 ; Retry

4
tests/test-data/test_configs/example.com.zone
View File

@@ -1,5 +1,5 @@
; replace the trust-dns.org with your own name
@ IN SOA trust-dns.org. root.trust-dns.org. (
; replace the hickory-dns.org with your own name
@ IN SOA hickory-dns.org. root.hickory-dns.org. (
199609203 ; Serial
8h ; Refresh
120m ; Retry

8
tests/test-data/test_configs/example.toml
View File

@@ -1,11 +1,11 @@
##
## This is an example configuration file for the Trust-DNS named server.
## This is an example configuration file for the Hickory DNS named server.
##
## The format is in TOML: https://github.com/toml-lang/toml which was chosen
## as the configuration format for Trust-DNS. While Trust-DNS is intended to
## as the configuration format for Hickory DNS. While Hickory DNS is intended to
## be a drop-in replacement for BIND9, it will not support the named.conf files
## directly. At some point, there will be a binary tool for converting the
## BIND9 configuration files over to Trust-DNS TOML.
## BIND9 configuration files over to Hickory DNS TOML.
##
## Many of these options are available as both command line options and
## configuration options in these files. In that case, the command line option
@@ -93,7 +93,7 @@ file = "example.com.zone"
## set of DNSSEC algorithms to use to sign the zone. enable_dnssec must be true.
## these will be lookedup by $file.{key_name}.pem, for backward compatibility
## with previous versions of Trust-DNS, if enable_dnssec is enabled but
## with previous versions of Hickory DNS, if enable_dnssec is enabled but
## supported_algorithms is not specified, it will default to "RSASHA256" and
## look for the $file.pem for the key. To control key length, or other options
## keys of the specified formats can be generated in PEM format. Instructions

2
tests/test-data/test_configs/sec/gen-keys.sh
View File

@@ -24,7 +24,7 @@ echo "====> generating cert"
${OPENSSL:?} req -new -x509 -days 365 -sha256 \
-key ${KEY_FILE:?} -keyform der \
-out ${CRT_FILE:?} -outform der \
-subj '/O=Trust-DNS/CN=ns.example.com' \
-subj '/O=Hickory DNS/CN=ns.example.com' \
-config <(cat /etc/ssl/openssl.cnf <(printf "\n[x509v3]\nsubjectAltName=critical,DNS:ns.example.com\nkeyUsage=critical,digitalSignature,keyAgreement,keyCertSign\nextendedKeyUsage=critical,serverAuth,clientAuth\nbasicConstraints=critical,pathlen:0")) \
-extensions x509v3 \
-reqexts x509v3