package main

import (
        "flag"
        "fmt"
        "log"
        "os"

        "github.com/azoic/wormhole-client/internal/client"
)

var (
        version   = "v1.0.0"
        buildTime = "unknown"
)

func main() {
        configPath := flag.String("config", "configs/client.yaml", "Configuration file path")
        mode := flag.String("mode", "http", "Client mode: http, global, transparent")
        showVersion := flag.Bool("version", false, "Show version information")
        flag.Parse()

        if *showVersion {
                fmt.Printf("Wormhole SOCKS5 Client %s\n", version)
                fmt.Printf("Build time: %s\n", buildTime)
                os.Exit(0)
        }

        fmt.Printf("🚀 Starting Wormhole SOCKS5 Client %s\n", version)
        fmt.Printf("📄 Config: %s\n", *configPath)
        fmt.Printf("🔧 Mode: %s\n", *mode)

        // TODO: 实现完整的客户端逻辑
        cli := client.NewClient(*mode)
        if err := cli.Start(*configPath); err != nil {
                log.Fatalf("Client failed: %v", err)
        }
}

package client

import (
        "fmt"
        "os"
        "os/signal"
        "syscall"

        "github.com/azoic/wormhole-client/internal/config"
        "github.com/azoic/wormhole-client/internal/proxy"
        "github.com/azoic/wormhole-client/internal/system"
        "github.com/azoic/wormhole-client/pkg/dns"
        "github.com/azoic/wormhole-client/pkg/logger"
)

type Client struct {
        mode           string
        config         *config.Config
        socks5Proxy    *proxy.SOCKS5Proxy
        dnsProxy       *dns.DNSProxy
        systemProxyMgr *system.SystemProxyManager
}

func NewClient(mode string) *Client {
        return &Client{
                mode:           mode,
                systemProxyMgr: system.NewSystemProxyManager(),
        }
}

func (c *Client) Start(configPath string) error {
        // 加载配置
        cfg, err := config.LoadConfig(configPath)
        if err != nil {
                return fmt.Errorf("failed to load config: %v", err)
        }

        if err := cfg.Validate(); err != nil {
                return fmt.Errorf("invalid config: %v", err)
        }

        c.config = cfg

        // 设置日志级别
        logger.SetLevel(cfg.LogLevel)

        logger.Info("🚀 Starting Wormhole SOCKS5 Client")
        logger.Info("📄 Config loaded from: %s", configPath)
        logger.Info("🔧 Mode: %s", c.mode)
        logger.Info("🎯 SOCKS5 Server: %s", cfg.GetServerAddr())

        // 创建SOCKS5代理客户端
        c.socks5Proxy = proxy.NewSOCKS5Proxy(
                cfg.GetServerAddr(),
                cfg.Server.Username,
                cfg.Server.Password,
                cfg.Timeout,
        )

        // 设置信号处理
        c.setupSignalHandler()

        switch c.mode {
        case "http":
                return c.startHTTPProxy()
        case "global":
                return c.startGlobalProxy()
        case "transparent":
                return c.startTransparentProxy()
        default:
                return fmt.Errorf("unsupported mode: %s", c.mode)
        }
}

func (c *Client) startHTTPProxy() error {
        logger.Info("🌐 Starting HTTP proxy mode...")
        logger.Info("💡 Setting up HTTP proxy on port %d", c.config.Proxy.LocalPort)

        server := c.socks5Proxy.CreateHTTPProxy(c.config.Proxy.LocalPort)

        logger.Info("✅ HTTP proxy started on :%d", c.config.Proxy.LocalPort)
        logger.Info("💡 Configure your browser to use HTTP proxy: 127.0.0.1:%d", c.config.Proxy.LocalPort)

        return server.ListenAndServe()
}

func (c *Client) startGlobalProxy() error {
        logger.Info("🌍 Starting global proxy mode...")
        logger.Info("💡 This will configure system-wide proxy settings")
        logger.Info("⚠️  Requires administrator privileges")

        // 启动HTTP代理服务器
        server := c.socks5Proxy.CreateHTTPProxy(c.config.Proxy.LocalPort)
        go func() {
                if err := server.ListenAndServe(); err != nil {
                        logger.Error("HTTP proxy server failed: %v", err)
                }
        }()

        // 设置系统代理
        httpProxy := fmt.Sprintf("127.0.0.1:%d", c.config.Proxy.LocalPort)
        httpsProxy := httpProxy

        if err := c.systemProxyMgr.SetGlobalProxy(httpProxy, httpsProxy, ""); err != nil {
                logger.Error("Failed to set system proxy: %v", err)
                logger.Warn("You may need to run with administrator privileges")
                logger.Info("Manual setup: Set HTTP/HTTPS proxy to %s", httpProxy)
        } else {
                logger.Info("✅ System proxy configured successfully")
        }

        // 启动DNS代理（如果启用）
        if c.config.GlobalProxy.DNSProxy {
                logger.Info("🔍 Starting DNS proxy on port %d", c.config.GlobalProxy.DNSPort)
                c.dnsProxy = dns.NewDNSProxy("8.8.8.8:53", c.config.GlobalProxy.DNSPort)
                if err := c.dnsProxy.Start(); err != nil {
                        logger.Warn("Failed to start DNS proxy: %v", err)
                } else {
                        logger.Info("✅ DNS proxy started")
                }
        }

        logger.Info("🎉 Global proxy mode started successfully")
        logger.Info("📍 HTTP/HTTPS Proxy: %s", httpProxy)
        if c.dnsProxy != nil {
                logger.Info("📍 DNS Proxy: 127.0.0.1:%d", c.config.GlobalProxy.DNSPort)
        }

        // 保持运行
        select {}
}

func (c *Client) startTransparentProxy() error {
        logger.Info("🔍 Starting transparent proxy mode...")
        logger.Info("💡 This will intercept network traffic transparently")
        logger.Info("⚠️  Requires root privileges and iptables support")
        logger.Error("❌ Transparent proxy mode is not yet implemented")

        return fmt.Errorf("transparent proxy mode not implemented")
}

