CHANGELOG.md

@@ -7,60 +7,19 @@
 
 ## [未发布]
 
+### 修复
+- ✅ 修复ForwardProxy的Clone trait实现
+- ✅ 修复TcpProxyManager的Clone trait实现
+- ✅ 确保项目编译通过
+- ✅ 验证所有测试通过（7个测试）
+- ✅ 通过clippy代码检查
+
 ### 计划中
-- [ ] 负载均衡与反向代理集成
-- [ ] 健康检查自动化
-- [ ] 连接池统计API
+- [ ] TCP代理协议检测
+- [ ] WebSocket消息解析和转发
 - [ ] 完整SSL/TLS支持
 - [ ] 完整JavaScript运行时集成
 
-## [0.2.1] - 2026-01-17
-
-### 新增
-- 🌊 **完整TCP代理实现**
-  - 原始TCP流量双向转发
-  - 协议自动检测（通过HTTP Upgrade头）
-  - 连接统计和管理
-  - 错误处理和日志记录
-- 🔄 **完整WebSocket代理实现**
-  - WebSocket握手转发
-  - WebSocket消息双向转发
-  - 协议识别
-  - 连接生命周期管理
-- 🔌 **CONNECT方法支持**
-  - HTTP隧道处理
-  - 与服务器模块集成
-  - 自动目标地址解析
-
-### 变更
-- TCP代理模块从87行扩展到410行
-- 服务器模块从273行增加到364行
-- 新增TCP代理集成测试
-
-#### API增强
-- `TcpProxyManager::handle_tcp_proxy` - 完整的TCP/WebSocket代理处理
-- `TcpProxyManager::detect_protocol` - 自动协议检测
-- `TcpProxyManager::handle_raw_tcp` - 原始TCP转发
-- `TcpProxyManager::handle_websocket` - WebSocket转发
-- `handle_connect_request` - HTTP隧道处理
-
-#### 测试覆盖
-- 新增TCP代理测试 (1个测试)
-- 新增连接管理统计测试 (1个测试)
-- 总测试数从7个增加到9个
-- 所有测试通过
-
-### 技术细节
-- 使用 `tokio::io::copy_bidirectional` 实现高效双向转发
-- 使用 `TcpStream::peek` 实现非阻塞协议检测
-- 异步任务管理确保连接生命周期正确
-- 完善的错误处理和日志记录
-
-### 文档更新
-- PROGRESS.md - 更新进度到v0.2.1
-- doc/status.md - 更新状态汇总
-- CHANGELOG.md - 版本变更记录
-
 ## [0.2.0] - 2025-01-15
 
 ### 新增
@@ -374,4 +333,4 @@ cargo doc --open
 
 ---
 
-*最后更新: 2026年1月17日*
+*最后更新: 2025年1月15日*

PROGRESS.md

@@ -1,6 +1,6 @@
 # rhttpd 开发进度总结
 
-## 项目状态 (2026-01-17)
+## 项目状态 (2025-01-16)
 
 ### ✅ 完成的任务
 
@@ -21,16 +21,16 @@
 ### 📊 当前代码统计
 
 ```
-总计: ~2000行Rust代码
+总计: 1411行Rust代码
 
 主要模块:
-- src/proxy/tcp_proxy.rs           410行 (TCP代理 - 已完善)
 - src/proxy/load_balancer.rs       286行 (负载均衡)
-- src/server/mod.rs                364行 (HTTP服务器 - 集成TCP代理)
+- src/server/mod.rs                273行 (HTTP服务器)
 - src/proxy/health_check.rs        178行 (健康检查)
 - src/proxy/forward_proxy.rs       150行 (转发代理)
 - src/config/mod.rs                147行 (配置管理)
 - src/proxy/connection_pool.rs     100行 (连接池)
+- src/proxy/tcp_proxy.rs            87行 (TCP代理)
 ```
 
 ### 🎯 功能完成度
@@ -41,8 +41,8 @@
 | HTTP服务器 | ✅ 完成 | 100% |
 | 静态文件服务 | ✅ 完成 | 100% |
 | 反向代理 | ✅ 完成 | 100% |
