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
// Copyright 2017-2021 Lukas Pustina <lukas@pustina.de> // // 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 // copied, modified, or distributed except according to those terms. //! `mhost` is a modern take on the classic `host` DNS lookup utility including an easy to use, and very fast Rust library. //! //! The library is currently still in a PoC state. It works and the command line tool `mhost` //! already uses it. Nevertheless, I'm not satisfied with the design and architecture so it is //! still work in progress. //! //! Unfortunately, this also means that the library totally lacks documentation. If you want to use //! the library in your own project, please be aware that the API might change. Even though //! documentation is missing, you can find fully working examples that might help to jump start //! you. //! //! Please feel free to give me feedback in form of GitHub issues and I welcome any PRs. //! //! # Example //! Lookup A, AAAA, and TXT records for `mhost.pustina.de` using the local operating system's nameservers as //! well as Google's nameserver. //! ``` //! use mhost::nameserver::NameServerConfig; //! use mhost::resolver::{MultiQuery, Resolver, ResolverConfig, ResolverGroup}; //! use mhost::resolver::lookup::Uniquify; //! use mhost::statistics::Statistics; //! use mhost::RecordType; //! use std::net::SocketAddr; //! //! # #[tokio::main] //! # async fn main() { //! # //! // Create a `ResolverGroup` with operating system's nameservers; a `ResolverGroup` //! // acts the same a single `Resolver` and allows to lookup records from multiple name servers. //! let mut resolvers = ResolverGroup::from_system_config(Default::default()) //! .await //! .expect("failed to create system resolvers"); //! //! // Create a Resolver for Google's DNS nameserver with UDP transport //! let sock_addr: SocketAddr = "8.8.8.8:53".parse().unwrap(); //! let name_server_config = NameServerConfig::udp(sock_addr); //! let config = ResolverConfig::new(name_server_config); //! let google = Resolver::new(config, Default::default()) //! .await //! .expect("Failed to create Google resolver"); //! //! // Add Google resolver to `ResolverGroup` //! resolvers.add(google); //! //! // Prepare a `MultiQuery`: Query multiple names and/or multiple record types at once //! let query = MultiQuery::multi_record( //! "mhost.pustina.de", //! vec![RecordType::A, RecordType::AAAA, RecordType::TXT] //! ).expect("Failed to create query"); //! //! // Perform multi-lookup //! let lookups = resolvers.lookup(query).await.expect("Failed to execute lookups"); //! //! // Print statistics about lookup results //! println!("Statistics: {:#?}", lookups.statistics()); //! //! // Print all results //! println!("Multi-Lookup results: {:#?}", lookups); //! //! // Aggregate all A records //! let a_records = lookups.a().unique().to_owned(); //! println!("A records: {:#?}", a_records); //! //! # assert!(a_records.len() > 0); //! # } //! ``` #[cfg(feature = "app")] pub mod app; pub mod diff; pub mod error; pub mod estimate; pub mod nameserver; pub mod resolver; pub mod resources; pub mod services; pub mod statistics; pub mod system_config; pub mod utils; pub use error::Error; pub use ipnetwork::IpNetwork; pub use resources::rdata::{IntoName, Name}; pub use resources::RecordType; pub type Result<T> = std::result::Result<T, error::Error>;