func (c *Client) setupSignalHandler() {
        sigChan := make(chan os.Signal, 1)
        signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

        go func() {
                <-sigChan
                logger.Info("🛑 Shutting down...")
                c.cleanup()
                os.Exit(0)
        }()
}

func (c *Client) cleanup() {
        // 恢复系统代理设置
        if c.systemProxyMgr != nil {
                if err := c.systemProxyMgr.RestoreProxy(); err != nil {
                        logger.Error("Failed to restore system proxy: %v", err)
                }
        }

        // 停止DNS代理
        if c.dnsProxy != nil {
                if err := c.dnsProxy.Stop(); err != nil {
                        logger.Error("Failed to stop DNS proxy: %v", err)
                }
        }

        logger.Info("✅ Cleanup completed")
}

package config

import (
        "fmt"
        "io/ioutil"
        "time"

        "gopkg.in/yaml.v3"
)

// Config 客户端配置结构
type Config struct {
        ServiceType      string           `yaml:"serviceType"`
        Server           Server           `yaml:"server"`
        Proxy            Proxy            `yaml:"proxy"`
        GlobalProxy      GlobalProxy      `yaml:"globalProxy"`
        TransparentProxy TransparentProxy `yaml:"transparentProxy"`
        LogLevel         string           `yaml:"logLevel"`
        Timeout          time.Duration    `yaml:"timeout"`
}

// Server SOCKS5服务器配置
type Server struct {
        Address  string `yaml:"address"`
        Port     int    `yaml:"port"`
        Username string `yaml:"username"`
        Password string `yaml:"password"`
}

// Proxy 代理模式配置
type Proxy struct {
        Mode      string `yaml:"mode"`
        LocalPort int    `yaml:"localPort"`
}

// GlobalProxy 全局代理配置
type GlobalProxy struct {
        Enabled  bool    `yaml:"enabled"`
        DNSProxy bool    `yaml:"dnsProxy"`
        DNSPort  int     `yaml:"dnsPort"`
        Routing  Routing `yaml:"routing"`
}

// TransparentProxy 透明代理配置
type TransparentProxy struct {
        Enabled     bool `yaml:"enabled"`
        Port        int  `yaml:"port"`
        DNSPort     int  `yaml:"dnsPort"`
        ModifyDNS   bool `yaml:"modifyDNS"`
        ModifyRoute bool `yaml:"modifyRoute"`
}

// Routing 路由规则配置
type Routing struct {
        BypassLocal   bool     `yaml:"bypassLocal"`
        BypassPrivate bool     `yaml:"bypassPrivate"`
        BypassDomains []string `yaml:"bypassDomains"`
        ForceDomains  []string `yaml:"forceDomains"`
}

// LoadConfig 从文件加载配置
func LoadConfig(configPath string) (*Config, error) {
        data, err := ioutil.ReadFile(configPath)
        if err != nil {
                return nil, fmt.Errorf("failed to read config file: %v", err)
        }

        var config Config
        if err := yaml.Unmarshal(data, &config); err != nil {
                return nil, fmt.Errorf("failed to parse config file: %v", err)
        }

        // 设置默认值
        if config.LogLevel == "" {
                config.LogLevel = "info"
        }
        if config.Timeout == 0 {
                config.Timeout = 30 * time.Second
        }
        if config.Proxy.LocalPort == 0 {
                config.Proxy.LocalPort = 8080
        }

        return &config, nil
}

// GetServerAddr 获取服务器地址
func (c *Config) GetServerAddr() string {
        return fmt.Sprintf("%s:%d", c.Server.Address, c.Server.Port)
}

// Validate 验证配置
func (c *Config) Validate() error {
        if c.Server.Address == "" {
                return fmt.Errorf("server address is required")
        }
        if c.Server.Port <= 0 || c.Server.Port > 65535 {
                return fmt.Errorf("invalid server port: %d", c.Server.Port)
        }

        validModes := map[string]bool{"http": true, "global": true, "transparent": true}
        if !validModes[c.Proxy.Mode] {
                return fmt.Errorf("invalid proxy mode: %s", c.Proxy.Mode)
        }

        return nil
}

package proxy

import (
        "context"
        "encoding/json"
        "fmt"
        "io"
        "net"
        "net/http"
        "strconv"
        "sync"
        "time"

        "github.com/azoic/wormhole-client/pkg/logger"
)

// SOCKS5Proxy SOCKS5代理客户端
type SOCKS5Proxy struct {
        serverAddr string
        username   string
        password   string
        timeout    time.Duration
        connPool   *connectionPool
        stats      *ProxyStats
}

// connectionPool 连接池
type connectionPool struct {
        connections chan net.Conn
        maxSize     int
        mutex       sync.Mutex
}

// NewSOCKS5Proxy 创建SOCKS5代理客户端
func NewSOCKS5Proxy(serverAddr, username, password string, timeout time.Duration) *SOCKS5Proxy {
        return &SOCKS5Proxy{
                serverAddr: serverAddr,
                username:   username,
                password:   password,
                timeout:    timeout,
                connPool: &connectionPool{
                        connections: make(chan net.Conn, 10),
                        maxSize:     10,
                },
                stats: NewProxyStats(),
        }
}

// CreateHTTPProxy 创建HTTP代理服务器
func (p *SOCKS5Proxy) CreateHTTPProxy(localPort int) *http.Server {
        proxyHandler := &httpProxyHandler{
                socks5Proxy: p,
        }

        // 创建ServeMux来处理不同的路径
        mux := http.NewServeMux()
        mux.Handle("/", proxyHandler)
        mux.HandleFunc("/stats", p.handleStats)
        mux.HandleFunc("/health", p.handleHealth)

        server := &http.Server{
                Addr:           fmt.Sprintf(":%d", localPort),
                Handler:        mux,
                ReadTimeout:    30 * time.Second,
                WriteTimeout:   30 * time.Second,
                IdleTimeout:    120 * time.Second,
                MaxHeaderBytes: 1 << 20, // 1MB
        }

        return server
}