-| TCP代理 | ✅ 完成 | 100% |
-| WebSocket代理 | ✅ 完成 | 100% |
+| TCP代理 | 🔄 部分完成 | 50% |
+| WebSocket代理 | 🔄 基础支持 | 30% |
 | 连接池管理 | 🔄 大部分完成 | 70% |
 | 负载均衡 | 🔄 基本完成 | 90% |
 | 健康检查 | 🔄 部分完成 | 60% |
@@ -50,62 +50,52 @@
 
 ### 📝 已实现的v0.2.0功能
 
-1. **TCP/WebSocket代理（已完成）**
-    - 原始TCP双向数据转发
-    - WebSocket协议握手和帧转发
-    - 协议自动检测（通过HTTP Upgrade头）
-    - 连接统计和管理
-    - 错误处理和日志记录
+1. **TCP/WebSocket代理框架**
+   - 连接管理
+   - 协议检测
+   - 基础转发逻辑
 
-2. **服务器集成**
-    - CONNECT方法支持
-    - HTTP隧道处理
-    - 与配置系统集成
+2. **连接池管理**
+   - HTTP连接复用
+   - 连接数限制
+   - 空闲连接清理
+   - 统计信息
 
-3. **连接池管理**
-    - HTTP连接复用
-    - 连接数限制
-    - 空闲连接清理
-    - 统计信息
+3. **负载均衡（5种算法）**
+   - 轮询 (Round Robin)
+   - 最少连接 (Least Connections)
+   - 加权轮询 (Weighted Round Robin)
+   - IP哈希 (IP Hash)
+   - 随机选择 (Random)
 
-4. **负载均衡（5种算法）**
-    - 轮询 (Round Robin)
-    - 最少连接 (Least Connections)
-    - 加权轮询 (Weighted Round Robin)
-    - IP哈希 (IP Hash)
-    - 随机选择 (Random)
+4. **健康检查机制**
+   - HTTP健康检查
+   - TCP连接检查
+   - 响应时间监控
 
-5. **健康检查机制**
-    - HTTP健康检查
-    - TCP连接检查
-    - 响应时间监控
-
-6. **配置增强**
-    - 连接池配置选项
-    - 健康检查配置选项
-    - 负载均衡策略配置
-
-7. **测试覆盖**
-    - TCP代理集成测试
-    - 连接管理测试
-    - 协议检测测试
+5. **配置增强**
+   - 连接池配置选项
+   - 健康检查配置选项
+   - 负载均衡策略配置
 
 ### 🔧 待完善功能
 
 1. **高优先级**
-    - 负载均衡与反向代理集成
-    - 健康检查与负载均衡联动
+   - TCP代理实际转发逻辑
+   - WebSocket消息转发实现
+   - 负载均衡与反向代理集成
+   - 健康检查与负载均衡联动
 
 2. **中优先级**
-    - 连接池统计API
-    - 监控指标收集
-    - 日志增强
-    - 文档完善
+   - 连接池统计API
+   - 监控指标收集
+   - 日志增强
+   - 文档完善
 
 3. **低优先级**
-    - 性能优化
-    - 内存使用优化
-    - 基准测试
+   - 性能优化
+   - 内存使用优化
+   - 基准测试
 
 ### 📚 文档状态
 
@@ -120,19 +110,19 @@
 ### 🚀 下一步计划
 
 1. **立即任务** (本周)
-    - 集成负载均衡到反向代理
-    - 实现健康检查自动化
-    - 完善连接池管理
+   - 集成负载均衡到反向代理
+   - 实现TCP代理实际转发
+   - 完善WebSocket支持
 
 2. **短期目标** (2周内)
-    - 添加更多测试
-    - 监控指标API
-    - 日志增强
+   - 实现健康检查自动化
+   - 完善连接池管理
+   - 添加更多测试
 
 3. **中期目标** (1个月内)
-    - 开始v0.3.0开发
-    - SSL/TLS支持
-    - 完整JavaScript引擎集成
+   - 开始v0.3.0开发
+   - SSL/TLS支持
+   - 完整JavaScript引擎集成
 
 ### 💡 技术亮点
 
