Revproxy is working. Added example cgi script

src/config.rs

@@ -20,7 +20,7 @@ pub struct Server {
     pub cert: String,
     pub cgi: Option<String>,
     pub usrdir: Option<bool>,
-    pub proxy: Option<Vec<String>>,
+    pub proxy: Option<HashMap<String, String>>,
 }
 
 #[derive(Debug, Clone)]
@@ -54,12 +54,7 @@ impl Config {
             };
             let mut pmap = HashMap::new();
             match &srv.proxy {
-                Some(pr) => {
-                    for p in pr {
-                        let p: Vec<&str> = p.split("=").collect();
-                        pmap.insert(p[0].trim().to_string(), p[1].trim().to_string());
-                    }
-                },
+                Some(pr) => pmap = pr.clone(),
                 None => {},
             };
             map.insert(srv.hostname.clone(), ServerCfg { 
@@ -70,7 +65,7 @@ impl Config {
                 cgi: cgi,
                 usrdir: usrdir,
                 port: self.port.clone(),
-                proxy: pmap,
+                proxy: pmap.clone(),
             });
         }
         map

src/main.rs

@@ -124,9 +124,13 @@ async fn handle_connection(mut con: conn::Connection, srv: &config::ServerCfg) -
     };
 
     if srv.proxy.len() != 0 {
-        match srv.proxy.get(url.path()) {
+        let seg = match url.path_segments().map(|c| c.collect::<Vec<_>>()) {
+            Some(s) => s,
+            None => return Ok(()),
+        };
+        match srv.proxy.get(seg[0]) {
             Some(p) => {
-                revproxy::proxy(p.to_string(), url).await?;
+                revproxy::proxy(p.to_string(), url, con).await?;
                 return Ok(());
             },
             None => {},

src/revproxy.rs

@@ -1,37 +1,59 @@
-use std::io;
-use std::fs::File;
-use std::sync::Arc;
-use std::net::ToSocketAddrs;
-use std::io::BufReader;
 use futures_util::future;
+use std::fs::File;
+use std::io;
+use std::io::Read;
+use std::io::BufReader;
+use std::net::ToSocketAddrs;
+use std::sync::Arc;
+use tokio::io::{copy, split, AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
-use tokio::io::{
-    AsyncWriteExt,
-    copy, split,
-};
-use tokio_rustls::{ TlsConnector, rustls::ClientConfig, webpki::DNSNameRef };
+use openssl::ssl::{SslConnector, SslMethod};
 use url::Url;
 
-pub async fn proxy(addr: String, _u: url::Url) -> Result<(), io::Error> {
-    let addr = addr.to_socket_addrs()?
+use crate::conn;
+use crate::status;
+
+pub async fn proxy(addr: String, u: url::Url, mut con: conn::Connection) -> Result<(), io::Error> {
+    let p: Vec<&str> = u.path().trim_start_matches("/").splitn(2, "/").collect();
+    if p.len() == 1 {
+        con.send_status(status::Status::NotFound, "Not Found").await?;
+        return Ok(());
+    }
+    if p[1] == "" || p[1] == "/" {
+        con.send_status(status::Status::NotFound, "Not Found").await?;
+        return Ok(())
+    }
+    let addr = addr
+        .to_socket_addrs()?
         .next()
         .ok_or_else(|| io::Error::from(io::ErrorKind::AddrNotAvailable))?;
-    let mut config = ClientConfig::new();
 
-    let mut pem = BufReader::new(File::open("cafile")?);
-    config.root_store.add_pem_file(&mut pem)
-                        .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid cert"))?;
-
-    let connector = TlsConnector::from(Arc::new(config));
-    let stream = TcpStream::connect(&addr).await?;
-
-    let domain = DNSNameRef::try_from_ascii_str("cbook.lan")
-                    .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid dnsname"))?;
-
-    println!("Connecting to agena...");
-    let mut stream = connector.connect(domain, stream).await?;
-    //stream.write_all(b"gopher://gopher.club/\r\n").await?;
-    //stream.flush().await?;
+    let mut connector = SslConnector::builder(SslMethod::tls()).unwrap();
+    connector.set_verify(openssl::ssl::SslVerifyMode::NONE);
+    let config = connector.build().configure().unwrap();
 
+    let stream = match TcpStream::connect(&addr).await {
+        Ok(s) => s,
+        Err(_) => {
+            eprintln!("Error connecting to proxy");
+            con.send_status(status::Status::ProxyError, "Error Connecting to proxy").await?;
+            return Ok(())
+        },
+    };
+    let mut stream = match tokio_openssl::connect(config, "localhost", stream).await {
+        Ok(s) => s,
+        Err(_) => {
+            eprintln!("Error connecting to proxy");
+            con.send_status(status::Status::ProxyError, "Error Connecting to proxy").await?;
+            return Ok(())
+        },
+    };
+    stream.write_all(p[1].as_bytes()).await?;
+    stream.flush().await?;
+    
+    let mut buf = vec![];
+    stream.read_to_end(&mut buf).await?;
+    // let req = String::from_utf8(buf[..].to_vec()).unwrap();
+    con.send_raw(&buf).await?;
     Ok(())
 }