// httpProxyHandler HTTP代理处理器
type httpProxyHandler struct {
        socks5Proxy *SOCKS5Proxy
}

func (h *httpProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
        // 统计连接
        h.socks5Proxy.stats.IncrementConnections()
        defer h.socks5Proxy.stats.DecrementActiveConnections()

        logger.Debug("Processing request: %s %s from %s", r.Method, r.URL.String(), r.RemoteAddr)

        if r.Method == http.MethodConnect {
                h.handleHTTPSProxy(w, r)
        } else {
                h.handleHTTPProxy(w, r)
        }
}

// handleHTTPSProxy 处理HTTPS代理请求 (CONNECT方法)
func (h *httpProxyHandler) handleHTTPSProxy(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(r.Context(), h.socks5Proxy.timeout)
        defer cancel()

        destConn, err := h.socks5Proxy.DialTCPWithContext(ctx, r.Host)
        if err != nil {
                h.socks5Proxy.stats.IncrementFailedRequests()
                h.socks5Proxy.stats.IncrementSOCKS5Error("connection_failed")
                logger.Error("Failed to connect via SOCKS5 to %s: %v", r.Host, err)
                http.Error(w, "Bad Gateway", http.StatusBadGateway)
                return
        }
        defer destConn.Close()

        // 发送200 Connection established响应
        w.WriteHeader(http.StatusOK)

        hijacker, ok := w.(http.Hijacker)
        if !ok {
                h.socks5Proxy.stats.IncrementFailedRequests()
                logger.Error("Hijacking not supported")
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
                return
        }

        clientConn, _, err := hijacker.Hijack()
        if err != nil {
                h.socks5Proxy.stats.IncrementFailedRequests()
                logger.Error("Failed to hijack connection: %v", err)
                return
        }
        defer clientConn.Close()

        h.socks5Proxy.stats.IncrementSuccessfulRequests()
        logger.Debug("Established HTTPS tunnel to %s", r.Host)

        // 双向数据转发
        var wg sync.WaitGroup
        wg.Add(2)

        go func() {
                defer wg.Done()
                written := h.copyData(clientConn, destConn, "client->server")
                h.socks5Proxy.stats.AddBytesTransferred(written, 0)
        }()

        go func() {
                defer wg.Done()
                written := h.copyData(destConn, clientConn, "server->client")
                h.socks5Proxy.stats.AddBytesTransferred(0, written)
        }()

        wg.Wait()
        logger.Debug("HTTPS tunnel to %s closed", r.Host)
}

// handleHTTPProxy 处理HTTP代理请求
func (h *httpProxyHandler) handleHTTPProxy(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(r.Context(), h.socks5Proxy.timeout)
        defer cancel()

        // 确保URL包含Host
        if r.URL.Host == "" {
                r.URL.Host = r.Host
        }
        if r.URL.Scheme == "" {
                r.URL.Scheme = "http"
        }

        // 通过SOCKS5连接到目标服务器
        destConn, err := h.socks5Proxy.DialTCPWithContext(ctx, r.Host)
        if err != nil {
                h.socks5Proxy.stats.IncrementFailedRequests()
                h.socks5Proxy.stats.IncrementSOCKS5Error("connection_failed")
                logger.Error("Failed to connect via SOCKS5 to %s: %v", r.Host, err)
                http.Error(w, "Bad Gateway", http.StatusBadGateway)
                return
        }
        defer destConn.Close()

        // 发送HTTP请求
        if err := r.Write(destConn); err != nil {
                h.socks5Proxy.stats.IncrementFailedRequests()
                logger.Error("Failed to write request to %s: %v", r.Host, err)
                http.Error(w, "Bad Gateway", http.StatusBadGateway)
                return
        }

        // 设置响应头
        w.Header().Set("Via", "1.1 wormhole-proxy")

        // 使用自定义ResponseWriter来统计字节数
        statsWriter := &statsResponseWriter{
                ResponseWriter: w,
                stats:          h.socks5Proxy.stats,
        }

        // 读取响应并返回给客户端
        written, err := io.Copy(statsWriter, destConn)
        if err != nil {
                h.socks5Proxy.stats.IncrementFailedRequests()
                logger.Error("Failed to copy response from %s: %v", r.Host, err)
                return
        }

        h.socks5Proxy.stats.IncrementSuccessfulRequests()
        h.socks5Proxy.stats.AddBytesTransferred(0, written)
        logger.Debug("HTTP request to %s completed, %d bytes", r.Host, written)
}

// statsResponseWriter 带统计功能的ResponseWriter
type statsResponseWriter struct {
        http.ResponseWriter
        stats *ProxyStats
}

func (w *statsResponseWriter) Write(data []byte) (int, error) {
        n, err := w.ResponseWriter.Write(data)
        if n > 0 {
                w.stats.AddBytesTransferred(int64(n), 0)
        }
        return n, err
}

// copyData 数据复制，带方向标识和字节统计
func (h *httpProxyHandler) copyData(dst, src net.Conn, direction string) int64 {
        defer dst.Close()
        defer src.Close()

        written, err := io.Copy(dst, src)
        if err != nil {
                logger.Debug("Copy %s finished with error: %v, bytes: %d", direction, err, written)
        } else {
                logger.Debug("Copy %s finished successfully, bytes: %d", direction, written)
        }

        return written
}

// handleStats 处理统计信息请求
func (p *SOCKS5Proxy) handleStats(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
                http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
                return
        }

        stats := p.stats.GetStats()

        w.Header().Set("Content-Type", "application/json")
        w.Header().Set("Access-Control-Allow-Origin", "*")

        if err := json.NewEncoder(w).Encode(stats); err != nil {
                logger.Error("Failed to encode stats: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
                return
        }
}

