add ReplyError, unify naming and errors

Author: linkdata

client/client.go

@@ -141,7 +141,7 @@ func (cli *Client) connect(ctx context.Context, proxyconn net.Conn, cmd socks5.C
 		defer proxyconn.SetDeadline(time.Time{})
 	}
 	if err = cli.connectAuth(proxyconn); err == nil {
-		err = socks5.ErrUnsupportedCommand
+		err = socks5.ErrReplyCommandNotSupported
 		switch cmd {
 		case socks5.CommandConnect:
 			if addr, err = cli.connectCommand(proxyconn, socks5.CommandConnect, address); err == nil {
@@ -233,7 +233,7 @@ func (cli *Client) readReply(conn net.Conn) (addr socks5.Addr, err error) {
 	if _, err = io.ReadFull(conn, header[:]); err == nil {
 		if err = socks5.MustEqual(header[0], socks5.Socks5Version, socks5.ErrVersion); err == nil {
 			replyCode := socks5.ReplyCode(header[1])
-			if err = socks5.MustEqual(replyCode, socks5.Success, replyCode.ToError()); err == nil {
+			if err = socks5.MustEqual(replyCode, socks5.ReplySuccess, replyCode.ToError()); err == nil {
 				addr, err = socks5.ReadAddr(conn)
 			}
 		}

errors.go

@@ -10,7 +10,6 @@ var (
 	ErrVersion                 = errors.New("invalid SOCKS version")
 	ErrInvalidPortNumber       = errors.New("invalid port number")
 	ErrBadSOCKSAuthVersion     = errors.New("bad SOCKS auth version")
-	ErrUnsupportedCommand      = errors.New("unsupported command")
 	ErrAuthFailed              = errors.New("authentication failed")
 	ErrInvalidUDPPacket        = errors.New("invalid udp packet")
 	ErrFragmentedUDPPacket     = errors.New("fragmented udp packet")

replycode.go

@@ -1,54 +1,39 @@
 package socks5
 
 import (
-	"errors"
 	"fmt"
 )
 
-// ReplyCode are the bytes sent in SOCKS5 packets
-// that represent replies from the server to a client
-// request.
+// ReplyCode is the reply code in SOCKS5 packets sent from the server to a client.
 type ReplyCode byte
 
-// The set of valid SOCKS5 reply types as per the RFC 1928.
 const (
-	Success              ReplyCode = 0
-	GeneralFailure       ReplyCode = 1
-	ConnectionNotAllowed ReplyCode = 2
-	NetworkUnreachable   ReplyCode = 3
-	HostUnreachable      ReplyCode = 4
-	ConnectionRefused    ReplyCode = 5
-	TtlExpired           ReplyCode = 6
-	CommandNotSupported  ReplyCode = 7
-	AddrTypeNotSupported ReplyCode = 8
-)
-
-var (
-	ErrGeneralFailure       = errors.New("general failure")
-	ErrConnectionNotAllowed = errors.New("connection not allowed")
-	ErrNetworkUnreachable   = errors.New("network unreachable")
-	ErrHostUnreachable      = errors.New("host unreachable")
-	ErrConnectionRefused    = errors.New("connection refused")
-	ErrTtlExpired           = errors.New("ttl expired")
-	ErrCommandNotSupported  = errors.New("command not supported")
-	ErrAddrTypeNotSupported = errors.New("address type not supported")
+	ReplySuccess              ReplyCode = 0
+	ReplyGeneralFailure       ReplyCode = 1
+	ReplyConnectionNotAllowed ReplyCode = 2
+	ReplyNetworkUnreachable   ReplyCode = 3
+	ReplyHostUnreachable      ReplyCode = 4
+	ReplyConnectionRefused    ReplyCode = 5
+	ReplyTTLExpired           ReplyCode = 6
+	ReplyCommandNotSupported  ReplyCode = 7
+	ReplyAddrTypeNotSupported ReplyCode = 8
 )
 
 var replyCodeError = map[ReplyCode]error{
-	Success:              nil,
-	GeneralFailure:       ErrGeneralFailure,
-	ConnectionNotAllowed: ErrConnectionNotAllowed,
-	NetworkUnreachable:   ErrNetworkUnreachable,
-	HostUnreachable:      ErrHostUnreachable,
-	ConnectionRefused:    ErrConnectionRefused,
-	TtlExpired:           ErrTtlExpired,
-	CommandNotSupported:  ErrCommandNotSupported,
-	AddrTypeNotSupported: ErrAddrTypeNotSupported,
+	ReplySuccess:              nil,
+	ReplyGeneralFailure:       ErrReplyGeneralFailure,
+	ReplyConnectionNotAllowed: ErrReplyConnectionNotAllowed,
+	ReplyNetworkUnreachable:   ErrReplyNetworkUnreachable,
+	ReplyHostUnreachable:      ErrReplyHostUnreachable,
+	ReplyConnectionRefused:    ErrReplyConnectionRefused,
+	ReplyTTLExpired:           ErrReplyTTLExpired,
+	ReplyCommandNotSupported:  ErrReplyCommandNotSupported,
+	ReplyAddrTypeNotSupported: ErrReplyAddrTypeNotSupported,
 }
 
 func (code ReplyCode) ToError() error {
 	if err, ok := replyCodeError[code]; ok {
 		return err
 	}
-	return fmt.Errorf("code(%d)", int(code))
+	return fmt.Errorf("socks5code(%v)", code)
 }

replycode_test.go

@@ -9,7 +9,7 @@ func TestReplyCode_ToError(t *testing.T) {
 		}
 	}
 	code := ReplyCode(254)
-	if x := code.ToError().Error(); x != "code(254)" {
+	if x := code.ToError().Error(); x != "socks5code(254)" {
 		t.Error(x)
 	}
 }

replyerror.go

@@ -0,0 +1,43 @@
+package socks5
+
+import "fmt"
+
+type ReplyError struct {
+	ReplyCode
+}
+
+var replyErrorText = []string{
+	ReplySuccess:              "success",
+	ReplyGeneralFailure:       "general failure",
+	ReplyConnectionNotAllowed: "connection not allowed",
+	ReplyNetworkUnreachable:   "network unreachable",
+	ReplyHostUnreachable:      "host unreachable",
+	ReplyConnectionRefused:    "connection refused",
+	ReplyTTLExpired:           "ttl expired",
+	ReplyCommandNotSupported:  "command not supported",
+	ReplyAddrTypeNotSupported: "address type not supported",
+}
+
+var (
+	ErrReply                     = ReplyError{ReplyGeneralFailure} // for testing against with errors.Is()
+	ErrReplySuccess              = ReplyError{ReplySuccess}
+	ErrReplyGeneralFailure       = ReplyError{ReplyGeneralFailure}
+	ErrReplyConnectionNotAllowed = ReplyError{ReplyConnectionNotAllowed}
+	ErrReplyNetworkUnreachable   = ReplyError{ReplyNetworkUnreachable}
+	ErrReplyHostUnreachable      = ReplyError{ReplyHostUnreachable}
+	ErrReplyConnectionRefused    = ReplyError{ReplyConnectionRefused}
+	ErrReplyTTLExpired           = ReplyError{ReplyTTLExpired}
+	ErrReplyCommandNotSupported  = ReplyError{ReplyCommandNotSupported}
+	ErrReplyAddrTypeNotSupported = ReplyError{ReplyAddrTypeNotSupported}
+)
+
+func (re ReplyError) Error() string {
+	if int(re.ReplyCode) < len(replyErrorText) {
+		return replyErrorText[re.ReplyCode]
+	}
+	return fmt.Sprintf("socks5code(%v)", re.ReplyCode)
+}
+
+func (re ReplyError) Is(target error) (yes bool) {
+	return target == ErrReply
+}

replyerror_test.go

@@ -0,0 +1,30 @@
+package socks5_test
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/linkdata/socks5"
+)
+
+func TestReplyError(t *testing.T) {
+	err := socks5.ErrReplyConnectionRefused
+	if !strings.Contains(err.Error(), "refused") {
+		t.Error(err.Error())
+	}
+	if !errors.Is(err, socks5.ErrReplyConnectionRefused) {
+		t.Error(err)
+	}
+	if !errors.Is(err, socks5.ErrReply) {
+		t.Errorf("%#v", err)
+	}
+	if errors.Is(err, socks5.ErrReplyHostUnreachable) {
+		t.Error(err)
+	}
+
+	re := socks5.ReplyError{99}
+	if x := re.Error(); x != "socks5code(99)" {
+		t.Error(x)
+	}
+}

server/dialerselector.go

@@ -5,5 +5,9 @@ import "github.com/linkdata/socks5"
 // A socks5.DialerSelector returns the ContextDialer to use.
 type DialerSelector interface {
 	// Socks5SelectDialer returns the ContextDialer to use.
+	//
+	// When called, client has already logged in using the given AuthMethod and username.
+	// In case of error, it is recommended to return one of the socks5.ErrReply... errors,
+	// as those will be mapped to SOCKS5 error codes in the reply to the client.
 	Socks5SelectDialer(am socks5.AuthMethod, username, network, address string) (cd socks5.ContextDialer, err error)
 }

server/handleassociate.go

@@ -26,7 +26,7 @@ func (sess *session) handleASSOCIATE(ctx context.Context) (err error) {
 			var bindPort uint16
 			if bindAddr, bindPort, err = socks5.SplitHostPort(clientUDPConn.LocalAddr().String()); err == nil {
 				res := &Response{
-					Reply: socks5.Success,
+					Reply: socks5.ReplySuccess,
 					Addr:  socks5.AddrFromHostPort(bindAddr, bindPort),
 				}
 				var buf []byte
@@ -40,7 +40,7 @@ func (sess *session) handleASSOCIATE(ctx context.Context) (err error) {
 		}
 	}
 	sess.maybeLogError(err, "ASSOCIATE", "session", sess.conn.RemoteAddr())
-	return sess.fail(socks5.GeneralFailure, err)
+	return sess.fail(err)
 }
 
 func (sess *session) serveUDP(ctx context.Context, clientTCPConn net.Conn, clientUDPConn net.PacketConn) (err error) {

server/handlebind.go

@@ -24,15 +24,15 @@ func (sess *session) handleBIND(ctx context.Context, bindaddr string) (err error
 		defer listener.Close()
 		var addr socks5.Addr
 		if addr, err = socks5.AddrFromString(listener.Addr().String()); err == nil {
-			if err = sendReply(sess.conn, socks5.Success, addr); err == nil {
+			if err = sendReply(sess.conn, socks5.ReplySuccess, addr); err == nil {
 				_ = sess.Debug && sess.LogDebug("BIND", "session", sess.conn.RemoteAddr(), "listen", addr)
 				var conn net.Conn
 				if conn, err = listener.Accept(); err == nil {
 					defer conn.Close()
 					var remoteAddr socks5.Addr
 					if remoteAddr, err = socks5.AddrFromString(conn.RemoteAddr().String()); err == nil {
 						_ = sess.Debug && sess.LogDebug("BIND", "session", sess.conn.RemoteAddr(), "remote-bound", remoteAddr)
-						if err = sendReply(sess.conn, socks5.Success, remoteAddr); err == nil {
+						if err = sendReply(sess.conn, socks5.ReplySuccess, remoteAddr); err == nil {
 							_ = sess.Debug && sess.LogDebug("BIND", "session", sess.conn.RemoteAddr(), "remote-start", remoteAddr)
 							ctx, cancel := context.WithCancel(ctx)
 							go func() {
@@ -53,6 +53,6 @@ func (sess *session) handleBIND(ctx context.Context, bindaddr string) (err error
 		}
 	}
 	sess.maybeLogError(err, "BIND", "session", sess.conn.RemoteAddr(), "adress", bindaddr)
-	_ = sendReply(sess.conn, socks5.GeneralFailure, socks5.ZeroAddr)
+	_ = sendReply(sess.conn, socks5.ReplyGeneralFailure, socks5.ZeroAddr)
 	return
 }

server/handleconnect.go

@@ -23,7 +23,7 @@ func (sess *session) handleCONNECT(ctx context.Context, addr string) (err error)
 		var serverPort uint16
 		if serverAddr, serverPort, err = socks5.SplitHostPort(localAddr); err == nil {
 			res := &Response{
-				Reply: socks5.Success,
+				Reply: socks5.ReplySuccess,
 				Addr:  socks5.AddrFromHostPort(serverAddr, serverPort),
 			}
 			var buf []byte
@@ -44,5 +44,5 @@ func (sess *session) handleCONNECT(ctx context.Context, addr string) (err error)
 		}
 	}
 	sess.maybeLogError(err, "CONNECT", "session", sess.conn.RemoteAddr(), "adress", addr)
-	return sess.fail(socks5.GeneralFailure, err)
+	return sess.fail(err)
 }