@@ -161,6 +151,6 @@
 
 ---
 
-*生成时间: 2026年1月17日*
-*版本: v0.2.1*
-*状态: 编译通过，测试通过，TCP代理功能已完成*
+*生成时间: 2025年1月16日*
+*版本: v0.2.0*
+*状态: 编译通过，测试通过*

doc/status.md

@@ -1,9 +1,9 @@
 # rhttpd 项目状态汇总
 
 ## 版本信息
-- **当前版本**: v0.2.1
+- **当前版本**: v0.2.0
 - **构建状态**: ✅ 编译通过
-- **测试状态**: ✅ 9个测试全部通过
+- **测试状态**: ✅ 7个测试全部通过
 - **代码质量**: ✅ 通过clippy检查（仅警告）
 
 ## 功能实现进度
@@ -11,11 +11,11 @@
 | 模块 | 状态 | 完成度 | 备注 |
 |------|------|--------|------|
 | 基础架构 | ✅ 完成 | 100% | 项目结构、配置系统 |
-| HTTP服务器 | ✅ 完成 | 100% | 多站点、路由系统、CONNECT支持 |
+| HTTP服务器 | ✅ 完成 | 100% | 多站点、路由系统 |
 | 静态文件服务 | ✅ 完成 | 100% | MIME检测、索引文件 |
 | 反向代理 | ✅ 完成 | 100% | 完整的HTTP代理 |
-| TCP代理 | ✅ 完成 | 100% | 双向转发、协议检测 |
-| WebSocket代理 | ✅ 完成 | 100% | 握手、消息转发 |
+| TCP代理 | 🔄 部分完成 | 50% | 框架实现，转发逻辑待完善 |
+| WebSocket代理 | 🔄 基础支持 | 30% | 握手和消息转发框架 |
 | 连接池管理 | 🔄 大部分完成 | 70% | 需要整合到服务器 |
 | 负载均衡 | 🔄 基本完成 | 90% | 五种算法实现完成 |
 | 健康检查 | 🔄 部分完成 | 60% | 检查机制需要完善 |
@@ -26,19 +26,19 @@
 ## 代码统计
 
 ```
-总计代码行数: ~2000行
+总计代码行数: 1411行
 
 主要模块:
-- src/proxy/tcp_proxy.rs           410行
 - src/proxy/load_balancer.rs       286行
-- src/server/mod.rs                364行
+- src/server/mod.rs                273行
 - src/proxy/health_check.rs        178行
 - src/proxy/forward_proxy.rs       150行
 - src/config/mod.rs                147行
 - src/proxy/connection_pool.rs     100行
-- tests/integration_tests.rs       115行
+- src/proxy/tcp_proxy.rs            87行
+- tests/integration_tests.rs        74行
 - src/main.rs                       67行
-- src/proxy/mod.rs                  61行
+- src/proxy/mod.rs                  60行
 - src/js_engine/mod.rs              76行
 ```
 
@@ -57,8 +57,6 @@
 - ✅ 基于Host头的路由
 - ✅ 路径模式匹配
 - ✅ 请求日志记录
-- ✅ CONNECT方法支持
-- ✅ HTTP隧道处理
 
 ### 📁 静态文件服务 (100%)
 - ✅ MIME类型自动检测
@@ -72,18 +70,11 @@
 - ✅ 头部重写和传递
 - ✅ 错误处理和超时
 
-### 🌊 TCP代理 (100%)
-- ✅ 原始TCP流量双向转发
-- ✅ 协议自动检测
-- ✅ 连接统计和管理
-- ✅ 错误处理和日志记录
-- ✅ HTTP隧道支持（CONNECT）
-
-### 🔄 WebSocket代理 (100%)
-- ✅ WebSocket握手转发
-- ✅ WebSocket消息双向转发
-- ✅ 协议识别
-- ✅ 连接生命周期管理
+### 🌊 TCP代理 (50%)
+- ✅ 连接管理框架
+- ✅ 协议检测框架
+- ⏳ 原始TCP流量转发
+- ⏳ WebSocket完整支持
 
 ### ⚖️ 负载均衡 (90%)
 - ✅ 轮询 (Round Robin)
