stuff

Author: blobcode

src/server.rs

@@ -1,5 +1,5 @@
-use tokio::io;
 use tokio::io::AsyncWriteExt;
+use tokio::io::{self, AsyncReadExt};
 use tokio::net::{TcpListener, TcpStream};
 
 use futures::FutureExt;
@@ -10,17 +10,19 @@ pub struct Server {
 }
 
 impl Server {
+    // start server
     pub async fn run(&self) -> Result<(), Box<dyn Error>> {
         let listen_addr = "127.0.0.1:".to_string() + &self.port.to_string();
 
         log::info!("Listening on: {}", listen_addr);
 
         let listener = TcpListener::bind(listen_addr).await?;
 
+        // listener loop that passes off to handler
         while let Ok((inbound, _)) = listener.accept().await {
             let handler = handle(inbound).map(|r| {
                 if let Err(e) = r {
-                    log::error!("Failed to proxy; error={}", e);
+                    log::error!("Failed to handle request; error={}", e);
                 }
             });
 
@@ -30,6 +32,32 @@ impl Server {
     }
 }
 
+// request handler
+async fn handle(mut inbound: TcpStream) -> Result<(), Box<dyn Error>> {
+    let mut buf = vec![0; 1024];
+    inbound.read(&mut buf).await.unwrap();
+    let mut headers = [httparse::EMPTY_HEADER; 16];
+    let mut r = httparse::Request::new(&mut headers);
+
+    r.parse(&buf).unwrap();
+
+    let p = headers.iter().position(|&h| h.name == "Host").unwrap();
+    let host = String::from_utf8_lossy(headers[p].value);
+
+    log::info!("{}", host);
+
+    let proxy = proxy(inbound, host.to_string()).map(|r| {
+        if let Err(e) = r {
+            log::error!("Failed to proxy; error={}", e);
+        }
+    });
+
+    tokio::spawn(proxy);
+
+    Ok(())
+}
+
+// proxy a tcp stream
 async fn proxy(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn Error>> {
     let mut outbound = TcpStream::connect(proxy_addr).await?;
 
@@ -50,31 +78,3 @@ async fn proxy(mut inbound: TcpStream, proxy_addr: String) -> Result<(), Box<dyn
 
     Ok(())
 }
-
-async fn handle(inbound: TcpStream) -> Result<(), Box<dyn Error>> {
-    let server_addr = "127.0.0.1:8080".to_string();
-
-    let transfer = proxy(inbound, server_addr.clone()).map(|r| {
-        if let Err(e) = r {
-            log::error!("Failed to proxy; error={}", e);
-        }
-    });
-
-    tokio::spawn(transfer);
-
-    Ok(())
-}
-
-fn gethost() -> Result<(), Box<dyn Error>> {
-    let mut headers = [httparse::EMPTY_HEADER; 64];
-    let mut req = httparse::Request::new(&mut headers);
-
-    let buf = b"GET /index.html HTTP/1.1\r\nHost";
-    assert!(req.parse(buf)?.is_partial());
-
-    // a partial request, so we try again once we have more data
-
-    let buf = b"GET /index.html HTTP/1.1\r\nHost: example.domain\r\n\r\n";
-    assert!(req.parse(buf)?.is_complete());
-    Ok(())
-}