tokio-tls: fix examples build and run (#1963)

tokio-tls/examples/download-rust-lang.rs

@@ -0,0 +1,40 @@
+// #![warn(rust_2018_idioms)]
+
+use native_tls::TlsConnector;
+use std::error::Error;
+use std::net::ToSocketAddrs;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
+use tokio_tls;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
+    let addr = "www.rust-lang.org:443"
+        .to_socket_addrs()?
+        .next()
+        .ok_or("failed to resolve www.rust-lang.org")?;
+
+    let socket = TcpStream::connect(&addr).await?;
+    let cx = TlsConnector::builder().build()?;
+    let cx = tokio_tls::TlsConnector::from(cx);
+
+    let mut socket = cx.connect("www.rust-lang.org", socket).await?;
+
+    socket
+        .write_all(
+            "\
+             GET / HTTP/1.0\r\n\
+             Host: www.rust-lang.org\r\n\
+             \r\n\
+             "
+            .as_bytes(),
+        )
+        .await?;
+
+    let mut data = Vec::new();
+    socket.read_to_end(&mut data).await?;
+
+    // println!("data: {:?}", &data);
+    println!("{}", String::from_utf8_lossy(&data[..]));
+    Ok(())
+}

tokio-tls/examples/echo.rs

@@ -0,0 +1,55 @@
+#![warn(rust_2018_idioms)]
+
+// A tiny async TLS echo server with Tokio
+use native_tls;
+use native_tls::Identity;
+use tokio;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+use tokio_tls;
+
+/**
+an example to setup a tls server.
+how to test:
+wget https://127.0.0.1:12345 --no-check-certificate
+*/
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Bind the server's socket
+    let addr = "127.0.0.1:12345".to_string();
+    let mut tcp: TcpListener = TcpListener::bind(&addr).await?;
+
+    // Create the TLS acceptor.
+    let der = include_bytes!("identity.p12");
+    let cert = Identity::from_pkcs12(der, "mypass")?;
+    let tls_acceptor =
+        tokio_tls::TlsAcceptor::from(native_tls::TlsAcceptor::builder(cert).build()?);
+    loop {
+        // Asynchronously wait for an inbound socket.
+        let (socket, remote_addr) = tcp.accept().await?;
+        let tls_acceptor = tls_acceptor.clone();
+        println!("accept connection from {}", remote_addr);
+        tokio::spawn(async move {
+            // Accept the TLS connection.
+            let mut tls_stream = tls_acceptor.accept(socket).await.expect("accept error");
+            // In a loop, read data from the socket and write the data back.
+
+            let mut buf = [0; 1024];
+            let n = tls_stream
+                .read(&mut buf)
+                .await
+                .expect("failed to read data from socket");
+
+            if n == 0 {
+                return;
+            }
+            println!("read={}", unsafe {
+                String::from_utf8_unchecked(buf[0..n].into())
+            });
+            tls_stream
+                .write_all(&buf[0..n])
+                .await
+                .expect("failed to write data to socket");
+        });
+    }
+}