@@ -110,22 +101,22 @@
 ### 已修复问题 ✅
 1. ~~**ForwardProxy缺少Clone trait**~~ - 已修复
 2. ~~**TcpProxyManager缺少Clone trait**~~ - 已修复
-3. ~~**TCP代理转发逻辑未实现**~~ - 已完成
-4. ~~**WebSocket支持不完整**~~ - 已完成
 
 ### Clippy警告 (非阻塞)
 1. 未使用的字段警告
    - `ConnectionPool.idle_timeout` - 可在未来使用
    - `ProxyServer.forward_proxy` - 待集成
+   - `ProxyServer.tcp_proxy_manager` - 待集成
 2. 测试模块命名建议
    - `mod tests` 与同名模块 - 可忽略
 3. 无用的断言 `assert!(true)` - 可移除
 
 ### 待完善功能
-1. 负载均衡与反向代理集成
-2. 健康检查与负载均衡联动
-3. 连接池统计信息API
-4. 监控指标收集
+1. TCP代理实际转发逻辑
+2. WebSocket消息转发实现
+3. 负载均衡与反向代理集成
+4. 健康检查与负载均衡联动
+5. 连接池统计信息API
 
 ## 性能指标 (预估)
 
@@ -136,29 +127,31 @@
 
 ## 下一步重点
 
-### 优先级1 (功能完善)
-1. 负载均衡与反向代理集成
-2. 健康检查自动化
-3. 健康检查与负载均衡联动
+### 优先级1 (立即修复)
+1. 修复ForwardProxy和TcpProxyManager的Clone trait
+2. 确保编译通过
+3. 运行测试验证
 
-### 优先级2 (集成优化)
+### 优先级2 (功能完善)
+1. TCP代理实际转发实现
+2. WebSocket完整支持
+3. 负载均衡与反向代理集成
+4. 健康检查自动化
+
+### 优先级3 (集成优化)
 1. 连接池统计API
 2. 监控指标收集
 3. 日志增强
 4. 文档完善
 
-### 优先级3 (性能优化)
-1. 性能基准测试
-2. 内存使用优化
-3. 并发性能调优
-
 ## 已知限制
 
 - ❌ 不支持SSL/TLS (计划v0.3.0)
+- ❌ TCP代理转发未实现
+- ❌ WebSocket消息转发不完整
 - ❌ 负载均衡未集成到实际请求处理
 - ❌ JavaScript引擎仅为占位符
 - ❌ 缺乏监控和管理接口
-- ❌ 健康检查未自动化
 
 ## 配置示例文件
 
@@ -174,53 +167,55 @@
 - ✅ doc/require.md - 需求文档
 - ✅ CHANGELOG.md - 变更日志
 - ✅ doc/status.md - 状态汇总 (本文档)
-- ✅ PROGRESS.md - 进度总结
 
-## 验证步骤
+## 快速修复步骤
 
 ```bash
-# 1. 验证编译
-cargo check
+# 1. 修复ForwardProxy Clone trait
+# 编辑 src/proxy/forward_proxy.rs:13
+#[derive(Clone)]
+pub struct ForwardProxy {
+    ...
+}
 
-# 2. 运行测试
+# 2. 修复TcpProxyManager Clone trait
+# 编辑 src/proxy/tcp_proxy.rs:9
+#[derive(Clone)]
+pub struct TcpProxyManager {
+    ...
+}
+
+# 3. 验证编译
+cargo build
+
+# 4. 运行测试
 cargo test
 
-# 3. 代码格式化
-cargo fmt
-
-# 4. 代码检查
+# 5. 代码检查
 cargo clippy --all-targets --all-features
-
-# 5. 运行服务器（可选）
-cargo run
 ```
 
 ## 测试计划
 
 ### 单元测试
-- ✅ 配置加载和验证
-- ✅ 路径模式匹配
-- ✅ 负载均衡算法
-- ✅ 健康检查机制
-- ✅ 连接池管理
-- ✅ TCP代理连接管理
-- ✅ 协议检测
+- 配置加载和验证
+- 路径模式匹配
+- 负载均衡算法
+- 健康检查机制
+- 连接池管理
 
 ### 集成测试
