Remove dependency on async-std & async-tls in maj, upgrade Tokio

Still gotta patch out the other crates tho

Cargo.toml

@@ -10,8 +10,6 @@ repository = "https://tulpa.dev/cadey/maj"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-std = { version = "1.6", optional = true }
-async-tls = { default-features = false, optional = true, version = "0" }
 async-trait = { version = "0", optional = true }
 log = "0.4"
 mime_guess = "2.0"
@@ -19,11 +17,11 @@ num = "0.2"
 num-derive = "0.3"
 num-traits = "0.2"
 once_cell = "1.4"
-rustls = { version = "0.18", optional = true, features = ["dangerous_configuration"] }
+rustls = { version = "0.19", optional = true, features = ["dangerous_configuration"] }
 structopt = "0.3"
 thiserror = "1"
-tokio-rustls = { version = "0.14", features = ["dangerous_configuration"], optional = true }
+tokio-rustls = { version = "0.21", features = ["dangerous_configuration"], optional = true }
-tokio = { version = "0.2", features = ["full"], optional = true }
+tokio = { version = "0.3", features = ["full"], optional = true }
 url = "2"
 webpki-roots = { version = "0.20", optional = true }
 webpki = { version = "0.21.0", optional = true }
@@ -41,8 +39,6 @@ client = [
   "webpki",
   "webpki-roots",
   "tokio",
-  "async-std",
-  "async-tls/client"
 ]
 
 server = [
@@ -50,8 +46,6 @@ server = [
   "webpki",
   "webpki-roots",
   "async-trait",
-  "async-std",
-  "async-tls/server"
 ]
 
 [workspace]

src/server/files.rs

@@ -26,7 +26,7 @@ impl MajHandler for Handler {
 
         log::debug!("opening file {:?}", path);
 
-        match async_std::fs::metadata(&path).await {
+        match tokio::fs::metadata(&path).await {
             Ok(stat) => {
                 if stat.is_dir() {
                     if r.url.as_str().ends_with('/') {
@@ -43,9 +43,9 @@ impl MajHandler for Handler {
             }
         }
 
-        let mut file = async_std::fs::File::open(&path).await?;
+        let mut file = tokio::fs::File::open(&path).await?;
         let mut buf: Vec<u8> = Vec::new();
-        async_std::io::copy(&mut file, &mut buf).await?;
+        tokio::io::copy(&mut file, &mut buf).await?;
 
         // Send header.
         if path.extension() == Some(OsStr::new("gmi"))

src/server/mod.rs

@@ -1,11 +1,10 @@
 use crate::{Response, StatusCode};
-use async_std::{
+use tokio::{
-    io::prelude::*,
+    prelude::*,
     net::{TcpListener, TcpStream},
-    stream::StreamExt,
     task,
 };
-use async_tls::TlsAcceptor;
+use tokio_rustls::TlsAcceptor;
 use async_trait::async_trait;
 use rustls::Certificate;
 use std::{error::Error as StdError, net::SocketAddr, sync::Arc};
@@ -53,12 +52,10 @@ where
 {
     let cfg = Arc::new(cfg);
     let listener = TcpListener::bind(&format!("{}:{}", host, port)).await?;
-    let mut incoming = listener.incoming();
     let acceptor = Arc::new(TlsAcceptor::from(cfg.clone()));
-    while let Some(Ok(stream)) = incoming.next().await {
+    while let Ok((stream, addr)) = listener.accept().await {
         let h = h.clone();
         let acceptor = acceptor.clone();
-        let addr = stream.peer_addr().unwrap();
         let port = port.clone();
 
         task::spawn(handle_request(h, stream, acceptor, addr, port));
@@ -83,7 +80,7 @@ async fn handle_request(
             if let Some(u_port) = url.port() {
                 if port != u_port {
                     let _ = write_header(
-                        &mut stream,
+                        stream,
                         StatusCode::ProxyRequestRefused,
                         "Cannot proxy to that URL",
                     )
@@ -117,7 +114,7 @@ async fn handle_request(
     Ok(())
 }
 
-pub async fn write_header<W: Write + Unpin>(
+pub async fn write_header<W: AsyncWrite + Unpin>(
     mut stream: W,
     status: StatusCode,
     meta: &str,
@@ -129,7 +126,7 @@ pub async fn write_header<W: Write + Unpin>(
 }
 
 /// Return the URL requested by the client.
-async fn parse_request<R: Read + Unpin>(mut stream: R) -> Result<Url> {
+async fn parse_request<R: AsyncRead + Unpin>(mut stream: R) -> Result<Url> {
     // Because requests are limited to 1024 bytes (plus 2 bytes for CRLF), we
     // can use a fixed-sized buffer on the stack, avoiding allocations and
     // copying, and stopping bad clients from making us use too much memory.
@@ -167,7 +164,7 @@ async fn handle<T>(
     stream: &mut T,
     addr: SocketAddr,
 ) where
-    T: Write + Unpin,
+    T: AsyncWrite + Unpin,
 {
     let u = req.url.clone();
     match h.handle(req).await {