// handleHealth 处理健康检查请求
func (p *SOCKS5Proxy) handleHealth(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodGet {
                http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
                return
        }

        stats := p.stats.GetStats()

        health := map[string]interface{}{
                "status":             "healthy",
                "uptime":             stats.Uptime.String(),
                "active_connections": stats.ActiveConnections,
                "success_rate":       stats.GetSuccessRate(),
        }

        w.Header().Set("Content-Type", "application/json")

        if err := json.NewEncoder(w).Encode(health); err != nil {
                logger.Error("Failed to encode health: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
                return
        }
}

// GetStats 获取代理统计信息
func (p *SOCKS5Proxy) GetStats() ProxyStatsSnapshot {
        return p.stats.GetStats()
}

// DialTCP 通过SOCKS5连接到目标地址
func (p *SOCKS5Proxy) DialTCP(address string) (net.Conn, error) {
        return p.DialTCPWithContext(context.Background(), address)
}

// DialTCPWithContext 通过SOCKS5连接到目标地址（带上下文）
func (p *SOCKS5Proxy) DialTCPWithContext(ctx context.Context, address string) (net.Conn, error) {
        // 连接到SOCKS5代理服务器
        dialer := &net.Dialer{
                Timeout: p.timeout,
        }

        conn, err := dialer.DialContext(ctx, "tcp", p.serverAddr)
        if err != nil {
                return nil, fmt.Errorf("failed to connect to SOCKS5 server: %v", err)
        }

        // 设置连接超时
        deadline, ok := ctx.Deadline()
        if ok {
                conn.SetDeadline(deadline)
        }

        // 执行SOCKS5握手
        if err := p.performSOCKS5Handshake(conn, address); err != nil {
                conn.Close()
                return nil, fmt.Errorf("SOCKS5 handshake failed: %v", err)
        }

        // 清除deadline，让连接正常使用
        conn.SetDeadline(time.Time{})

        logger.Debug("Successfully connected to %s via SOCKS5 proxy", address)
        return conn, nil
}

// performSOCKS5Handshake 执行SOCKS5握手协议
func (p *SOCKS5Proxy) performSOCKS5Handshake(conn net.Conn, targetAddr string) error {
        // 设置握手超时
        deadline := time.Now().Add(p.timeout)
        conn.SetDeadline(deadline)

        // 第一步：发送认证方法选择
        authMethods := []byte{0x05, 0x02, 0x00, 0x02} // 版本5，2个方法，无认证+用户名密码认证
        if _, err := conn.Write(authMethods); err != nil {
                return fmt.Errorf("failed to send auth methods: %v", err)
        }

        // 读取服务器响应
        response := make([]byte, 2)
        if _, err := io.ReadFull(conn, response); err != nil {
                return fmt.Errorf("failed to read auth response: %v", err)
        }

        if response[0] != 0x05 {
                return fmt.Errorf("invalid SOCKS version: %d", response[0])
        }

        // 第二步：处理认证
        switch response[1] {
        case 0x00: // 无认证
                logger.Debug("SOCKS5 server requires no authentication")
        case 0x02: // 用户名密码认证
                if err := p.performUserPassAuth(conn); err != nil {
                        return fmt.Errorf("user/pass authentication failed: %v", err)
                }
        case 0xFF: // 无可接受的认证方法
                return fmt.Errorf("no acceptable authentication methods")
        default:
                return fmt.Errorf("unsupported authentication method: %d", response[1])
        }

        // 第三步：发送连接请求
        connectReq, err := p.buildConnectRequest(targetAddr)
        if err != nil {
                return fmt.Errorf("failed to build connect request: %v", err)
        }

        if _, err := conn.Write(connectReq); err != nil {
                return fmt.Errorf("failed to send connect request: %v", err)
        }

        // 第四步：读取连接响应
        return p.readConnectResponse(conn)
}

// buildConnectRequest 构建连接请求
func (p *SOCKS5Proxy) buildConnectRequest(targetAddr string) ([]byte, error) {
        host, portStr, err := net.SplitHostPort(targetAddr)
        if err != nil {
                return nil, fmt.Errorf("invalid target address: %v", err)
        }

        // 解析端口号
        portNum, err := parsePort(portStr)
        if err != nil {
                return nil, fmt.Errorf("invalid port: %v", err)
        }

        var connectReq []byte

        // 检测地址类型并构建请求
        if ip := net.ParseIP(host); ip != nil {
                if ip4 := ip.To4(); ip4 != nil {
                        // IPv4地址
                        connectReq = []byte{0x05, 0x01, 0x00, 0x01}
                        connectReq = append(connectReq, ip4...)
                } else if ip6 := ip.To16(); ip6 != nil {
                        // IPv6地址
                        connectReq = []byte{0x05, 0x01, 0x00, 0x04}
                        connectReq = append(connectReq, ip6...)
                }
        } else {
                // 域名
                if len(host) > 255 {
                        return nil, fmt.Errorf("domain name too long: %d", len(host))
                }
                connectReq = []byte{0x05, 0x01, 0x00, 0x03}
                connectReq = append(connectReq, byte(len(host)))
                connectReq = append(connectReq, []byte(host)...)
        }

        // 添加端口
        connectReq = append(connectReq, byte(portNum>>8), byte(portNum&0xFF))

        return connectReq, nil
}

// readConnectResponse 读取连接响应
func (p *SOCKS5Proxy) readConnectResponse(conn net.Conn) error {
        // 读取响应头部
        header := make([]byte, 4)
        if _, err := io.ReadFull(conn, header); err != nil {
                return fmt.Errorf("failed to read connect response header: %v", err)
        }

        if header[0] != 0x05 {
                return fmt.Errorf("invalid SOCKS version in response: %d", header[0])
        }

        if header[1] != 0x00 {
                return fmt.Errorf("connection failed, status: %d (%s)", header[1], getSOCKS5ErrorMessage(header[1]))
        }

        // 读取绑定地址和端口
        addrType := header[3]
        switch addrType {
        case 0x01: // IPv4
                skipBytes := make([]byte, 6) // 4字节IP + 2字节端口
                _, err := io.ReadFull(conn, skipBytes)
                return err
        case 0x03: // 域名
                lenByte := make([]byte, 1)
                if _, err := io.ReadFull(conn, lenByte); err != nil {
                        return err
                }
                skipBytes := make([]byte, int(lenByte[0])+2) // 域名长度 + 2字节端口
                _, err := io.ReadFull(conn, skipBytes)
                return err
        case 0x04: // IPv6
                skipBytes := make([]byte, 18) // 16字节IP + 2字节端口
                _, err := io.ReadFull(conn, skipBytes)
                return err
        default:
                return fmt.Errorf("unsupported address type: %d", addrType)
        }
}

// performUserPassAuth 执行用户名密码认证
func (p *SOCKS5Proxy) performUserPassAuth(conn net.Conn) error {
        // 发送用户名密码
        authData := []byte{0x01} // 子协议版本
        authData = append(authData, byte(len(p.username)))
        authData = append(authData, []byte(p.username)...)
        authData = append(authData, byte(len(p.password)))
        authData = append(authData, []byte(p.password)...)

        if _, err := conn.Write(authData); err != nil {
                return fmt.Errorf("failed to send credentials: %v", err)
        }

        // 读取认证结果
        authResult := make([]byte, 2)
        if _, err := io.ReadFull(conn, authResult); err != nil {
                return fmt.Errorf("failed to read auth result: %v", err)
        }

        if authResult[0] != 0x01 {
                return fmt.Errorf("invalid auth response version: %d", authResult[0])
        }

        if authResult[1] != 0x00 {
                return fmt.Errorf("authentication failed")
        }

        logger.Debug("SOCKS5 authentication successful")
        return nil
}

// getSOCKS5ErrorMessage 获取SOCKS5错误消息
func getSOCKS5ErrorMessage(code byte) string {
        switch code {
        case 0x01:
                return "general SOCKS server failure"
        case 0x02:
                return "connection not allowed by ruleset"
        case 0x03:
                return "network unreachable"
        case 0x04:
                return "host unreachable"
        case 0x05:
                return "connection refused"
        case 0x06:
                return "TTL expired"
        case 0x07:
                return "command not supported"
        case 0x08:
                return "address type not supported"
        default:
                return "unknown error"
        }
}

// parsePort 解析端口号
func parsePort(portStr string) (int, error) {
        if portStr == "" {
                return 80, nil // 默认HTTP端口
        }

        port, err := strconv.Atoi(portStr)
        if err != nil {
                return 0, fmt.Errorf("invalid port format: %s", portStr)
        }

        if port < 1 || port > 65535 {
                return 0, fmt.Errorf("port out of range: %d", port)
        }

        return port, nil
}

package proxy

import (
        "sync"
        "sync/atomic"
        "time"
)

// ProxyStats 代理统计信息
type ProxyStats struct {
        StartTime          time.Time
        TotalConnections   int64
        ActiveConnections  int64
        SuccessfulRequests int64
        FailedRequests     int64
        BytesSent          int64
        BytesReceived      int64
        SOCKS5Errors       map[string]int64
        mutex              sync.RWMutex
}

// NewProxyStats 创建新的统计实例
func NewProxyStats() *ProxyStats {
        return &ProxyStats{
                StartTime:    time.Now(),
                SOCKS5Errors: make(map[string]int64),
        }
}

// IncrementConnections 增加连接计数
func (s *ProxyStats) IncrementConnections() {
        atomic.AddInt64(&s.TotalConnections, 1)
        atomic.AddInt64(&s.ActiveConnections, 1)
}

// DecrementActiveConnections 减少活跃连接计数
func (s *ProxyStats) DecrementActiveConnections() {
        atomic.AddInt64(&s.ActiveConnections, -1)
}

// IncrementSuccessfulRequests 增加成功请求计数
func (s *ProxyStats) IncrementSuccessfulRequests() {
        atomic.AddInt64(&s.SuccessfulRequests, 1)
}

// IncrementFailedRequests 增加失败请求计数
func (s *ProxyStats) IncrementFailedRequests() {
        atomic.AddInt64(&s.FailedRequests, 1)
}

// AddBytesTransferred 添加传输字节数
func (s *ProxyStats) AddBytesTransferred(sent, received int64) {
        atomic.AddInt64(&s.BytesSent, sent)
        atomic.AddInt64(&s.BytesReceived, received)
}

// IncrementSOCKS5Error 增加SOCKS5错误计数
func (s *ProxyStats) IncrementSOCKS5Error(errorType string) {
        s.mutex.Lock()
        defer s.mutex.Unlock()
        s.SOCKS5Errors[errorType]++
}

// GetStats 获取统计快照
func (s *ProxyStats) GetStats() ProxyStatsSnapshot {
        s.mutex.RLock()
        defer s.mutex.RUnlock()

        errors := make(map[string]int64)
        for k, v := range s.SOCKS5Errors {
                errors[k] = v
        }

        return ProxyStatsSnapshot{
                StartTime:          s.StartTime,
                Uptime:             time.Since(s.StartTime),
                TotalConnections:   atomic.LoadInt64(&s.TotalConnections),
                ActiveConnections:  atomic.LoadInt64(&s.ActiveConnections),
                SuccessfulRequests: atomic.LoadInt64(&s.SuccessfulRequests),
                FailedRequests:     atomic.LoadInt64(&s.FailedRequests),
                BytesSent:          atomic.LoadInt64(&s.BytesSent),
                BytesReceived:      atomic.LoadInt64(&s.BytesReceived),
                SOCKS5Errors:       errors,
        }
}

// ProxyStatsSnapshot 统计快照
type ProxyStatsSnapshot struct {
        StartTime          time.Time        `json:"start_time"`
        Uptime             time.Duration    `json:"uptime"`
        TotalConnections   int64            `json:"total_connections"`
        ActiveConnections  int64            `json:"active_connections"`
        SuccessfulRequests int64            `json:"successful_requests"`
        FailedRequests     int64            `json:"failed_requests"`
        BytesSent          int64            `json:"bytes_sent"`
        BytesReceived      int64            `json:"bytes_received"`
        SOCKS5Errors       map[string]int64 `json:"socks5_errors"`
}

// GetSuccessRate 获取成功率
func (s *ProxyStatsSnapshot) GetSuccessRate() float64 {
        total := s.SuccessfulRequests + s.FailedRequests
        if total == 0 {
                return 0
        }
        return float64(s.SuccessfulRequests) / float64(total) * 100
}

// GetTotalBytes 获取总传输字节数
func (s *ProxyStatsSnapshot) GetTotalBytes() int64 {
        return s.BytesSent + s.BytesReceived
}

// GetAverageConnectionsPerHour 获取每小时平均连接数
func (s *ProxyStatsSnapshot) GetAverageConnectionsPerHour() float64 {
        hours := s.Uptime.Hours()
        if hours == 0 {
                return 0
        }
        return float64(s.TotalConnections) / hours
}

package system

import (
        "fmt"
        "os/exec"
        "runtime"
        "strings"

        "github.com/azoic/wormhole-client/pkg/logger"
)

// SystemProxyManager 系统代理管理器
type SystemProxyManager struct {
        originalSettings map[string]string
}

// NewSystemProxyManager 创建系统代理管理器
func NewSystemProxyManager() *SystemProxyManager {
        return &SystemProxyManager{
                originalSettings: make(map[string]string),
        }
}

// SetGlobalProxy 设置全局代理
func (s *SystemProxyManager) SetGlobalProxy(httpProxy, httpsProxy, socksProxy string) error {
        switch runtime.GOOS {
        case "darwin":
                return s.setMacOSProxy(httpProxy, httpsProxy, socksProxy)
        case "windows":
                return s.setWindowsProxy(httpProxy, httpsProxy, socksProxy)
        case "linux":
                return s.setLinuxProxy(httpProxy, httpsProxy, socksProxy)
        default:
                return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
        }
}

// RestoreProxy 恢复原始代理设置
func (s *SystemProxyManager) RestoreProxy() error {
        switch runtime.GOOS {
        case "darwin":
                return s.restoreMacOSProxy()
        case "windows":
                return s.restoreWindowsProxy()
        case "linux":
                return s.restoreLinuxProxy()
        default:
                return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
        }
}

// macOS 代理设置
func (s *SystemProxyManager) setMacOSProxy(httpProxy, httpsProxy, socksProxy string) error {
        logger.Info("Setting macOS system proxy...")

        // 获取网络服务名称
        networkService, err := s.getMacOSNetworkService()
        if err != nil {
                return fmt.Errorf("failed to get network service: %v", err)
        }

        // 保存原始设置
        if err := s.saveMacOSOriginalSettings(networkService); err != nil {
                logger.Warn("Failed to save original proxy settings: %v", err)
        }

        // 设置HTTP代理
        if httpProxy != "" {
                if err := s.runCommand("networksetup", "-setwebproxy", networkService,
                        s.parseProxyHost(httpProxy), s.parseProxyPort(httpProxy)); err != nil {
                        return fmt.Errorf("failed to set HTTP proxy: %v", err)
                }

                if err := s.runCommand("networksetup", "-setwebproxystate", networkService, "on"); err != nil {
                        return fmt.Errorf("failed to enable HTTP proxy: %v", err)
                }
        }

        // 设置HTTPS代理
        if httpsProxy != "" {
                if err := s.runCommand("networksetup", "-setsecurewebproxy", networkService,
                        s.parseProxyHost(httpsProxy), s.parseProxyPort(httpsProxy)); err != nil {
                        return fmt.Errorf("failed to set HTTPS proxy: %v", err)
                }

                if err := s.runCommand("networksetup", "-setsecurewebproxystate", networkService, "on"); err != nil {
                        return fmt.Errorf("failed to enable HTTPS proxy: %v", err)
                }
        }

        // 设置SOCKS代理
        if socksProxy != "" {
                if err := s.runCommand("networksetup", "-setsocksfirewallproxy", networkService,
                        s.parseProxyHost(socksProxy), s.parseProxyPort(socksProxy)); err != nil {
                        return fmt.Errorf("failed to set SOCKS proxy: %v", err)
                }

                if err := s.runCommand("networksetup", "-setsocksfirewallproxystate", networkService, "on"); err != nil {
                        return fmt.Errorf("failed to enable SOCKS proxy: %v", err)
                }
        }

        logger.Info("macOS system proxy configured successfully")
        return nil
}

// 获取macOS网络服务名称
func (s *SystemProxyManager) getMacOSNetworkService() (string, error) {
        output, err := exec.Command("networksetup", "-listallnetworkservices").Output()
        if err != nil {
                return "", err
        }

        lines := strings.Split(string(output), "\n")
        for _, line := range lines {
                line = strings.TrimSpace(line)
                if line != "" && !strings.HasPrefix(line, "*") && !strings.Contains(line, "An asterisk") {
                        // 优先选择Wi-Fi，否则选择第一个可用的服务
                        if strings.Contains(strings.ToLower(line), "wi-fi") || strings.Contains(strings.ToLower(line), "wifi") {
                                return line, nil
                        }
                }
        }

        // 如果没找到Wi-Fi，返回第一个可用的服务
        for _, line := range lines {
                line = strings.TrimSpace(line)
                if line != "" && !strings.HasPrefix(line, "*") && !strings.Contains(line, "An asterisk") {
                        return line, nil
                }
        }

        return "", fmt.Errorf("no network service found")
}

// 保存macOS原始代理设置
func (s *SystemProxyManager) saveMacOSOriginalSettings(networkService string) error {
        // 保存HTTP代理状态
        if output, err := exec.Command("networksetup", "-getwebproxy", networkService).Output(); err == nil {
                s.originalSettings["http_proxy"] = string(output)
        }

        // 保存HTTPS代理状态
        if output, err := exec.Command("networksetup", "-getsecurewebproxy", networkService).Output(); err == nil {
                s.originalSettings["https_proxy"] = string(output)
        }

        // 保存SOCKS代理状态
        if output, err := exec.Command("networksetup", "-getsocksfirewallproxy", networkService).Output(); err == nil {
                s.originalSettings["socks_proxy"] = string(output)
        }

        s.originalSettings["network_service"] = networkService
        return nil
}

// 恢复macOS代理设置
func (s *SystemProxyManager) restoreMacOSProxy() error {
        networkService, exists := s.originalSettings["network_service"]
        if !exists {
                return fmt.Errorf("no network service information saved")
        }

        logger.Info("Restoring macOS system proxy...")

        // 关闭所有代理
        s.runCommand("networksetup", "-setwebproxystate", networkService, "off")
        s.runCommand("networksetup", "-setsecurewebproxystate", networkService, "off")
        s.runCommand("networksetup", "-setsocksfirewallproxystate", networkService, "off")

        logger.Info("macOS system proxy restored")
        return nil
}

// Windows 代理设置（简化实现）
func (s *SystemProxyManager) setWindowsProxy(httpProxy, httpsProxy, socksProxy string) error {
        logger.Warn("Windows proxy setting not fully implemented")
        return fmt.Errorf("Windows proxy setting not implemented yet")
}

func (s *SystemProxyManager) restoreWindowsProxy() error {
        logger.Warn("Windows proxy restoration not fully implemented")
        return nil
}

// Linux 代理设置（简化实现）
func (s *SystemProxyManager) setLinuxProxy(httpProxy, httpsProxy, socksProxy string) error {
        logger.Warn("Linux proxy setting not fully implemented")
        return fmt.Errorf("Linux proxy setting not implemented yet")
}

func (s *SystemProxyManager) restoreLinuxProxy() error {
        logger.Warn("Linux proxy restoration not fully implemented")
        return nil
}

// 辅助函数
func (s *SystemProxyManager) runCommand(name string, args ...string) error {
        cmd := exec.Command(name, args...)
        output, err := cmd.CombinedOutput()
        if err != nil {
                logger.Error("Command failed: %s %v, output: %s", name, args, string(output))
                return err
        }
        return nil
}

func (s *SystemProxyManager) parseProxyHost(proxy string) string {
        // 简单解析，格式: host:port
        parts := strings.Split(proxy, ":")
        if len(parts) >= 1 {
                return parts[0]
        }
        return proxy
}

func (s *SystemProxyManager) parseProxyPort(proxy string) string {
        // 简单解析，格式: host:port
        parts := strings.Split(proxy, ":")
        if len(parts) >= 2 {
                return parts[1]
        }
        return "8080" // 默认端口
}

package dns

import (
        "fmt"
        "net"
        "strings"
        "sync"
        "time"

        "github.com/azoic/wormhole-client/pkg/logger"
)

// DNSProxy DNS代理服务器
type DNSProxy struct {
        upstreamDNS string
        localPort   int
        server      *net.UDPConn
        cache       *dnsCache
        running     bool
        mutex       sync.RWMutex
}

// dnsCache DNS缓存
type dnsCache struct {
        entries map[string]*cacheEntry
        mutex   sync.RWMutex
}

type cacheEntry struct {
        response []byte
        expiry   time.Time
}

// NewDNSProxy 创建DNS代理
func NewDNSProxy(upstreamDNS string, localPort int) *DNSProxy {
        return &DNSProxy{
                upstreamDNS: upstreamDNS,
                localPort:   localPort,
                cache: &dnsCache{
                        entries: make(map[string]*cacheEntry),
                },
        }
}

// Start 启动DNS代理服务器
func (d *DNSProxy) Start() error {
        d.mutex.Lock()
        defer d.mutex.Unlock()

        if d.running {
                return fmt.Errorf("DNS proxy is already running")
        }

        addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", d.localPort))
        if err != nil {
                return fmt.Errorf("failed to resolve UDP address: %v", err)
        }

        d.server, err = net.ListenUDP("udp", addr)
        if err != nil {
                return fmt.Errorf("failed to start DNS proxy server: %v", err)
        }

        d.running = true
        logger.Info("DNS proxy started on port %d", d.localPort)

        // 启动清理缓存的goroutine
        go d.cleanupCache()

        // 处理DNS请求
        go d.handleRequests()

        return nil
}

// Stop 停止DNS代理服务器
func (d *DNSProxy) Stop() error {
        d.mutex.Lock()
        defer d.mutex.Unlock()

        if !d.running {
                return nil
        }

        d.running = false
        if d.server != nil {
                d.server.Close()
        }

        logger.Info("DNS proxy stopped")
        return nil
}

// handleRequests 处理DNS请求
func (d *DNSProxy) handleRequests() {
        buffer := make([]byte, 512) // DNS消息最大512字节（UDP）

        for d.isRunning() {
                n, clientAddr, err := d.server.ReadFromUDP(buffer)
                if err != nil {
                        if d.isRunning() {
                                logger.Error("Failed to read DNS request: %v", err)
                        }
                        continue
                }

                go d.processRequest(buffer[:n], clientAddr)
        }
}

// processRequest 处理单个DNS请求
func (d *DNSProxy) processRequest(request []byte, clientAddr *net.UDPAddr) {
        // 简单的DNS请求解析
        domain := d.extractDomain(request)
        logger.Debug("DNS request for domain: %s", domain)

        // 检查缓存
        if cachedResponse := d.getFromCache(domain); cachedResponse != nil {
                logger.Debug("Serving %s from cache", domain)
                d.server.WriteToUDP(cachedResponse, clientAddr)
                return
        }

        // 转发到上游DNS服务器
        response, err := d.forwardToUpstream(request)
        if err != nil {
                logger.Error("Failed to forward DNS request: %v", err)
                return
        }

        // 缓存响应
        d.addToCache(domain, response)

        // 返回响应给客户端
        d.server.WriteToUDP(response, clientAddr)
}

// extractDomain 从DNS请求中提取域名（简化实现）
func (d *DNSProxy) extractDomain(request []byte) string {
        if len(request) < 12 {
                return ""
        }

        // 跳过DNS头部（12字节）
        offset := 12
        var domain strings.Builder

        for offset < len(request) {
                length := int(request[offset])
                if length == 0 {
                        break
                }

                offset++
                if offset+length > len(request) {
                        break
                }

                if domain.Len() > 0 {
                        domain.WriteByte('.')
                }
                domain.Write(request[offset : offset+length])
                offset += length
        }

        return domain.String()
}

// forwardToUpstream 转发DNS请求到上游服务器
func (d *DNSProxy) forwardToUpstream(request []byte) ([]byte, error) {
        conn, err := net.Dial("udp", d.upstreamDNS)
        if err != nil {
                return nil, fmt.Errorf("failed to connect to upstream DNS: %v", err)
        }
        defer conn.Close()

        // 设置超时
        conn.SetDeadline(time.Now().Add(5 * time.Second))

        // 发送请求
        if _, err := conn.Write(request); err != nil {
                return nil, fmt.Errorf("failed to send DNS request: %v", err)
        }

        // 读取响应
        response := make([]byte, 512)
        n, err := conn.Read(response)
        if err != nil {
                return nil, fmt.Errorf("failed to read DNS response: %v", err)
        }

        return response[:n], nil
}

// getFromCache 从缓存获取DNS响应
func (d *DNSProxy) getFromCache(domain string) []byte {
        d.cache.mutex.RLock()
        defer d.cache.mutex.RUnlock()

        entry, exists := d.cache.entries[domain]
        if !exists || time.Now().After(entry.expiry) {
                return nil
        }

        return entry.response
}

// addToCache 添加DNS响应到缓存
func (d *DNSProxy) addToCache(domain string, response []byte) {
        d.cache.mutex.Lock()
        defer d.cache.mutex.Unlock()

        // 设置缓存过期时间（5分钟）
        expiry := time.Now().Add(5 * time.Minute)

        d.cache.entries[domain] = &cacheEntry{
                response: make([]byte, len(response)),
                expiry:   expiry,
        }
        copy(d.cache.entries[domain].response, response)
}

// cleanupCache 清理过期的缓存条目
func (d *DNSProxy) cleanupCache() {
        ticker := time.NewTicker(1 * time.Minute)
        defer ticker.Stop()

        for {
                select {
                case <-ticker.C:
                        if !d.isRunning() {
                                return
                        }

                        d.cache.mutex.Lock()
                        now := time.Now()
                        for domain, entry := range d.cache.entries {
                                if now.After(entry.expiry) {
                                        delete(d.cache.entries, domain)
                                }
                        }
                        d.cache.mutex.Unlock()
                }
        }
}

// isRunning 检查DNS代理是否在运行
func (d *DNSProxy) isRunning() bool {
        d.mutex.RLock()
        defer d.mutex.RUnlock()
        return d.running
}

package logger

import (
        "fmt"
        "log"
        "os"
        "strings"
        "time"
)

type LogLevel int

const (
        DEBUG LogLevel = iota
        INFO
        WARN
        ERROR
)

type Logger struct {
        level  LogLevel
        logger *log.Logger
}

var defaultLogger *Logger

func init() {
        defaultLogger = New("INFO")
}

// New 创建新的日志记录器
func New(levelStr string) *Logger {
        level := parseLogLevel(levelStr)
        logger := log.New(os.Stdout, "", 0)

        return &Logger{
                level:  level,
                logger: logger,
        }
}

// SetLevel 设置日志级别
func SetLevel(levelStr string) {
        defaultLogger.level = parseLogLevel(levelStr)
}

func parseLogLevel(levelStr string) LogLevel {
        switch strings.ToUpper(levelStr) {
        case "DEBUG":
                return DEBUG
        case "INFO":
                return INFO
        case "WARN", "WARNING":
                return WARN
        case "ERROR":
                return ERROR
        default:
                return INFO
        }
}

func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
        if level < l.level {
                return
        }

        levelStr := ""
        switch level {
        case DEBUG:
                levelStr = "DEBUG"
        case INFO:
                levelStr = "INFO"
        case WARN:
                levelStr = "WARN"
        case ERROR:
                levelStr = "ERROR"
        }

        timestamp := time.Now().Format("2006-01-02 15:04:05")
        message := fmt.Sprintf(format, args...)
        logLine := fmt.Sprintf("[%s] [%s] %s", timestamp, levelStr, message)

        l.logger.Println(logLine)
}

// Debug 调试日志
func (l *Logger) Debug(format string, args ...interface{}) {
        l.log(DEBUG, format, args...)
}

// Info 信息日志
func (l *Logger) Info(format string, args ...interface{}) {
        l.log(INFO, format, args...)
}

// Warn 警告日志
func (l *Logger) Warn(format string, args ...interface{}) {
        l.log(WARN, format, args...)
}

// Error 错误日志
func (l *Logger) Error(format string, args ...interface{}) {
        l.log(ERROR, format, args...)
}

// 全局日志函数
func Debug(format string, args ...interface{}) {
        defaultLogger.Debug(format, args...)
}

func Info(format string, args ...interface{}) {
        defaultLogger.Info(format, args...)
}

func Warn(format string, args ...interface{}) {
        defaultLogger.Warn(format, args...)
}

func Error(format string, args ...interface{}) {
        defaultLogger.Error(format, args...)
}