kcptun-rust 1.1.0

// 简单的 KCP 服务器 - 用于测试与 Go 客户端的兼容性

use rust_tokio_kcp::{KcpConfig, KcpListener, KcpNoDelayConfig};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use anyhow::Result;
use std::net::SocketAddr;

#[tokio::main]
async fn main() -> Result<()> {
    println!("=== 简单的 KCP 服务器 ===");
    println!("监听地址: 127.0.0.1:29900");
    println!("使用 --crypt none（无加密）");
    println!();
    
    let listen_addr: SocketAddr = "127.0.0.1:29900".parse()?;
    
    // 最简单的 KCP 配置（无加密）
    let kcp_config = KcpConfig {
        mtu: 1350,
        nodelay: KcpNoDelayConfig {
            nodelay: false,
            interval: 30,
            resend: 2,
            nc: true,
        },
        wnd_size: (1024, 1024),
        stream: true,
        flush_write: false,
        flush_acks_input: false,
        fec_data_shards: 0,  // 禁用 FEC
        fec_parity_shards: 0,
        crypt: None,  // 不加密
        ..Default::default()
    };
    
    let mut listener = KcpListener::bind(kcp_config, listen_addr).await?;
    println!("✓ KCP 服务器已启动");
    println!("等待连接...");
    println!();
    
    loop {
        match listener.accept().await {
            Ok((mut stream, peer_addr)) => {
                println!("✓ 接受连接: {}", peer_addr);
                
                tokio::spawn(async move {
                    let mut buf = vec![0u8; 4096];
                    
                    loop {
                        match stream.read(&mut buf).await {
                            Ok(0) => {
                                println!("  连接关闭: {}", peer_addr);
                                break;
                            }
                            Ok(n) => {
                                println!("  收到 {} 字节: {:?}", n, String::from_utf8_lossy(&buf[..n]));
                                
                                // Echo 回去
                                if let Err(e) = stream.write_all(&buf[..n]).await {
                                    println!("  写入错误: {}", e);
                                    break;
                                }
                                
                                if let Err(e) = stream.flush().await {
                                    println!("  刷新错误: {}", e);
                                    break;
                                }
                                
                                println!("  已回复 {} 字节", n);
                            }
                            Err(e) => {
                                println!("  读取错误: {}", e);
                                break;
                            }
                        }
                    }
                });
            }
            Err(e) => {
                println!("✗ 接受连接失败: {}", e);
            }
        }
    }
}