PeachCloud/peach-dyndns-server
0
0
Fork 0
Code Issues 1 Pull Requests Projects Releases 1 Wiki Activity

Merge pull request #2 from peachcloud/latest

Browse Source 
Update code to use latest versions of trust_dns library
This commit is contained in:
Max Fowler 2021-04-28 13:11:06 +02:00 committed by GitHub
commit e6a9dbbfe9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 1080 additions and 992 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1942
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

14
Cargo.toml
View File

@ -8,13 +8,13 @@ edition = "2018"
clap-log-flag = "0.2" clap-log-flag = "0.2"
clap-verbosity-flag = "0.2" clap-verbosity-flag = "0.2"
log = "0.4" log = "0.4"
futures = "0.1.26" futures = "0.3.1"
hyper = "0.12" hyper = { version = "0.14", features = ["full"] }
nest = "1" nest = "1"
structopt = "0.2" structopt = "0.2"
tokio = "0.1" tokio = { version = "1.5.0", features = ["full"] }
tokio-executor = "0.1" tokio-executor = "0.1"
tokio-tcp = "0.1" tokio-tcp = "0.1.4"
tokio-udp = "0.1" tokio-udp = "0.1.4"
trust-dns = "0.16" trust-dns-server = "0.20.2"
trust-dns-server = "0.16" trust-dns-client = "0.20.2"

48
src/dns.rs
View File

@ -2,20 +2,26 @@ use std::collections::BTreeMap;
use std::net::{IpAddr, Ipv4Addr, SocketAddr}; use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::str::FromStr; use std::str::FromStr;
use std::time::Duration; use std::time::Duration;
use std::sync::{Arc, RwLock};
use futures::{future, Future}; use futures::{future, Future};
use tokio_tcp::TcpListener; use futures::future::join_all;
use tokio_udp::UdpSocket; use tokio::net::TcpListener;
use trust_dns::rr::rdata::soa::SOA; use tokio::net::UdpSocket;
use trust_dns::rr::{LowerName, Name, RData, Record, RecordSet, RecordType, RrKey}; use trust_dns_client::rr::rdata::soa::SOA;
use trust_dns_client::rr::{LowerName, Name, RData, Record, RecordSet, RecordType, RrKey};
use trust_dns_server; use trust_dns_server;
use trust_dns_server::authority::{Catalog, ZoneType}; use trust_dns_server::authority::{Catalog, ZoneType};
use trust_dns_server::server::ServerFuture; use trust_dns_server::server::ServerFuture;
use trust_dns_server::store::in_memory::InMemoryAuthority; use trust_dns_server::store::in_memory::InMemoryAuthority;
static DEFAULT_TCP_REQUEST_TIMEOUT: u64 = 5; static DEFAULT_TCP_REQUEST_TIMEOUT: u64 = 5;
pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
pub async fn server() -> ServerFuture<Catalog> {
info!("Trust-DNS {} starting", trust_dns_server::version()); info!("Trust-DNS {} starting", trust_dns_server::version());
let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)); let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
@ -23,10 +29,8 @@ pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
let tcp_request_timeout = Duration::from_secs(DEFAULT_TCP_REQUEST_TIMEOUT); let tcp_request_timeout = Duration::from_secs(DEFAULT_TCP_REQUEST_TIMEOUT);
let sock_addr = SocketAddr::new(ip_addr, listen_port); let sock_addr = SocketAddr::new(ip_addr, listen_port);
let udp_socket = UdpSocket::bind(&sock_addr) let udp_socket = UdpSocket::bind(&sock_addr).await.expect("could not bind udp socket");
.unwrap_or_else(|_| panic!("could not bind to udp: {}", sock_addr)); let tcp_listener = TcpListener::bind(&sock_addr).await.expect("could not bind tcp listener");
let tcp_listener = TcpListener::bind(&sock_addr)
.unwrap_or_else(|_| panic!("could not bind to tcp: {}", sock_addr));
let mut catalog: Catalog = Catalog::new(); let mut catalog: Catalog = Catalog::new();
@ -76,22 +80,18 @@ pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
let dyn_record = Record::from_rdata(dyn_name, dyn_ttl, dyn_rdata); let dyn_record = Record::from_rdata(dyn_name, dyn_ttl, dyn_rdata);
authority.upsert(dyn_record, authority.serial()); authority.upsert(dyn_record, authority.serial());
catalog.upsert(LowerName::new(&authority_name), Box::new(authority)); catalog.upsert(LowerName::new(&authority_name), Box::new(Arc::new(RwLock::new(authority))));
let server = ServerFuture::new(catalog); let mut server = ServerFuture::new(catalog);
Box::new(future::lazy(move || { // load all the listeners
// load all the listeners info!("DNS server listening for UDP on {:?}", udp_socket);
info!("DNS server listening for UDP on {:?}", udp_socket); let udp_future = server.register_socket(udp_socket);
server.register_socket(udp_socket);
info!("DNS server listening for TCP on {:?}", tcp_listener); info!("DNS server listening for TCP on {:?}", tcp_listener);
server let tcp_future = server
.register_listener(tcp_listener, tcp_request_timeout) .register_listener(tcp_listener, tcp_request_timeout);
.expect("DNS server could not register TCP listener"); info!("awaiting DNS connections...");
info!("awaiting DNS connections..."); server
future::empty()
}))
} }

