优化连接效率

server/fwd/fwd.go

@@ -1,22 +1,11 @@
 package fwd
 
 import (
-	"bufio"
 	"context"
-	"encoding/binary"
-	"io"
 	"log/slog"
-	"net"
 	"proxy-server/pkg/utils"
 	"proxy-server/server/fwd/core"
-	"proxy-server/server/fwd/dispatcher"
-	"proxy-server/server/pkg/env"
-	"strconv"
-	"strings"
 	"sync"
-	"time"
-
-	"github.com/pkg/errors"
 )
 
 type Config struct {
@@ -122,256 +111,3 @@ func (s *Service) Run() {
 	wg.Wait()
 	slog.Info("fwd 服务已退出")
 }
-
-func (s *Service) startCtrlTun() error {
-	ctrlPort := env.AppCtrlPort
-	slog.Debug("监听控制通道", slog.Uint64("port", uint64(ctrlPort)))
-
-	// 监听端口
-	ls, err := net.Listen("tcp", ":"+strconv.Itoa(int(ctrlPort)))
-	if err != nil {
-		return errors.Wrap(err, "监听控制通道失败")
-	}
-	defer utils.Close(ls)
-
-	// 处理连接
-	connCh := utils.ChanConnAccept(s.ctx, ls)
-	for {
-		select {
-		case <-s.ctx.Done():
-			return nil
-		case conn, ok := <-connCh:
-			if !ok {
-				return errors.New("获取连接失败")
-			}
-			s.ctrlConnWg.Add(1)
-			go func() {
-				defer s.ctrlConnWg.Done()
-				err := s.processCtrlConn(conn)
-				if err != nil {
-					slog.Error("处理控制通道连接失败", "err", err)
-					utils.Close(conn)
-				}
-			}()
-		}
-	}
-}
-
-func (s *Service) processCtrlConn(conn net.Conn) error {
-	reader := bufio.NewReader(conn)
-
-	// 获取转发端口
-	portBuf, err := utils.ReadBuffer(reader, 2)
-	if err != nil {
-		return errors.Wrap(err, "获取转发端口失败")
-	}
-	port := binary.BigEndian.Uint16(portBuf)
-
-	slog.Info("客户端注册", "addr", conn.RemoteAddr().String(), "port", port)
-
-	// 启动转发服务
-	proxy, err := dispatcher.New(port)
-	if err != nil {
-		return errors.Wrap(err, "创建 socks 转发服务失败")
-	}
-	defer proxy.Close()
-
-	s.fwdLesWg.Add(1)
-	go func() {
-		defer s.fwdLesWg.Done()
-		err := proxy.Run()
-		if err != nil {
-			slog.Error("代理服务运行失败", "err", err)
-			return
-		}
-	}()
-
-	// 监听客户端连接
-	errCh := make(chan error)
-	defer close(errCh)
-	go func() {
-		_, err := reader.ReadByte()
-		errCh <- err
-	}()
-
-	// 处理连接
-	for {
-		select {
-		case <-s.ctx.Done():
-			return nil
-		case err := <-errCh:
-			switch {
-			case strings.Contains(err.Error(), "An existing connection was forcibly closed by the remote host."):
-				slog.Debug("客户端主动断开连接")
-				return nil
-			case err == nil:
-				return errors.New("客户端握手失败")
-			default:
-				return errors.Wrap(err, "客户端意外断开连接")
-			}
-		case user := <-proxy.Conn:
-			s.userConnWg.Add(1)
-			go func() {
-				defer s.userConnWg.Done()
-				err := s.processUserConn(user, conn)
-				if err != nil {
-					slog.Error("处理用户连接失败", "err", err)
-					utils.Close(user)
-				}
-			}()
-		}
-	}
-}
-
-func (s *Service) startDataTun() error {
-	dataPort := env.AppDataPort
-	slog.Debug("监听数据通道", slog.Uint64("port", uint64(dataPort)))
-
-	// 监听端口
-	ls, err := net.Listen("tcp", ":"+strconv.Itoa(int(dataPort)))
-	if err != nil {
-		return errors.Wrap(err, "监听数据通道失败")
-	}
-	defer utils.Close(ls)
-
-	go func() {
-		<-s.ctx.Done()
-		utils.Close(ls)
-	}()
-
-	for {
-		conn, err := ls.Accept()
-		if err != nil {
-			return errors.Wrap(err, "监听数据通道失败")
-		}
-
-		select {
-		case <-s.ctx.Done():
-			utils.Close(conn)
-			return nil
-		default:
-			s.dataConnWg.Add(1)
-			go func() {
-				defer s.dataConnWg.Done()
-				defer utils.Close(conn)
-				err := s.processDataConn(conn)
-				if err != nil {
-					slog.Error("处理数据通道失败", "err", err)
-				}
-			}()
-		}
-	}
-}
-
-func (s *Service) processDataConn(client net.Conn) error {
-
-	// 读取 tag
-	var tag string
-	select {
-	case <-s.ctx.Done():
-		return nil
-	default:
-		tagLen, err := utils.ReadByte(client)
-		if err != nil {
-			return errors.Wrap(err, "从客户端获取 tag 失败")
-		}
-		tagBuf, err := utils.ReadBuffer(client, int(tagLen))
-		if err != nil {
-			return errors.Wrap(err, "从客户端获取 tag 失败")
-		}
-		tag = string(tagBuf)
-	}
-
-	// 找到用户连接
-	user, ok := s.userConnMap.LoadAndDelete(tag)
-	if !ok {
-		return errors.New("查找用户连接失败")
-	}
-	defer utils.Close(user)
-
-	// 发送目标地址
-	select {
-	case <-s.ctx.Done():
-		return nil
-	default:
-		dest := user.Dest.String()
-		destLen := len(dest)
-		destBuf := make([]byte, 1+destLen)
-		destBuf[0] = byte(destLen)
-		copy(destBuf[1:], dest)
-		_, err := client.Write(destBuf)
-		if err != nil {
-			return errors.Wrap(err, "向客户端发送目标地址失败")
-		}
-	}
-
-	// 数据转发
-	userPipeReader, userPipeWriter := io.Pipe()
-	defer utils.Close(userPipeWriter)
-	teeUser := io.TeeReader(user, userPipeWriter)
-	go func() {
-		err := analysisAndLog(user, userPipeReader)
-		if err != nil {
-			slog.Error("数据解析失败", "err", err)
-		}
-	}()
-
-	wg := sync.WaitGroup{}
-	wg.Add(2)
-	go func() {
-		defer wg.Done()
-		_, err := io.Copy(client, teeUser)
-		if err != nil {
-			slog.Error("数据转发失败 user->client", "err", err)
-		}
-	}()
-	go func() {
-		defer wg.Done()
-		_, err := io.Copy(user, client)
-		if err != nil {
-			slog.Error("数据转发失败 client->user", "err", err, "errType")
-		}
-	}()
-
-	select {
-	case <-s.ctx.Done():
-	case <-utils.ChanWgWait(s.ctx, &wg):
-	}
-
-	return nil
-}
-
-func (s *Service) processUserConn(user *core.Conn, ctrl net.Conn) error {
-
-	// 发送 tag
-	tag := user.Tag
-	tagLen := len(tag)
-	tagBuf := make([]byte, 1+tagLen)
-	tagBuf[0] = byte(tagLen)
-	copy(tagBuf[1:], tag)
-
-	_, err := ctrl.Write(tagBuf)
-	if err != nil {
-		return errors.Wrap(err, "向控制通道发送 tag 失败")
-	}
-
-	// 记录用户连接
-	s.userConnMap.Store(user.Tag, user)
-
-	// 如果限定时间内没有建立数据通道，则关闭连接
-	timeout, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	select {
-	case <-s.ctx.Done():
-		// 服务会在退出时统一关闭未消费的连接
-	case <-timeout.Done():
-		storedUser, ok := s.userConnMap.LoadAndDelete(user.Tag)
-		if ok {
-			slog.Debug("用户连接超时，关闭连接", "tag", user.Tag)
-			utils.Close(storedUser)
-		}
-	}
-
-	return nil
-}