Drop moved examples from domain-core.

domain-core/examples/lookup.rs

@@ -1,93 +0,0 @@
-/*
-extern crate domain;
-
-use std::env;
-//use std::io;
-use std::net::IpAddr;
-use std::str::FromStr;
-use domain::bits::DNameBuf;
-use domain::resolv::{Resolver, ResolvConf};
-use domain::resolv::conf::ServerMode;
-use domain::resolv::lookup::{lookup_addr, lookup_host};
-
-
-fn forward(name: DNameBuf, conf: ResolvConf) {
-    match Resolver::run_with_conf(conf, |resolv| lookup_host(resolv, &name)) {
-        Ok(result) => {
-            if name != result.canonical_name() {
-                println!("{} is an alias for {}",
-                         name, result.canonical_name());
-            }
-            for addr in result.iter() {
-                println!("{} has address {}", result.canonical_name(), addr);
-            }
-        },
-        Err(err) => {
-            println!("Error: {:?}", err);
-        }
-    }
-}
-
-fn reverse(addr: IpAddr, conf: ResolvConf) {
-    match Resolver::run_with_conf(conf, |resolv| lookup_addr(resolv, addr)) {
-        Ok(result) => {
-            println!("Success:");
-            for name in result.iter() {
-                println!("Host {} has domain name pointer {}", addr, name);
-            }
-        },
-        Err(err) => {
-            println!("Error: {}", err);
-        }
-    }
-}
-
-fn set_tcp_mode(conf: &mut ResolvConf, mode: ServerMode) {
-    for server in &mut conf.servers {
-        server.tcp = mode;
-    }
-}
-
-fn parse_queryopt(conf: &mut ResolvConf, arg: &str) {
-    match arg {
-        "+vc" => conf.options.use_vc = true,
-        "+tcpsgl" => set_tcp_mode(conf, ServerMode::SingleRequest),
-        "+tcpseq" => set_tcp_mode(conf, ServerMode::Sequential),
-        "+tcpmul" => set_tcp_mode(conf, ServerMode::Multiplex),
-        _ => {
-            println!("Warning: ignoring unknown query option {}", arg);
-        }
-    }
-}
-*/
-
-fn main() {
-/*
-    let mut conf = ResolvConf::default();
-    let mut names = Vec::new();
-    for arg in env::args().skip(1) {
-        if arg.starts_with('+') {
-            parse_queryopt(&mut conf, &arg)
-        }
-        else {
-            names.push(arg)
-        }
-    }
-    if names.is_empty() {
-        println!("Usage: host [OPTIONS] <hostname>");
-        return;
-    }
-
-    for name in names {
-        if let Ok(addr) = IpAddr::from_str(&name) {
-            reverse(addr, conf.clone())
-        }
-        else if let Ok(name) = DNameBuf::from_str(&name) {
-            forward(name, conf.clone())
-        }
-        else {
-            println!("Not a domain name: {}", name)
-        }
-    }
-*/
-}

domain-core/examples/rusthome.rs

@@ -1,63 +0,0 @@
-/*
-//! Download and print the Rust homepage.
-//!
-//! This is the [toy HTTP+TLS client] example from the [futures tutorial]
-//! extended to use our resolver.
-//!
-//! [toy HTTP+TLS client]: https://tokio.rs/docs/getting-started/tls/
-//! [futures tutorial]: https://tokio.rs/docs/getting-started/futures/
-
-extern crate futures;
-extern crate native_tls;
-extern crate tokio_core;
-extern crate tokio_io;
-extern crate tokio_tls;
-extern crate domain;
-
-use std::io;
-use std::str::FromStr;
-
-use futures::Future;
-use native_tls::TlsConnector;
-use tokio_core::net::TcpStream;
-use tokio_core::reactor::Core;
-use tokio_tls::TlsConnectorExt;
-use domain::bits::DNameBuf;
-use domain::resolv::Resolver;
-use domain::resolv::lookup::lookup_host;
-
-#[allow(unknown_lints, string_lit_as_bytes)]
-*/
-fn main() {
-/*
-    let mut core = Core::new().unwrap();
-    let handle = core.handle();
-    let resolver = Resolver::new(&handle);
-    let addr = lookup_host(resolver, DNameBuf::from_str("www.rust-lang.org")
-                                              .unwrap()).map_err(Into::into);
-    let cx = TlsConnector::builder().unwrap().build().unwrap();
-    let socket = addr.and_then(|addr| {
-        TcpStream::connect(&addr.port_iter(443).next().unwrap(), &handle)
-    });
-
-    let tls_handshake = socket.and_then(|socket| {
-        let tls = cx.connect_async("www.rust-lang.org", socket);
-        tls.map_err(|e| {
-            io::Error::new(io::ErrorKind::Other, e)
-        })
-    });
-    let request = tls_handshake.and_then(|socket| {
-        tokio_io::io::write_all(socket, "\
-            GET / HTTP/1.0\r\n\
-            Host: www.rust-lang.org\r\n\
-            \r\n\
-        ".as_bytes())
-    });
-    let response = request.and_then(|(socket, _request)| {
-        tokio_io::io::read_to_end(socket, Vec::new())
-    });
-
-    let (_socket, data) = core.run(response).unwrap();
-    println!("{}", String::from_utf8_lossy(&data));
-*/
-}