21
src/http.rs
View File

@ -1,21 +1,22 @@
use futures::Future; use futures::Future;
use hyper::service::service_fn_ok;
use hyper::{Body, Request, Response, Server}; use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use hyper::service::{make_service_fn, service_fn};
fn handle_request(_req: Request<Body>) -> Response<Body> {
Response::new(Body::from("Hello, World!")) async fn handle_request(_req: Request<Body>) -> Result<Response<Body>, Infallible>{
Ok(Response::new(Body::from("Hello, World!")))
} }
pub fn server() -> Box<Future<Item = (), Error = ()> + Send> { pub async fn server() {
let address = ([127, 0, 0, 1], 3000).into(); let address = ([127, 0, 0, 1], 3000).into();
let handle_connection = || service_fn_ok(handle_request); let make_svc = make_service_fn(|_conn| async {
// service_fn converts our function into a `Service`
Ok::<_, Infallible>(service_fn(handle_request))
});
info!("HTTP server listening for TCP on {:?}", address); info!("HTTP server listening for TCP on {:?}", address);
let server = Server::bind(&address) Server::bind(&address).serve(make_svc).await;
.serve(handle_connection)
.map_err(|e| error!("HTTP server error: {}", e));
Box::new(server)
} }

47
src/main.rs
View File

@ -2,40 +2,37 @@
extern crate log; extern crate log;
use std::io; use std::io;
use futures::{try_join, future, Future};
use futures::{future, Future};
use nest::{Error, Store, Value}; use nest::{Error, Store, Value};
use tokio::runtime::Runtime; use tokio::task;
use tokio_executor;
mod cli; mod cli;
mod dns; mod dns;
mod http; mod http;
fn main() -> Result<(), Box<dyn std::error::Error>> { #[tokio::main]
let args = cli::args()?; async fn main() {
let mut runtime = Runtime::new().expect("error when creating tokio Runtime"); let args = cli::args().expect("error parsing args");
let main_future: Box<Future<Item = (), Error = ()> + Send> = // create future for dns and http servers
Box::new(future::lazy(move || { let dns_future = task::spawn(dns::server());
tokio_executor::spawn(dns::server()); let http_future = task::spawn(http::server());
tokio_executor::spawn(http::server());
future::empty() // join futures
})); let result = try_join!(dns_future, http_future);
if let Err(e) = runtime.block_on(main_future.map_err(|_| { match result {
io::Error::new( Err(e) => {
io::ErrorKind::Interrupted, io::Error::new(
"Server stopping due to interruption", io::ErrorKind::Interrupted,
) "Server stopping due to interruption",
})) { );
error!("server failure: {}", e); error!("server failure: {}", e);
}
Ok(val) => {
info!("we're stopping for some unexpected reason");
}
} }
info!("we're stopping for some unexpected reason");
// we're exiting for some reason...
info!("stopping!?");
Ok(())
} }