1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! This crate provides a simple name resolver that based on `domain` crate
//!
//! The `domain` crate is made as a one-stop thing for any DNS. Still
//! `abstract-ns` provides subscriptions for updates and service discovery
//! based on different services (and mapping between names and resolvers).
//!
//! Use this crate:
//!
//! 1. As a more efficient `ns-std-threaded` (with care!)
//! 2. For DNS-based name resolution (no SRV yet)
//!
#![warn(missing_docs)]
#![warn(missing_debug_implementations)]
extern crate futures;
extern crate abstract_ns;
extern crate domain;
extern crate tokio_core;

use std::fmt;
use std::str::FromStr;
use std::net::{IpAddr};
use std::error::Error as StdError;

use futures::{Future, Async};
use tokio_core::reactor::Handle;
use domain::resolv;
use domain::iana::{Rtype, Class};
use domain::rdata::A;
use domain::bits::{Question, DNameBuf};
use abstract_ns::{Name, IpList, Error};


/// A main DNS resolver which implements all needed resolver traits
#[derive(Clone, Debug)]
pub struct DnsResolver {
    internal: resolv::Resolver,
}

/// A Future returned by `DnsResolver::resolve_host`
pub struct HostFuture {
    name: Name,
    query: Option<resolv::Query>,
    error: Option<Error>,
}


impl fmt::Debug for HostFuture {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("HostFuture")
        .field("name", &self.name)
        .finish()
    }
}

impl Future for HostFuture {
    type Item = IpList;
    type Error = Error;
    fn poll(&mut self) -> Result<Async<IpList>, Error> {
        if let Some(err) = self.error.take() {
            return Err(err);
        }
        match self.query.as_mut().expect("future polled twice").poll() {
            Ok(Async::Ready(buf)) => {
                let answer = match buf.answer() {
                    Ok(ans) => ans,
                    Err(e) => {
                        return Err(Error::TemporaryError(
                            Box::new(e)));
                    }
                };
                let mut result = Vec::new();
                for ip_res in answer.limit_to::<A>() {
                    match ip_res {
                        Ok(ip) => result.push(
                            IpAddr::V4(ip.data().addr())),
                        Err(e) => {
                            return Err(Error::TemporaryError(
                                Box::new(e)))
                        }
                    }
                }
                Ok(Async::Ready(result.into()))
            }
            Ok(Async::NotReady) => Ok(Async::NotReady),
            Err(resolv::error::Error::Question(_)) |
            Err(resolv::error::Error::NoName) => {
                Err(Error::InvalidName(self.name.to_string(),
                    "resolv::error::Error::Question"))
            }
            Err(e) => {
                // TODO(tailhook) what returned if
                // there is no such name? Is it success?
                Err(Error::TemporaryError(Box::new(e)))
            }
        }
    }
}

impl DnsResolver {
    /// Create a DNS resolver with system config
    pub fn system_config(lp: &Handle) -> Result<DnsResolver, Box<StdError>> {
        Ok(DnsResolver {
            internal: resolv::Resolver::new(lp),
        })
    }
    /// Create a resolver from `domain::resolv::Resolver` instance
    ///
    /// This method provides the most comprehensive configuration
    pub fn new_from_resolver(internal: resolv::Resolver) -> DnsResolver {
        DnsResolver {
            internal: internal,
        }
    }
}

impl abstract_ns::HostResolve for DnsResolver {
    type HostFuture = HostFuture;
    fn resolve_host(&self, name: &Name) -> HostFuture {
        match DNameBuf::from_str(&format!("{}.", name)) {
            Ok(dname) => {
                HostFuture {
                    name: name.clone(),
                    query: Some(self.internal.clone()
                        .query(Question::new(dname, Rtype::A, Class::In))),
                    error: None,
                }
            }
            Err(_) => {
                HostFuture {
                    name: name.clone(),
                    query: None,
                    error: Some(Error::InvalidName(name.to_string(),
                    "domain::resolv::DNameBuf::from_str failed")),
                }
            }
        }
    }
}