[Feature] Introduce handling of HTTP(S) proxy

This adds new category of traffic for proxy, currently unstable and untested. Would be improved further.

Cargo.toml

@@ -18,6 +18,7 @@ rand = { version = "0.8.5" }
 [dependencies]
 anyhow = { version = "1.0.81" }
 async-listen = { version = "0.2.1" }
+async-trait = { version = "*" }
 bytes = { version = "1.6.0" }
 clap = { version = "4.5.3", features = ["derive"] }
 cfg-if = { version = "1.0" }

src/common/logging.rs

@@ -87,7 +87,7 @@ macro_rules! log_tcp_closed_conn {
 macro_rules! log_tcp_established_conn {
     ($conn_addr:expr, $conn_label:expr) => {
         info!(
-            "\n\n\tTCP {} connection has been OPENED: \
+            "\n\n\tTCP connection with {} label has been OPENED: \
             \n\t\tpeer: '{}' \
             \n",
             $conn_label, $conn_addr,

src/io/mod.rs

@@ -1,8 +1,6 @@
 use anyhow::Result;
-use std::fmt::Debug;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
-pub mod stream;
 pub mod tunnel;
 
 pub trait LurkRequest {
@@ -14,15 +12,3 @@ pub trait LurkRequest {
 pub trait LurkResponse {
     async fn write_to<T: AsyncWriteExt + Unpin>(&self, stream: &mut T) -> Result<()>;
 }
-
-pub trait LurkResponseWrite {
-    async fn write_response<Response>(&mut self, response: Response) -> Result<()>
-    where
-        Response: LurkResponse + Debug + 'static;
-}
-
-pub trait LurkRequestRead {
-    async fn read_request<Request>(&mut self) -> Result<Request>
-    where
-        Request: LurkRequest + Debug + 'static;
-}

src/net/tcp.rs

@@ -175,7 +175,7 @@ pub mod listener {
                     .expect("Expect accepted connection before expired timeout")
                     .expect("Expect accepted TCP connection");
 
-                assert_eq!(LurkTcpConnectionLabel::SOCKS5, conn.label());
+                assert_eq!(LurkTcpConnectionLabel::Socks5, conn.label());
                 assert!(
                     listener.factory.get_active_tokens() <= conn_limit,
                     "Number of opened connections must not exceed the limit"
@@ -195,8 +195,8 @@ pub mod listener {
 
 pub mod connection {
 
-    use crate::io::stream::{LurkStream, LurkTcpStream};
     use anyhow::{bail, Result};
+    use async_trait::async_trait;
     use std::{fmt::Display, io, net::SocketAddr};
     use tokio::net::TcpStream;
 
@@ -209,7 +209,13 @@ pub mod connection {
     #[repr(u8)]
     pub enum LurkTcpConnectionLabel {
         /// Traffic of TCP connection belongs to proxy SOCKS5 protocol
-        SOCKS5 = 0x05,
+        Socks5,
+
+        /// Traffic of TCP connection belongs to HTTP protocol
+        Http,
+
+        /// Traffic of TCP connection belongs to HTTPS protocol
+        HttpSecure,
 
         /// Unknown traffic
         Unknown(u8),
@@ -227,7 +233,9 @@ pub mod connection {
 
             if peeked_bytes == 1 {
                 let label = match buff[0] {
-                    0x05 => LurkTcpConnectionLabel::SOCKS5,
+                    0x47 => LurkTcpConnectionLabel::Http,
+                    0x43 => LurkTcpConnectionLabel::HttpSecure,
+                    0x05 => LurkTcpConnectionLabel::Socks5,
                     v => LurkTcpConnectionLabel::Unknown(v),
                 };
 
@@ -241,8 +249,10 @@ pub mod connection {
     impl Display for LurkTcpConnectionLabel {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
-                LurkTcpConnectionLabel::SOCKS5 => write!(f, "SOCKS5"),
-                LurkTcpConnectionLabel::Unknown(l) => write!(f, "Unknown TCP label {l:#04x}"),
+                LurkTcpConnectionLabel::Http => write!(f, "HTTP"),
+                LurkTcpConnectionLabel::HttpSecure => write!(f, "HTTPS"),
+                LurkTcpConnectionLabel::Socks5 => write!(f, "SOCKS5"),
+                LurkTcpConnectionLabel::Unknown(l) => write!(f, "unknown {l:#04x}"),
             }
         }
     }
@@ -273,8 +283,7 @@ pub mod connection {
     }
 
     pub struct LurkTcpConnection {
-        /// Lurk wrapper of TcpStream
-        stream: LurkTcpStream,
+        stream: TcpStream,
         /// Label describing traffic in this TCP connection
         label: LurkTcpConnectionLabel,
         /// Remote address that this connection is connected to
@@ -284,11 +293,11 @@ pub mod connection {
     }
 
     impl LurkTcpConnection {
-        fn new(tcp_stream: TcpStream, label: LurkTcpConnectionLabel) -> Result<LurkTcpConnection> {
+        fn new(stream: TcpStream, label: LurkTcpConnectionLabel) -> Result<LurkTcpConnection> {
             Ok(LurkTcpConnection {
-                peer_addr: tcp_stream.peer_addr()?,
-                local_addr: tcp_stream.local_addr()?,
-                stream: LurkStream::new(tcp_stream),
+                peer_addr: stream.peer_addr()?,
+                local_addr: stream.local_addr()?,
+                stream,
                 label,
             })
         }
@@ -305,11 +314,16 @@ pub mod connection {
             self.label
         }
 
-        pub fn stream_mut(&mut self) -> &mut LurkTcpStream {
+        pub fn stream_mut(&mut self) -> &mut TcpStream {
             &mut self.stream
         }
     }
 
+    #[async_trait]
+    pub trait LurkTcpConnectionHandler: Send {
+        async fn handle(&mut self, mut conn: LurkTcpConnection) -> Result<()>;
+    }
+
     #[cfg(test)]
     mod tests {
 
@@ -338,7 +352,7 @@ pub mod connection {
                 .accept()
                 .and_then(|(s, _)| async move {
                     let label = LurkTcpConnectionLabel::from_tcp_stream(&s).await.unwrap();
-                    assert_eq!(LurkTcpConnectionLabel::SOCKS5, label);
+                    assert_eq!(LurkTcpConnectionLabel::Socks5, label);
                     Ok(())
                 })
                 .await