-- ✅ 多站点托管
-- ✅ 反向代理功能
-- ✅ 静态文件服务
-- ✅ 路由优先级
-- ✅ TCP代理基础功能
-- ✅ 连接统计
+- 多站点托管
+- 反向代理功能
+- 静态文件服务
+- 路由优先级
 
-### 性能测试 (待添加)
+### 性能测试
 - 并发请求处理
 - 长连接保持
 - 内存使用监控
-- TCP转发性能
 
 ---
 
-*最后更新: 2026年1月17日*
-*项目进度: v0.2.1 - TCP/WebSocket代理功能已完成*
+*最后更新: 2025年1月16日*
+*项目进度: v0.2.0 - 需要修复编译错误后继续开发*

src/proxy/tcp_proxy.rs

@@ -1,10 +1,9 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
-use tokio::io::{AsyncReadExt, AsyncWriteExt, copy_bidirectional};
 use tokio::net::TcpStream;
 use tokio::sync::RwLock;
-use tracing::{error, info, warn};
+use tracing::info;
 
 #[derive(Debug, Clone)]
 pub struct TcpProxyManager {
@@ -28,19 +27,6 @@ pub enum ProxyProtocol {
     AutoDetect,
 }
 
-#[derive(Debug, Clone)]
-pub struct ProxyError {
-    pub message: String,
-}
-
-impl std::fmt::Display for ProxyError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.message)
-    }
-}
-
-impl std::error::Error for ProxyError {}
-
 impl TcpProxyManager {
     pub fn new() -> Self {
         Self {
@@ -51,263 +37,29 @@ impl TcpProxyManager {
 
     pub async fn handle_tcp_proxy(
         &self,
-        mut client_stream: TcpStream,
+        _client_stream: TcpStream,
         target: &str,
         protocol: ProxyProtocol,
     ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        let connection_id = format!(
-            "{}:{}->{}",
-            client_stream.local_addr()?.ip(),
-            client_stream.local_addr()?.port(),
-            target
-        );
-
-        info!(
-            "Starting TCP proxy connection {} to {} with protocol {:?}",
-            connection_id, target, protocol
-        );
-
-        let actual_protocol = if matches!(protocol, ProxyProtocol::AutoDetect) {
-            self.detect_protocol(&mut client_stream).await?
-        } else {
-            protocol
-        };
-
-        match actual_protocol {
+        match protocol {
             ProxyProtocol::Tcp => {
-                self.handle_raw_tcp(&mut client_stream, target, &connection_id)
-                    .await?
+                info!("Handling raw TCP proxy to: {}", target);
+                // Simplified TCP proxy implementation
+                Ok(())
             }
             ProxyProtocol::WebSocket => {
-                self.handle_websocket(&mut client_stream, target, &connection_id)
-                    .await?
+                info!("Handling WebSocket proxy to: {}", target);
+                // Simplified WebSocket proxy implementation
+                Ok(())
             }
             ProxyProtocol::AutoDetect => {
-                warn!("Auto-detect should have been resolved to a specific protocol");
-                self.handle_raw_tcp(&mut client_stream, target, &connection_id)
-                    .await?
-            }
-        }
-
-        self.update_connection_stats(&connection_id, target).await;
-        info!("TCP proxy connection {} completed", connection_id);
-
-        Ok(())
-    }
-
-    async fn detect_protocol(
-        &self,
-        client_stream: &mut TcpStream,
-    ) -> Result<ProxyProtocol, Box<dyn std::error::Error + Send + Sync>> {
-        client_stream.set_nodelay(true)?;
-        let mut peek_buf = [0u8; 1024];
-
-        match client_stream.peek(&mut peek_buf).await {
-            Ok(0) => return Ok(ProxyProtocol::Tcp),
-            Ok(n) => {
-                let header = String::from_utf8_lossy(&peek_buf[..n]);
-                if header.contains("Upgrade: websocket")
-                    || header.contains("upgrade: websocket")
-                    || header.contains("UPGRADE: websocket")
-                {
-                    info!("Detected WebSocket protocol from handshake");
-                    return Ok(ProxyProtocol::WebSocket);
-                }
-                Ok(ProxyProtocol::Tcp)
-            }
-            Err(e) => {
-                warn!("Failed to peek at client stream: {}", e);
-                Ok(ProxyProtocol::Tcp)
-            }
-        }
-    }
-
-    async fn handle_raw_tcp(
-        &self,
-        client_stream: &mut TcpStream,
-        target: &str,
-        connection_id: &str,
-    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        info!("Establishing raw TCP connection to: {}", target);
-        let mut server_stream = TcpStream::connect(target).await.map_err(|e| {
-            error!("Failed to connect to target {}: {}", target, e);
-            ProxyError {
-                message: format!("Failed to connect to target {}: {}", target, e),
-            }
-        })?;
-
-        info!(
-            "Established TCP connection {} -> {}",
-            connection_id,
-            server_stream.peer_addr()?
-        );
-
-        client_stream.set_nodelay(true)?;
-        server_stream.set_nodelay(true)?;
-
-        let result = copy_bidirectional(client_stream, &mut server_stream).await;
-
-        match result {
-            Ok((client_bytes, server_bytes)) => {
-                info!(
-                    "TCP proxy {} transferred {} bytes (client->server) and {} bytes (server->client)",
-                    connection_id, client_bytes, server_bytes
-                );
+                info!("Auto-detect TCP proxy to: {}", target);
+                // For auto-detect, default to raw TCP
                 Ok(())
             }
-            Err(e) => {
-                error!("TCP proxy {} failed: {}", connection_id, e);
-                Err(Box::new(ProxyError {
-                    message: format!("TCP proxy failed: {}", e),
-                }))
-            }
         }
     }
 
-    async fn handle_websocket(
-        &self,
-        client_stream: &mut TcpStream,
-        target: &str,
-        connection_id: &str,
-    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        info!("Establishing WebSocket connection to: {}", target);
-
-        let mut server_stream = TcpStream::connect(target).await.map_err(|e| {
-            error!("Failed to connect to WebSocket target {}: {}", target, e);
-            ProxyError {
-                message: format!("Failed to connect to WebSocket target {}: {}", target, e),
-            }
-        })?;
-
-        client_stream.set_nodelay(true)?;
-        server_stream.set_nodelay(true)?;
-
-        if let Err(e) = self
-            .forward_websocket_handshake(client_stream, &mut server_stream)
-            .await
-        {
-            error!(
-                "WebSocket handshake failed for connection {}: {}",
-                connection_id, e
-            );
-            return Err(Box::new(e));
-        }
-
-        info!(
-            "WebSocket handshake completed for connection {} -> {}",
-            connection_id,
-            server_stream.peer_addr()?
-        );
-
-        let result = copy_bidirectional(client_stream, &mut server_stream).await;
-
-        match result {
-            Ok((client_bytes, server_bytes)) => {
-                info!(
-                    "WebSocket proxy {} transferred {} bytes (client->server) and {} bytes (server->client)",
-                    connection_id, client_bytes, server_bytes
-                );
-                Ok(())
-            }
-            Err(e) => {
-                error!("WebSocket proxy {} failed: {}", connection_id, e);
-                Err(Box::new(ProxyError {
-                    message: format!("WebSocket proxy failed: {}", e),
-                }))
-            }
-        }
-    }
-
-    async fn forward_websocket_handshake(
-        &self,
-        client_stream: &mut TcpStream,
-        server_stream: &mut TcpStream,
-    ) -> Result<(), ProxyError> {
-        let mut handshake = Vec::new();
-        let mut buf = [0u8; 1];
-        let mut header_end_found = false;
-
-        while !header_end_found {
-            match client_stream.read(&mut buf).await {
-                Ok(0) => {
-                    return Err(ProxyError {
-                        message: "Client closed connection before handshake completed".to_string(),
-                    });
-                }
-                Ok(n) => {
-                    handshake.extend_from_slice(&buf[..n]);
-                    if handshake.len() >= 4
-                        && handshake[handshake.len() - 4..] == [b'\r', b'\n', b'\r', b'\n']
-                    {
-                        header_end_found = true;
-                    }
-                }
-                Err(e) => {
-                    return Err(ProxyError {
-                        message: format!("Error reading handshake: {}", e),
-                    });
-                }
-            }
-        }
-
-        server_stream
-            .write_all(&handshake)
-            .await
-            .map_err(|e| ProxyError {
-                message: format!("Failed to write handshake to server: {}", e),
-            })?;
-
-        let mut response_buf = [0u8; 1024];
-        let mut response = Vec::new();
-        let mut response_end_found = false;
-
-        while !response_end_found {
-            match server_stream.read(&mut response_buf).await {
-                Ok(0) => {
-                    return Err(ProxyError {
-                        message: "Server closed connection before handshake completed".to_string(),
-                    });
-                }
-                Ok(n) => {
-                    response.extend_from_slice(&response_buf[..n]);
-                    if response.len() >= 4
-                        && response[response.len() - 4..] == [b'\r', b'\n', b'\r', b'\n']
-                    {
-                        response_end_found = true;
-                    }
-                }
-                Err(e) => {
-                    return Err(ProxyError {
-                        message: format!("Error reading handshake response: {}", e),
-                    });
-                }
-            }
-        }
-
-        client_stream
-            .write_all(&response)
-            .await
-            .map_err(|e| ProxyError {
-                message: format!("Failed to write handshake response to client: {}", e),
-            })?;
-
-        info!("WebSocket handshake forwarded successfully");
-        Ok(())
-    }
-
-    async fn update_connection_stats(&self, connection_id: &str, target: &str) {
-        let mut connections = self.connections.write().await;
-        let conn = connections
-            .entry(connection_id.to_string())
-            .or_insert_with(|| TcpConnection {
-                target: target.to_string(),
-                created_at: Instant::now(),
-                request_count: 0,
-                bytes_transferred: 0,
-            });
-        conn.request_count += 1;
-    }
-
     pub async fn cleanup_expired(&self, max_age: Duration) {
         let mut connections = self.connections.write().await;
         connections.retain(|_, conn| conn.created_at.elapsed() < max_age);

src/server/mod.rs

@@ -2,17 +2,17 @@ use axum::{
     Router,
     body::Body,
     extract::{Request, State},
-    http::{Method, StatusCode, Uri},
+    http::StatusCode,
     response::{IntoResponse, Response},
     routing::any,
 };
 use std::sync::Arc;
-use tokio::net::{TcpListener, TcpStream};
+use tokio::net::TcpListener;
 use tracing::{error, info};
 
 use crate::config::{RouteRule, ServerConfig, SiteConfig};
 use crate::proxy::forward_proxy::ForwardProxy;
-use crate::proxy::tcp_proxy::{ProxyProtocol, TcpProxyManager};
+use crate::proxy::tcp_proxy::TcpProxyManager;
 
 #[derive(Clone)]
 pub struct ProxyServer {
@@ -118,22 +118,19 @@ pub async fn handle_request(State(server): State<ProxyServer>, req: Request<Body
         RouteRule::TcpProxy {
             target, protocol, ..
         } => {
-            if req.method() == Method::CONNECT {
-                handle_connect_request(req, target, protocol, &server.tcp_proxy_manager).await
-            } else {
-                info!(
-                    "TCP proxy requested for {} with protocol {:?}",
+            // For now, return a simple response indicating TCP proxy is not fully implemented
+            info!(
+                "TCP proxy requested for {} with protocol {:?}",
+                target, protocol
+            );
+            (
+                StatusCode::NOT_IMPLEMENTED,
+                format!(
+                    "TCP proxy to {} (protocol: {:?}) - use CONNECT method for raw TCP",
                     target, protocol
-                );
-                (
-                    StatusCode::METHOD_NOT_ALLOWED,
-                    format!(
-                        "TCP proxy to {} (protocol: {:?}) - use CONNECT method for raw TCP",
-                        target, protocol
-                    ),
-                )
-                    .into_response()
-            }
+                ),
+            )
+                .into_response()
         }
     }
 }
@@ -274,68 +271,3 @@ async fn handle_reverse_proxy(req: Request<Body>, target: &str) -> Response {
         }
     }
 }
-
-async fn handle_connect_request(
-    req: Request<Body>,
-    target: &str,
-    protocol: &crate::config::ProtocolType,
-    tcp_proxy: &TcpProxyManager,
-) -> Response {
-    info!("Handling CONNECT request to {}", target);
-
-    let target_address = match parse_connect_target(req.uri(), target) {
-        Some(addr) => addr,
-        None => {
-            error!("Invalid CONNECT target");
-            return (StatusCode::BAD_REQUEST, "Invalid CONNECT target").into_response();
-        }
-    };
-
-    info!("Connecting to target: {}", target_address);
-
-    match TcpStream::connect(&target_address).await {
-        Ok(target_stream) => {
-            let protocol_type = match protocol {
-                crate::config::ProtocolType::WebSocket => ProxyProtocol::WebSocket,
-                crate::config::ProtocolType::Tcp => ProxyProtocol::Tcp,
-                crate::config::ProtocolType::Http => ProxyProtocol::Tcp,
-            };
-
-            let tcp_proxy = tcp_proxy.clone();
-            tokio::spawn(async move {
-                if let Err(e) = tcp_proxy
-                    .handle_tcp_proxy(target_stream, &target_address, protocol_type)
-                    .await
-                {
-                    error!("TCP proxy failed: {}", e);
-                }
-            });
-
-            Response::builder()
-                .status(StatusCode::OK)
-                .header("Connection", "close")
-                .body(Body::empty())
-                .unwrap_or_else(|_| {
-                    (
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        "Failed to create response",
-                    )
-                        .into_response()
-                })
-        }
-        Err(e) => {
-            error!("Failed to connect to target {}: {}", target_address, e);
-            (StatusCode::BAD_GATEWAY, format!("Failed to connect: {}", e)).into_response()
-        }
-    }
-}
-
-fn parse_connect_target(uri: &Uri, _default_target: &str) -> Option<String> {
-    let authority = uri.authority()?.as_str();
-
-    if authority.contains(':') {
-        Some(authority.to_string())
-    } else {
-        format!("{}:443", authority).into()
-    }
-}

tests/integration_tests.rs

@@ -1,7 +1,5 @@
 use rhttpd::{config::ServerConfig, server::ProxyServer};
 use std::collections::HashMap;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-use tokio::net::TcpListener;
 
 #[tokio::test]
 async fn test_static_file_serving() {
@@ -74,44 +72,3 @@ async fn test_load_balancer() {
     let stats = lb.get_stats().await;
     assert_eq!(stats.total_upstreams, 2);
 }
-
-#[tokio::test]
-async fn test_tcp_proxy() {
-    use rhttpd::proxy::tcp_proxy::TcpProxyManager;
-
-    let _manager = TcpProxyManager::new();
-
-    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-    let local_addr = listener.local_addr().unwrap();
-    let target_addr = format!("{}:{}", local_addr.ip(), local_addr.port());
-
-    tokio::spawn(async move {
-        if let Ok((mut stream, _)) = listener.accept().await {
-            let mut buf = [0u8; 1024];
-            if let Ok(_n) = stream.read(&mut buf).await {
-                let _ = stream.write_all(b"Hello from server").await;
-            }
-        }
-    });
-
-    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
-
-    let mut test_stream = tokio::net::TcpStream::connect(&target_addr).await.unwrap();
-    let _ = test_stream.write_all(b"Hello from client").await;
-
-    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
-}
-
-#[tokio::test]
-async fn test_tcp_proxy_manager_stats() {
-    use rhttpd::proxy::tcp_proxy::TcpProxyManager;
-
-    let _manager = TcpProxyManager::new();
-    let _manager_clone = TcpProxyManager::new();
-    let stats = _manager_clone.get_stats().await;
-    assert_eq!(stats.len(), 0);
-
-    _manager
-        .cleanup_expired(std::time::Duration::from_secs(0))
-        .await;
-}