zap: change socks handle from client to server.

main.go

@@ -24,18 +24,19 @@ var (
 
 	serverCommand = &cobra.Command{
 		Use:   "server",
-		Short: "seaMoon server mod",
+		Short: "SeaMoon server mod",
 		RunE:  Server,
 	}
 
 	proxyCommand = &cobra.Command{
 		Use:   "proxy",
-		Short: "seaMoon proxy mod",
+		Short: "SeaMoon proxy mod",
 		Run:   Proxy,
 	}
 
 	versionCommand = &cobra.Command{
-		Use: "version",
+		Use:   "version",
+		Short: "SeaMoon version info",
 		Run: func(cmd *cobra.Command, args []string) {
 			fmt.Println(consts.Version)
 		},

pkg/network/addr.go

@@ -21,6 +21,10 @@ type Addr struct {
 	Port uint16
 }
 
+type ListenConfig struct {
+	net.ListenConfig
+}
+
 func IsIPv4(address string) bool {
 	return address != "" && address[0] != ':' && address[0] != '['
 }

pkg/network/buffer.go

@@ -2,7 +2,24 @@ package network
 
 // fork from go-gost/core
 
-import "sync"
+import (
+	"bufio"
+	"net"
+	"sync"
+)
+
+type BufferedConn struct {
+	net.Conn
+	Br *bufio.Reader
+}
+
+func (c *BufferedConn) Read(b []byte) (int, error) {
+	return c.Br.Read(b)
+}
+
+func (c *BufferedConn) Peek(n int) ([]byte, error) {
+	return c.Br.Peek(n)
+}
 
 var (
 	pools = []struct {

pkg/transfer/socks5.go

@@ -1,7 +1,7 @@
 package transfer
 
 import (
-	"errors"
+	"bufio"
 	"log/slog"
 	"net"
 	"time"
@@ -10,20 +10,49 @@ import (
 	"github.com/DVKunion/SeaMoon/pkg/network"
 )
 
-func Socks5Transport(conn net.Conn, req *network.SOCKS5Request) error {
-	switch req.Cmd {
-	case network.SOCKS5CmdConnect:
-		handleConnect(conn, req)
-	case network.SOCKS5CmdBind:
-		handleBind()
-	case network.SOCKS5CmdUDP:
-		handleUDPOverTCP()
-	case network.SOCKS5CmdUDPOverTCP:
-		handleUDPOverTCP()
-	default:
-		return errors.New("")
+func Socks5Transport(conn net.Conn) error {
+	br := &network.BufferedConn{Conn: conn, Br: bufio.NewReader(conn)}
+	b, err := br.Peek(1)
+
+	if err != nil || b[0] != network.SOCKS5Version {
+		slog.Error(consts.CLIENT_PROTOCOL_UNSUPPORT_ERROR, "err", err)
+		return err
+	} else {
+		// select method
+		_, err := network.ReadMethods(br)
+		if err != nil {
+			slog.Error(`[socks5] read methods failed`, "err", err)
+			return err
+		}
+
+		// TODO AUTH
+		if err := network.WriteMethod(network.MethodNoAuth, br); err != nil {
+			if err != nil {
+				slog.Error(`[socks5] write method failed`, "err", err)
+			} else {
+				slog.Error(`[socks5] methods is not acceptable`)
+			}
+			return err
+		}
+
+		// read command
+		request, err := network.ReadSOCKS5Request(br)
+		if err != nil {
+			slog.Error(`[socks5] read command failed`, "err", err)
+			return err
+		}
+		switch request.Cmd {
+		case network.SOCKS5CmdConnect:
+			handleConnect(br, request)
+		case network.SOCKS5CmdBind:
+			slog.Error("not support cmd bind")
+			//handleBind(conn, request)
+		case network.SOCKS5CmdUDPOverTCP:
+			//handleUDP(conn, request)
+			slog.Error("not support cmd upd")
+		}
 	}
-	return errors.New("")
+	return nil
 }
 
 func handleConnect(conn net.Conn, req *network.SOCKS5Request) {
@@ -40,6 +69,11 @@ func handleConnect(conn net.Conn, req *network.SOCKS5Request) {
 	// if utils.Transport get out , then close conn of remote
 	defer destConn.Close()
 
+	if err := network.NewReply(network.SOCKS5RespSucceeded, nil).Write(conn); err != nil {
+		slog.Error(consts.SOCKS5_CONNECT_WRITE_ERROR, "err", err)
+		return
+	}
+
 	slog.Info(consts.SOCKS5_CONNECT_ESTAB, "src", conn.RemoteAddr(), "dest", req.Addr)
 
 	if err := network.Transport(conn, destConn); err != nil {

server/options.go

@@ -6,6 +6,8 @@ type Options struct {
 	host  string      // 监听地址
 	port  string      // 监听端口
 	proto tunnel.Type // 监听协议
+
+	mtcp bool //
 }
 
 type Option func(o *Options) (err error)
@@ -34,3 +36,10 @@ func WithProto(t string) Option {
 		return nil
 	}
 }
+
+func WithMTcp(flag bool) Option {
+	return func(o *Options) (err error) {
+		o.mtcp = flag
+		return nil
+	}
+}

server/server.go

@@ -4,20 +4,15 @@ import (
 	"context"
 	"errors"
 	"log/slog"
-	"net"
-	"net/http"
 	"strings"
-	"time"
 
-	"github.com/DVKunion/SeaMoon/pkg/consts"
+	net "github.com/DVKunion/SeaMoon/pkg/network"
 	"github.com/DVKunion/SeaMoon/server/service"
 )
 
 type Server struct {
 	srv  service.Service
 	opts Options
-
-	startAt time.Time
 }
 
 func New(opts ...Option) (*Server, error) {
@@ -40,46 +35,36 @@ func New(opts ...Option) (*Server, error) {
 	return s, nil
 }
 
+// Serve do common serve
 func (s *Server) Serve(ctx context.Context) error {
-	// http server
-	serverAddr := strings.Join(append([]string{s.opts.host, s.opts.port}), ":")
+	network := "tcp"
 
-	mux := http.NewServeMux()
+	if net.IsIPv4(s.opts.host) {
+		network = "tcp4"
+	}
+
+	serverAddr := strings.Join(append([]string{s.opts.host, s.opts.port}), ":")
 
 	lc := net.ListenConfig{}
-	lc.SetMultipathTCP(true)
+	if s.opts.mtcp {
+		lc.SetMultipathTCP(true)
+	}
 
-	ln, err := lc.Listen(ctx, "tcp", serverAddr)
+	ln, err := lc.Listen(ctx, network, serverAddr)
 
 	if err != nil {
 		return err
 	}
 
-	server := &http.Server{
-		Addr:    serverAddr,
-		Handler: mux,
-	}
+	slog.Info("seamoon server start with", "options", s.opts)
 
-	s.srv.Handle(mux)
-	s.startAt = time.Now()
-	// inject
-	mux.HandleFunc("/_health", s.health)
+	var srvOpt []service.Option
 
-	slog.Info("seamoon server start with", "options", s.opts)
-	// http服务
-	if err := server.Serve(ln); err != nil {
+	srvOpt = append(srvOpt, service.WithAddr(serverAddr))
+
+	if err := s.srv.Serve(ln, srvOpt...); err != nil {
 		slog.Error("server error", err)
 		return err
 	}
 	return nil
 }
-
-func (s *Server) health(w http.ResponseWriter, _ *http.Request) {
-	w.Header().Set("Content-Type", "text/plain")
-	w.WriteHeader(http.StatusOK)
-	_, err := w.Write([]byte("OK\n" + s.startAt.Format("2006-01-02 15:04:05") + "\n" + consts.Version + "-" + consts.Commit))
-	if err != nil {
-		slog.Error("server status error", "msg", err)
-		return
-	}
-}

server/service/options.go

@@ -0,0 +1,56 @@
+package service
+
+import (
+	"crypto/tls"
+	"time"
+)
+
+type Options struct {
+	addr string
+
+	tlsConf   *tls.Config
+	keepalive *KeepAliveOpt
+	buffers   *BufferOpt
+}
+
+type Option func(o *Options)
+
+type KeepAliveOpt struct {
+	MinTime           time.Duration
+	MaxTime           time.Duration
+	Timeout           time.Duration
+	HandshakeTimeout  time.Duration
+	MaxConnectionIdle time.Duration
+
+	PermitStream bool
+}
+
+type BufferOpt struct {
+	ReadBufferSize    int
+	WriteBufferSize   int
+	EnableCompression bool
+}
+
+func WithAddr(addr string) Option {
+	return func(o *Options) {
+		o.addr = addr
+	}
+}
+
+func WithTLSConf(t *tls.Config) Option {
+	return func(o *Options) {
+		o.tlsConf = t
+	}
+}
+
+func WithKeepAlive(k *KeepAliveOpt) Option {
+	return func(o *Options) {
+		o.keepalive = k
+	}
+}
+
+func WithBuffers(b *BufferOpt) Option {
+	return func(o *Options) {
+		o.buffers = b
+	}
+}

server/service/service.go

@@ -1,13 +1,13 @@
 package service
 
 import (
-	"net/http"
+	"net"
 
 	"github.com/DVKunion/SeaMoon/pkg/tunnel"
 )
 
 type Service interface {
-	Handle(m *http.ServeMux)
+	Serve(ln net.Listener, srvOpt ...Option) error
 }
 
 var Factory = map[tunnel.Type]Service{}