Remove bad rw usages

nekohasekai · nekohasekai · commit d9a5120bbd2b · 2024-06-23T16:15:43.000+08:00
diff --git a/common/cond.go b/common/cond.go
@@ -363,10 +363,12 @@ func Close(closers ...any) error {
 	return retErr
 }
 
+// Deprecated: wtf is this?
 type Starter interface {
 	Start() error
 }
 
+// Deprecated: wtf is this?
 func Start(starters ...any) error {
 	for _, rawStarter := range starters {
 		if rawStarter == nil {
diff --git a/common/metadata/serializer.go b/common/metadata/serializer.go
@@ -8,7 +8,7 @@ import (
 	"github.com/sagernet/sing/common"
 	"github.com/sagernet/sing/common/buf"
 	E "github.com/sagernet/sing/common/exceptions"
-	"github.com/sagernet/sing/common/rw"
+	"github.com/sagernet/sing/common/varbin"
 )
 
 const (
@@ -116,7 +116,7 @@ func (s *Serializer) WriteAddrPort(writer io.Writer, destination Socksaddr) erro
 		return err
 	}
 	if !isBuffer {
-		err = rw.WriteBytes(writer, buffer.Bytes())
+		err = common.Error(writer.Write(buffer.Bytes()))
 	}
 	return err
 }
@@ -129,8 +129,9 @@ func (s *Serializer) AddrPortLen(destination Socksaddr) int {
 	}
 }
 
-func (s *Serializer) ReadAddress(reader io.Reader) (Socksaddr, error) {
-	af, err := rw.ReadByte(reader)
+func (s *Serializer) ReadAddress(rawRedaer io.Reader) (Socksaddr, error) {
+	reader := varbin.NewReader(rawRedaer)
+	af, err := reader.ReadByte()
 	if err != nil {
 		return Socksaddr{}, err
 	}
@@ -164,11 +165,12 @@ func (s *Serializer) ReadAddress(reader io.Reader) (Socksaddr, error) {
 }
 
 func (s *Serializer) ReadPort(reader io.Reader) (uint16, error) {
-	port, err := rw.ReadBytes(reader, 2)
+	var port uint16
+	err := binary.Read(reader, binary.BigEndian, &port)
 	if err != nil {
 		return 0, E.Cause(err, "read port")
 	}
-	return binary.BigEndian.Uint16(port), nil
+	return port, nil
 }
 
 func (s *Serializer) ReadAddrPort(reader io.Reader) (destination Socksaddr, err error) {
@@ -194,12 +196,17 @@ func (s *Serializer) ReadAddrPort(reader io.Reader) (destination Socksaddr, err
 	return addr, nil
 }
 
-func ReadSockString(reader io.Reader) (string, error) {
-	strLen, err := rw.ReadByte(reader)
+func ReadSockString(reader varbin.Reader) (string, error) {
+	strLen, err := reader.ReadByte()
+	if err != nil {
+		return "", err
+	}
+	strBytes := make([]byte, strLen)
+	_, err = io.ReadFull(reader, strBytes)
 	if err != nil {
 		return "", err
 	}
-	return rw.ReadString(reader, int(strLen))
+	return string(strBytes), nil
 }
 
 func WriteSocksString(buffer *buf.Buffer, str string) error {
diff --git a/protocol/socks/client.go b/protocol/socks/client.go
@@ -1,12 +1,15 @@
 package socks
 
 import (
+	std_bufio "bufio"
 	"context"
 	"net"
 	"net/url"
 	"os"
 	"strings"
 
+	"github.com/sagernet/sing/common/buf"
+	"github.com/sagernet/sing/common/bufio"
 	E "github.com/sagernet/sing/common/exceptions"
 	M "github.com/sagernet/sing/common/metadata"
 	N "github.com/sagernet/sing/common/network"
@@ -118,31 +121,53 @@ func (c *Client) DialContext(ctx context.Context, network string, address M.Sock
 		return nil, err
 	}
 	if c.version == Version4 && address.IsFqdn() {
-		tcpAddr, err := net.ResolveTCPAddr(network, address.String())
+		var tcpAddr *net.TCPAddr
+		tcpAddr, err = net.ResolveTCPAddr(network, address.String())
 		if err != nil {
 			tcpConn.Close()
 			return nil, err
 		}
 		address = M.SocksaddrFromNet(tcpAddr)
 	}
+	reader := std_bufio.NewReader(tcpConn)
 	switch c.version {
 	case Version4, Version4A:
-		_, err = ClientHandshake4(tcpConn, command, address, c.username)
+		_, err = ClientHandshake4(reader, tcpConn, command, address, c.username)
 		if err != nil {
 			tcpConn.Close()
 			return nil, err
 		}
+		if reader.Buffered() > 0 {
+			buffer := buf.NewSize(reader.Buffered())
+			_, err = buffer.ReadFullFrom(reader, reader.Buffered())
+			if err != nil {
+				tcpConn.Close()
+				return nil, err
+			}
+			return bufio.NewCachedConn(tcpConn, buffer), nil
+		}
 		return tcpConn, nil
 	case Version5:
-		response, err := ClientHandshake5(tcpConn, command, address, c.username, c.password)
+		var response socks5.Response
+		response, err = ClientHandshake5(reader, tcpConn, command, address, c.username, c.password)
 		if err != nil {
 			tcpConn.Close()
 			return nil, err
 		}
 		if command == socks5.CommandConnect {
+			if reader.Buffered() > 0 {
+				buffer := buf.NewSize(reader.Buffered())
+				_, err = buffer.ReadFullFrom(reader, reader.Buffered())
+				if err != nil {
+					tcpConn.Close()
+					return nil, err
+				}
+				return bufio.NewCachedConn(tcpConn, buffer), nil
+			}
 			return tcpConn, nil
 		}
-		udpConn, err := c.dialer.DialContext(ctx, N.NetworkUDP, response.Bind)
+		var udpConn net.Conn
+		udpConn, err = c.dialer.DialContext(ctx, N.NetworkUDP, response.Bind)
 		if err != nil {
 			tcpConn.Close()
 			return nil, err
@@ -166,16 +191,17 @@ func (c *Client) BindContext(ctx context.Context, address M.Socksaddr) (net.Conn
 	if err != nil {
 		return nil, err
 	}
+	reader := std_bufio.NewReader(tcpConn)
 	switch c.version {
 	case Version4, Version4A:
-		_, err = ClientHandshake4(tcpConn, socks4.CommandBind, address, c.username)
+		_, err = ClientHandshake4(reader, tcpConn, socks4.CommandBind, address, c.username)
 		if err != nil {
 			tcpConn.Close()
 			return nil, err
 		}
 		return tcpConn, nil
 	case Version5:
-		_, err = ClientHandshake5(tcpConn, socks5.CommandBind, address, c.username, c.password)
+		_, err = ClientHandshake5(reader, tcpConn, socks5.CommandBind, address, c.username, c.password)
 		if err != nil {
 			tcpConn.Close()
 			return nil, err
diff --git a/protocol/socks/handshake.go b/protocol/socks/handshake.go
@@ -1,6 +1,7 @@
 package socks
 
 import (
+	std_bufio "bufio"
 	"context"
 	"io"
 	"net"
@@ -13,7 +14,7 @@ import (
 	E "github.com/sagernet/sing/common/exceptions"
 	M "github.com/sagernet/sing/common/metadata"
 	N "github.com/sagernet/sing/common/network"
-	"github.com/sagernet/sing/common/rw"
+	"github.com/sagernet/sing/common/varbin"
 	"github.com/sagernet/sing/protocol/socks/socks4"
 	"github.com/sagernet/sing/protocol/socks/socks5"
 )
@@ -23,16 +24,16 @@ type Handler interface {
 	N.UDPConnectionHandler
 }
 
-func ClientHandshake4(conn io.ReadWriter, command byte, destination M.Socksaddr, username string) (socks4.Response, error) {
-	err := socks4.WriteRequest(conn, socks4.Request{
+func ClientHandshake4(reader varbin.Reader, writer io.Writer, command byte, destination M.Socksaddr, username string) (socks4.Response, error) {
+	err := socks4.WriteRequest(writer, socks4.Request{
 		Command:     command,
 		Destination: destination,
 		Username:    username,
 	})
 	if err != nil {
 		return socks4.Response{}, err
 	}
-	response, err := socks4.ReadResponse(conn)
+	response, err := socks4.ReadResponse(reader)
 	if err != nil {
 		return socks4.Response{}, err
 	}
@@ -42,32 +43,32 @@ func ClientHandshake4(conn io.ReadWriter, command byte, destination M.Socksaddr,
 	return response, err
 }
 
-func ClientHandshake5(conn io.ReadWriter, command byte, destination M.Socksaddr, username string, password string) (socks5.Response, error) {
+func ClientHandshake5(reader varbin.Reader, writer io.Writer, command byte, destination M.Socksaddr, username string, password string) (socks5.Response, error) {
 	var method byte
 	if username == "" {
 		method = socks5.AuthTypeNotRequired
 	} else {
 		method = socks5.AuthTypeUsernamePassword
 	}
-	err := socks5.WriteAuthRequest(conn, socks5.AuthRequest{
+	err := socks5.WriteAuthRequest(writer, socks5.AuthRequest{
 		Methods: []byte{method},
 	})
 	if err != nil {
 		return socks5.Response{}, err
 	}
-	authResponse, err := socks5.ReadAuthResponse(conn)
+	authResponse, err := socks5.ReadAuthResponse(reader)
 	if err != nil {
 		return socks5.Response{}, err
 	}
 	if authResponse.Method == socks5.AuthTypeUsernamePassword {
-		err = socks5.WriteUsernamePasswordAuthRequest(conn, socks5.UsernamePasswordAuthRequest{
+		err = socks5.WriteUsernamePasswordAuthRequest(writer, socks5.UsernamePasswordAuthRequest{
 			Username: username,
 			Password: password,
 		})
 		if err != nil {
 			return socks5.Response{}, err
 		}
-		usernamePasswordResponse, err := socks5.ReadUsernamePasswordAuthResponse(conn)
+		usernamePasswordResponse, err := socks5.ReadUsernamePasswordAuthResponse(reader)
 		if err != nil {
 			return socks5.Response{}, err
 		}
@@ -77,14 +78,14 @@ func ClientHandshake5(conn io.ReadWriter, command byte, destination M.Socksaddr,
 	} else if authResponse.Method != socks5.AuthTypeNotRequired {
 		return socks5.Response{}, E.New("socks5: unsupported auth method: ", authResponse.Method)
 	}
-	err = socks5.WriteRequest(conn, socks5.Request{
+	err = socks5.WriteRequest(writer, socks5.Request{
 		Command:     command,
 		Destination: destination,
 	})
 	if err != nil {
 		return socks5.Response{}, err
 	}
-	response, err := socks5.ReadResponse(conn)
+	response, err := socks5.ReadResponse(reader)
 	if err != nil {
 		return socks5.Response{}, err
 	}
@@ -94,18 +95,14 @@ func ClientHandshake5(conn io.ReadWriter, command byte, destination M.Socksaddr,
 	return response, err
 }
 
-func HandleConnection(ctx context.Context, conn net.Conn, authenticator *auth.Authenticator, handler Handler, metadata M.Metadata) error {
-	version, err := rw.ReadByte(conn)
+func HandleConnection(ctx context.Context, conn net.Conn, reader *std_bufio.Reader, authenticator *auth.Authenticator, handler Handler, metadata M.Metadata) error {
+	version, err := reader.ReadByte()
 	if err != nil {
 		return err
 	}
-	return HandleConnection0(ctx, conn, version, authenticator, handler, metadata)
-}
-
-func HandleConnection0(ctx context.Context, conn net.Conn, version byte, authenticator *auth.Authenticator, handler Handler, metadata M.Metadata) error {
 	switch version {
 	case socks4.Version:
-		request, err := socks4.ReadRequest0(conn)
+		request, err := socks4.ReadRequest0(reader)
 		if err != nil {
 			return err
 		}
@@ -142,7 +139,7 @@ func HandleConnection0(ctx context.Context, conn net.Conn, version byte, authent
 			return E.New("socks4: unsupported command ", request.Command)
 		}
 	case socks5.Version:
-		authRequest, err := socks5.ReadAuthRequest0(conn)
+		authRequest, err := socks5.ReadAuthRequest0(reader)
 		if err != nil {
 			return err
 		}
@@ -167,7 +164,7 @@ func HandleConnection0(ctx context.Context, conn net.Conn, version byte, authent
 			return err
 		}
 		if authMethod == socks5.AuthTypeUsernamePassword {
-			usernamePasswordAuthRequest, err := socks5.ReadUsernamePasswordAuthRequest(conn)
+			usernamePasswordAuthRequest, err := socks5.ReadUsernamePasswordAuthRequest(reader)
 			if err != nil {
 				return err
 			}
@@ -186,7 +183,7 @@ func HandleConnection0(ctx context.Context, conn net.Conn, version byte, authent
 				return E.New("socks5: authentication failed, username=", usernamePasswordAuthRequest.Username, ", password=", usernamePasswordAuthRequest.Password)
 			}
 		}
-		request, err := socks5.ReadRequest(conn)
+		request, err := socks5.ReadRequest(reader)
 		if err != nil {
 			return err
 		}
diff --git a/protocol/socks/socks4/protocol.go b/protocol/socks/socks4/protocol.go
@@ -10,7 +10,7 @@ import (
 	"github.com/sagernet/sing/common/buf"
 	E "github.com/sagernet/sing/common/exceptions"
 	M "github.com/sagernet/sing/common/metadata"
-	"github.com/sagernet/sing/common/rw"
+	"github.com/sagernet/sing/common/varbin"
 )
 
 const (
@@ -31,8 +31,8 @@ type Request struct {
 	Username    string
 }
 
-func ReadRequest(reader io.Reader) (request Request, err error) {
-	version, err := rw.ReadByte(reader)
+func ReadRequest(reader varbin.Reader) (request Request, err error) {
+	version, err := reader.ReadByte()
 	if err != nil {
 		return
 	}
@@ -43,8 +43,8 @@ func ReadRequest(reader io.Reader) (request Request, err error) {
 	return ReadRequest0(reader)
 }
 
-func ReadRequest0(reader io.Reader) (request Request, err error) {
-	request.Command, err = rw.ReadByte(reader)
+func ReadRequest0(reader varbin.Reader) (request Request, err error) {
+	request.Command, err = reader.ReadByte()
 	if err != nil {
 		return
 	}
@@ -108,24 +108,24 @@ func WriteRequest(writer io.Writer, request Request) error {
 		common.Must1(buffer.WriteString(request.Destination.AddrString()))
 		common.Must(buffer.WriteZero())
 	}
-	return rw.WriteBytes(writer, buffer.Bytes())
+	return common.Error(writer.Write(buffer.Bytes()))
 }
 
 type Response struct {
 	ReplyCode   byte
 	Destination M.Socksaddr
 }
 
-func ReadResponse(reader io.Reader) (response Response, err error) {
-	version, err := rw.ReadByte(reader)
+func ReadResponse(reader varbin.Reader) (response Response, err error) {
+	version, err := reader.ReadByte()
 	if err != nil {
 		return
 	}
 	if version != 0 {
 		err = E.New("excepted socks4 response version 0, got ", version)
 		return
 	}
-	response.ReplyCode, err = rw.ReadByte(reader)
+	response.ReplyCode, err = reader.ReadByte()
 	if err != nil {
 		return
 	}
@@ -151,13 +151,13 @@ func WriteResponse(writer io.Writer, response Response) error {
 		binary.Write(buffer, binary.BigEndian, response.Destination.Port),
 		common.Error(buffer.Write(response.Destination.Addr.AsSlice())),
 	)
-	return rw.WriteBytes(writer, buffer.Bytes())
+	return common.Error(writer.Write(buffer.Bytes()))
 }
 
-func readString(reader io.Reader) (string, error) {
+func readString(reader varbin.Reader) (string, error) {
 	buffer := bytes.Buffer{}
 	for {
-		b, err := rw.ReadByte(reader)
+		b, err := reader.ReadByte()
 		if err != nil {
 			return "", err
 		}
diff --git a/protocol/socks/socks5/protocol.go b/protocol/socks/socks5/protocol.go
diff --git a/service/filemanager/default.go b/service/filemanager/default.go

Original file line number	Diff line number	Diff line change
`@@ -363,10 +363,12 @@ func Close(closers ...any) error {`
`363`	`363`	`return retErr`
`364`	`364`	`}`
`365`	`365`
	`366`	`+// Deprecated: wtf is this?`
`366`	`367`	`type Starter interface {`
`367`	`368`	`Start() error`
`368`	`369`	`}`
`369`	`370`
	`371`	`+// Deprecated: wtf is this?`
`370`	`372`	`func Start(starters ...any) error {`
`371`	`373`	`for _, rawStarter := range starters {`
`372`	`374`	`if rawStarter == nil {`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ import (`
`8`	`8`	`"github.com/sagernet/sing/common"`
`9`	`9`	`"github.com/sagernet/sing/common/buf"`
`10`	`10`	`E "github.com/sagernet/sing/common/exceptions"`
`11`		`- "github.com/sagernet/sing/common/rw"`
	`11`	`+ "github.com/sagernet/sing/common/varbin"`
`12`	`12`	`)`
`13`	`13`
`14`	`14`	`const (`
`@@ -116,7 +116,7 @@ func (s *Serializer) WriteAddrPort(writer io.Writer, destination Socksaddr) erro`
`116`	`116`	`return err`
`117`	`117`	`}`
`118`	`118`	`if !isBuffer {`
`119`		`- err = rw.WriteBytes(writer, buffer.Bytes())`
	`119`	`+ err = common.Error(writer.Write(buffer.Bytes()))`
`120`	`120`	`}`
`121`	`121`	`return err`
`122`	`122`	`}`
`@@ -129,8 +129,9 @@ func (s *Serializer) AddrPortLen(destination Socksaddr) int {`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`132`		`-func (s *Serializer) ReadAddress(reader io.Reader) (Socksaddr, error) {`
`133`		`- af, err := rw.ReadByte(reader)`
	`132`	`+func (s *Serializer) ReadAddress(rawRedaer io.Reader) (Socksaddr, error) {`
	`133`	`+ reader := varbin.NewReader(rawRedaer)`
	`134`	`+ af, err := reader.ReadByte()`
`134`	`135`	`if err != nil {`
`135`	`136`	`return Socksaddr{}, err`
`136`	`137`	`}`
`@@ -164,11 +165,12 @@ func (s *Serializer) ReadAddress(reader io.Reader) (Socksaddr, error) {`
`164`	`165`	`}`
`165`	`166`
`166`	`167`	`func (s *Serializer) ReadPort(reader io.Reader) (uint16, error) {`
`167`		`- port, err := rw.ReadBytes(reader, 2)`
	`168`	`+ var port uint16`
	`169`	`+ err := binary.Read(reader, binary.BigEndian, &port)`
`168`	`170`	`if err != nil {`
`169`	`171`	`return 0, E.Cause(err, "read port")`
`170`	`172`	`}`
`171`		`- return binary.BigEndian.Uint16(port), nil`
	`173`	`+ return port, nil`
`172`	`174`	`}`
`173`	`175`
`174`	`176`	`func (s *Serializer) ReadAddrPort(reader io.Reader) (destination Socksaddr, err error) {`
`@@ -194,12 +196,17 @@ func (s *Serializer) ReadAddrPort(reader io.Reader) (destination Socksaddr, err`
`194`	`196`	`return addr, nil`
`195`	`197`	`}`
`196`	`198`
`197`		`-func ReadSockString(reader io.Reader) (string, error) {`
`198`		`- strLen, err := rw.ReadByte(reader)`
	`199`	`+func ReadSockString(reader varbin.Reader) (string, error) {`
	`200`	`+ strLen, err := reader.ReadByte()`
	`201`	`+ if err != nil {`
	`202`	`+ return "", err`
	`203`	`+ }`
	`204`	`+ strBytes := make([]byte, strLen)`
	`205`	`+ _, err = io.ReadFull(reader, strBytes)`
`199`	`206`	`if err != nil {`
`200`	`207`	`return "", err`
`201`	`208`	`}`
`202`		`- return rw.ReadString(reader, int(strLen))`
	`209`	`+ return string(strBytes), nil`
`203`	`210`	`}`
`204`	`211`
`205`	`212`	`func WriteSocksString(buffer *buf.Buffer, str string) error {`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ import (`
`10`	`10`	`"github.com/sagernet/sing/common/buf"`
`11`	`11`	`E "github.com/sagernet/sing/common/exceptions"`
`12`	`12`	`M "github.com/sagernet/sing/common/metadata"`
`13`		`- "github.com/sagernet/sing/common/rw"`
	`13`	`+ "github.com/sagernet/sing/common/varbin"`
`14`	`14`	`)`
`15`	`15`
`16`	`16`	`const (`
`@@ -31,8 +31,8 @@ type Request struct {`
`31`	`31`	`Username string`
`32`	`32`	`}`
`33`	`33`
`34`		`-func ReadRequest(reader io.Reader) (request Request, err error) {`
`35`		`- version, err := rw.ReadByte(reader)`
	`34`	`+func ReadRequest(reader varbin.Reader) (request Request, err error) {`
	`35`	`+ version, err := reader.ReadByte()`
`36`	`36`	`if err != nil {`
`37`	`37`	`return`
`38`	`38`	`}`
`@@ -43,8 +43,8 @@ func ReadRequest(reader io.Reader) (request Request, err error) {`
`43`	`43`	`return ReadRequest0(reader)`
`44`	`44`	`}`
`45`	`45`
`46`		`-func ReadRequest0(reader io.Reader) (request Request, err error) {`
`47`		`- request.Command, err = rw.ReadByte(reader)`
	`46`	`+func ReadRequest0(reader varbin.Reader) (request Request, err error) {`
	`47`	`+ request.Command, err = reader.ReadByte()`
`48`	`48`	`if err != nil {`
`49`	`49`	`return`
`50`	`50`	`}`
`@@ -108,24 +108,24 @@ func WriteRequest(writer io.Writer, request Request) error {`
`108`	`108`	`common.Must1(buffer.WriteString(request.Destination.AddrString()))`
`109`	`109`	`common.Must(buffer.WriteZero())`
`110`	`110`	`}`
`111`		`- return rw.WriteBytes(writer, buffer.Bytes())`
	`111`	`+ return common.Error(writer.Write(buffer.Bytes()))`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`type Response struct {`
`115`	`115`	`ReplyCode byte`
`116`	`116`	`Destination M.Socksaddr`
`117`	`117`	`}`
`118`	`118`
`119`		`-func ReadResponse(reader io.Reader) (response Response, err error) {`
`120`		`- version, err := rw.ReadByte(reader)`
	`119`	`+func ReadResponse(reader varbin.Reader) (response Response, err error) {`
	`120`	`+ version, err := reader.ReadByte()`
`121`	`121`	`if err != nil {`
`122`	`122`	`return`
`123`	`123`	`}`
`124`	`124`	`if version != 0 {`
`125`	`125`	`err = E.New("excepted socks4 response version 0, got ", version)`
`126`	`126`	`return`
`127`	`127`	`}`
`128`		`- response.ReplyCode, err = rw.ReadByte(reader)`
	`128`	`+ response.ReplyCode, err = reader.ReadByte()`
`129`	`129`	`if err != nil {`
`130`	`130`	`return`
`131`	`131`	`}`
`@@ -151,13 +151,13 @@ func WriteResponse(writer io.Writer, response Response) error {`
`151`	`151`	`binary.Write(buffer, binary.BigEndian, response.Destination.Port),`
`152`	`152`	`common.Error(buffer.Write(response.Destination.Addr.AsSlice())),`
`153`	`153`	`)`
`154`		`- return rw.WriteBytes(writer, buffer.Bytes())`
	`154`	`+ return common.Error(writer.Write(buffer.Bytes()))`
`155`	`155`	`}`
`156`	`156`
`157`		`-func readString(reader io.Reader) (string, error) {`
	`157`	`+func readString(reader varbin.Reader) (string, error) {`
`158`	`158`	`buffer := bytes.Buffer{}`
`159`	`159`	`for {`
`160`		`- b, err := rw.ReadByte(reader)`
	`160`	`+ b, err := reader.ReadByte()`
`161`	`161`	`if err != nil {`
`162`	`162`	`return "", err`
`163`	`163`	`}`