167 lines
4.4 KiB
Rust
167 lines
4.4 KiB
Rust
use futures_io::{AsyncRead, AsyncWrite};
|
|
use std::{
|
|
future::Future,
|
|
pin::Pin,
|
|
task::{Context, Poll},
|
|
};
|
|
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
|
|
|
|
pub fn resolver(
|
|
config: ResolverConfig,
|
|
options: ResolverOpts,
|
|
) -> Result<JiveResolver, trust_dns_resolver::error::ResolveError> {
|
|
JiveResolver::new(config, options, JiveRuntimeHandle)
|
|
}
|
|
|
|
pub fn resolver_from_system_conf() -> Result<JiveResolver, trust_dns_resolver::error::ResolveError>
|
|
{
|
|
JiveResolver::from_system_conf(JiveRuntimeHandle)
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct JiveRuntime;
|
|
|
|
pub struct JiveTcpStream {
|
|
pub(crate) io: jive::io::Async<jive::net::TcpStream>,
|
|
}
|
|
|
|
pub struct JiveUdpSocket {
|
|
io: jive::io::Async<jive::net::UdpSocket>,
|
|
}
|
|
|
|
pub type JiveResolver = trust_dns_resolver::AsyncResolver<JiveConnection, JiveConnectionProvider>;
|
|
|
|
pub type JiveConnection = trust_dns_resolver::name_server::GenericConnection;
|
|
pub type JiveConnectionProvider =
|
|
trust_dns_resolver::name_server::GenericConnectionProvider<JiveRuntime>;
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub struct JiveRuntimeHandle;
|
|
|
|
pub struct JiveTimer;
|
|
|
|
impl JiveTcpStream {
|
|
pub fn into_inner(self) -> jive::io::Async<jive::net::TcpStream> {
|
|
self.io
|
|
}
|
|
|
|
pub fn from_inner(io: jive::io::Async<jive::net::TcpStream>) -> Self {
|
|
JiveTcpStream { io }
|
|
}
|
|
}
|
|
|
|
impl trust_dns_resolver::name_server::RuntimeProvider for JiveRuntime {
|
|
type Handle = JiveRuntimeHandle;
|
|
type Tcp = JiveTcpStream;
|
|
type Timer = JiveTimer;
|
|
type Udp = JiveUdpSocket;
|
|
}
|
|
|
|
impl trust_dns_resolver::name_server::Spawn for JiveRuntimeHandle {
|
|
fn spawn_bg<F>(&mut self, future: F)
|
|
where
|
|
F: Future<Output = Result<(), trust_dns_proto::error::ProtoError>> + Send + 'static,
|
|
{
|
|
let _join = jive::spawn(future);
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl trust_dns_proto::tcp::Connect for JiveTcpStream {
|
|
async fn connect_with_bind(
|
|
addr: std::net::SocketAddr,
|
|
bind_addr: Option<std::net::SocketAddr>,
|
|
) -> std::io::Result<Self> {
|
|
if let Some(_bind_addr) = bind_addr {
|
|
todo!("Implement connect with bind");
|
|
} else {
|
|
let io = jive::io::Async::<jive::net::TcpStream>::connect(addr).await?;
|
|
|
|
Ok(JiveTcpStream { io })
|
|
}
|
|
}
|
|
}
|
|
|
|
impl trust_dns_proto::tcp::DnsTcpStream for JiveTcpStream {
|
|
type Time = JiveTimer;
|
|
}
|
|
|
|
impl AsyncRead for JiveTcpStream {
|
|
fn poll_read(
|
|
self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
buf: &mut [u8],
|
|
) -> Poll<std::io::Result<usize>> {
|
|
Pin::new(&mut self.get_mut().io).poll_read(cx, buf)
|
|
}
|
|
}
|
|
|
|
impl AsyncWrite for JiveTcpStream {
|
|
fn poll_write(
|
|
self: Pin<&mut Self>,
|
|
cx: &mut Context<'_>,
|
|
buf: &[u8],
|
|
) -> Poll<std::io::Result<usize>> {
|
|
Pin::new(&mut self.get_mut().io).poll_write(cx, buf)
|
|
}
|
|
|
|
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
|
|
Pin::new(&mut self.get_mut().io).poll_flush(cx)
|
|
}
|
|
|
|
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
|
|
Pin::new(&mut self.get_mut().io).poll_close(cx)
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl trust_dns_proto::udp::UdpSocket for JiveUdpSocket {
|
|
type Time = JiveTimer;
|
|
|
|
async fn bind(addr: std::net::SocketAddr) -> std::io::Result<Self> {
|
|
let io = jive::io::Async::<jive::net::UdpSocket>::bind(addr).await?;
|
|
|
|
Ok(JiveUdpSocket { io })
|
|
}
|
|
|
|
fn poll_send_to(
|
|
&self,
|
|
cx: &mut Context<'_>,
|
|
buf: &[u8],
|
|
target: std::net::SocketAddr,
|
|
) -> Poll<std::io::Result<usize>> {
|
|
self.io.poll_send_to(cx, buf, target)
|
|
}
|
|
|
|
fn poll_recv_from(
|
|
&self,
|
|
cx: &mut Context<'_>,
|
|
buf: &mut [u8],
|
|
) -> Poll<std::io::Result<(usize, std::net::SocketAddr)>> {
|
|
self.io.poll_recv_from(cx, buf)
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl trust_dns_proto::Time for JiveTimer {
|
|
async fn delay_for(duration: std::time::Duration) {
|
|
jive::time::sleep(duration).await
|
|
}
|
|
|
|
async fn timeout<F: 'static + Future + Send>(
|
|
duration: std::time::Duration,
|
|
future: F,
|
|
) -> Result<F::Output, std::io::Error> {
|
|
jive::time::timeout(duration, Box::pin(future)).await
|
|
}
|
|
}
|
|
|
|
impl trust_dns_proto::Executor for JiveRuntime {
|
|
fn new() -> Self {
|
|
Self
|
|
}
|
|
|
|
fn block_on<F: Future>(&mut self, future: F) -> F::Output {
|
|
jive::block_on(future)
|
|
}
|
|
}
|