lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-06-25 00:45:24 +00:00
Code Issues Releases Wiki Activity

Unify error checking by introducing error codes

Browse Source
This commit is contained in:
V2Ray 2015-09-25 00:17:44 +02:00
parent 1995594b98
commit 08f85fc9b7
7 changed files with 124 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
common/errors/errors.go
View File

@ -4,55 +4,86 @@ import (
"fmt"
)
func HasCode(err error, code int) bool {
if errWithCode, ok := err.(ErrorWithCode); ok {
return errWithCode.Code() == code
}
return false
}
type ErrorWithCode interface {
error
Code() int
}
type ErrorCode int
func (code ErrorCode) Code() int {
return int(code)
}
func (code ErrorCode) Prefix() string {
return fmt.Sprintf("[Error 0x%04X] ", code.Code())
}
type AuthenticationError struct {
ErrorCode
AuthDetail interface{}
}
func NewAuthenticationError(detail interface{}) AuthenticationError {
return AuthenticationError{
ErrorCode: 1,
AuthDetail: detail,
}
}
func (err AuthenticationError) Error() string {
return fmt.Sprintf("[Error 0x0001] Invalid auth %v", err.AuthDetail)
return fmt.Sprintf("%sInvalid auth %v", err.Prefix(), err.AuthDetail)
}
type ProtocolVersionError struct {
ErrorCode
Version int
}
func NewProtocolVersionError(version int) ProtocolVersionError {
return ProtocolVersionError{
Version: version,
ErrorCode: 2,
Version: version,
}
}
func (err ProtocolVersionError) Error() string {
return fmt.Sprintf("[Error 0x0002] Invalid version %d", err.Version)
return fmt.Sprintf("%sInvalid version %d", err.Prefix(), err.Version)
}
type CorruptedPacketError struct {
ErrorCode
}
var corruptedPacketErrorInstance = CorruptedPacketError{ErrorCode: 3}
func NewCorruptedPacketError() CorruptedPacketError {
return CorruptedPacketError{}
return corruptedPacketErrorInstance
}
func (err CorruptedPacketError) Error() string {
return "[Error 0x0003] Corrupted packet."
return err.Prefix() + "Corrupted packet."
}
type IPFormatError struct {
ErrorCode
IP []byte
}
func NewIPFormatError(ip []byte) IPFormatError {
return IPFormatError{
IP: ip,
ErrorCode: 4,
IP: ip,
}
}
func (err IPFormatError) Error() string {
return fmt.Sprintf("[Error 0x0004] Invalid IP %v", err.IP)
return fmt.Sprintf("%sInvalid IP %v", err.Prefix(), err.IP)
}

23
common/errors/errors_test.go Normal file
View File

@ -0,0 +1,23 @@
package errors_test
import (
"testing"
"github.com/v2ray/v2ray-core/common/errors"
"github.com/v2ray/v2ray-core/testing/unit"
)
type MockError struct {
errors.ErrorCode
}
func (err MockError) Error() string {
return "This is a fake error."
}
func TestHasCode(t *testing.T) {
assert := unit.Assert(t)
err := MockError{ErrorCode: 101}
assert.Error(err).HasCode(101)
}

57
proxy/socks/protocol/socks.go
View File

@ -2,10 +2,9 @@ package protocol
import (
"encoding/binary"
"errors"
"fmt"
"io"
"github.com/v2ray/v2ray-core/common/errors"
"github.com/v2ray/v2ray-core/common/log"
v2net "github.com/v2ray/v2ray-core/common/net"
)
@ -23,10 +22,6 @@ const (
Socks4RequestRejected = byte(91)
)
var (
ErrorSocksVersion4 = errors.New("Using SOCKS version 4.")
)
// Authentication request header of Socks5 protocol
type Socks5AuthenticationRequest struct {
version byte
@ -34,13 +29,6 @@ type Socks5AuthenticationRequest struct {
authMethods [256]byte
}
type Socks4AuthenticationRequest struct {
Version byte
Command byte
Port uint16
IP [4]byte
}
func (request *Socks5AuthenticationRequest) HasAuthMethod(method byte) bool {
for i := 0; i < int(request.nMethods); i++ {
if request.authMethods[i] == method {
@ -54,11 +42,11 @@ func ReadAuthentication(reader io.Reader) (auth Socks5AuthenticationRequest, aut
buffer := make([]byte, 256)
nBytes, err := reader.Read(buffer)
if err != nil {
log.Error("Failed to read socks authentication: %v", err)
return
}
if nBytes < 2 {
err = fmt.Errorf("Expected 2 bytes read, but actaully %d bytes read", nBytes)
log.Info("Socks expected 2 bytes read, but only %d bytes read", nBytes)
err = errors.NewCorruptedPacketError()
return
}
@ -67,24 +55,26 @@ func ReadAuthentication(reader io.Reader) (auth Socks5AuthenticationRequest, aut
auth4.Command = buffer[1]
auth4.Port = binary.BigEndian.Uint16(buffer[2:4])
copy(auth4.IP[:], buffer[4:8])
err = ErrorSocksVersion4
err = NewSocksVersion4Error()
return
}
auth.version = buffer[0]
if auth.version != socksVersion {
err = fmt.Errorf("Unknown SOCKS version %d", auth.version)
err = errors.NewProtocolVersionError(int(auth.version))
return
}
auth.nMethods = buffer[1]
if auth.nMethods <= 0 {
err = fmt.Errorf("Zero length of authentication methods")
log.Info("Zero length of authentication methods")
err = errors.NewCorruptedPacketError()
return
}
if nBytes-2 != int(auth.nMethods) {
err = fmt.Errorf("Unmatching number of auth methods, expecting %d, but got %d", auth.nMethods, nBytes)
log.Info("Unmatching number of auth methods, expecting %d, but got %d", auth.nMethods, nBytes)
err = errors.NewCorruptedPacketError()
return
}
copy(auth.authMethods[:], buffer[2:nBytes])
@ -207,14 +197,13 @@ type Socks5Request struct {
}
func ReadRequest(reader io.Reader) (request *Socks5Request, err error) {
buffer := make([]byte, 4)
nBytes, err := reader.Read(buffer)
buffer := make([]byte, 256)
nBytes, err := reader.Read(buffer[:4])
if err != nil {
return
}
if nBytes < len(buffer) {
err = fmt.Errorf("Unable to read request.")
if nBytes < 4 {
err = errors.NewCorruptedPacketError()
return
}
request = &Socks5Request{
@ -230,11 +219,10 @@ func ReadRequest(reader io.Reader) (request *Socks5Request, err error) {
return
}
if nBytes != 4 {
err = fmt.Errorf("Unable to read IPv4 address.")
err = errors.NewCorruptedPacketError()
return
}
case AddrTypeDomain:
buffer = make([]byte, 256)
nBytes, err = reader.Read(buffer[0:1])
if err != nil {
return
@ -246,7 +234,8 @@ func ReadRequest(reader io.Reader) (request *Socks5Request, err error) {
}
if nBytes != int(domainLength) {
err = fmt.Errorf("Unable to read domain with %d bytes, expecting %d bytes", nBytes, domainLength)
log.Info("Unable to read domain with %d bytes, expecting %d bytes", nBytes, domainLength)
err = errors.NewCorruptedPacketError()
return
}
request.Domain = string(buffer[:domainLength])
@ -256,21 +245,21 @@ func ReadRequest(reader io.Reader) (request *Socks5Request, err error) {
return
}
if nBytes != 16 {
err = fmt.Errorf("Unable to read IPv4 address.")
err = errors.NewCorruptedPacketError()
return
}
default:
err = fmt.Errorf("Unexpected address type %d", request.AddrType)
log.Info("Unexpected address type %d", request.AddrType)
err = errors.NewCorruptedPacketError()
return
}
buffer = make([]byte, 2)
nBytes, err = reader.Read(buffer)
nBytes, err = reader.Read(buffer[:2])
if err != nil {
return
}
if nBytes != 2 {
err = fmt.Errorf("Unable to read port.")
err = errors.NewCorruptedPacketError()
return
}
@ -351,9 +340,7 @@ func (r *Socks5Response) toBytes() []byte {
case 0x04:
buffer = append(buffer, r.IPv6[:]...)
}
portBuffer := make([]byte, 2)
binary.BigEndian.PutUint16(portBuffer, r.Port)
buffer = append(buffer, portBuffer...)
buffer = append(buffer, byte(r.Port>>8), byte(r.Port))
return buffer
}

29
proxy/socks/protocol/socks4.go Normal file
View File

@ -0,0 +1,29 @@
package protocol
import (
_ "fmt"
"github.com/v2ray/v2ray-core/common/errors"
_ "github.com/v2ray/v2ray-core/common/log"
)
type SocksVersion4Error struct {
errors.ErrorCode
}
var socksVersion4ErrorInstance = SocksVersion4Error{ErrorCode: 1000}
func NewSocksVersion4Error() SocksVersion4Error {
return socksVersion4ErrorInstance
}
func (err SocksVersion4Error) Error() string {
return err.Prefix() + "Request is socks version 4."
}
type Socks4AuthenticationRequest struct {
Version byte
Command byte
Port uint16
IP [4]byte
}

2
proxy/socks/protocol/socks_test.go
View File

@ -47,7 +47,7 @@ func TestAuthentication4RequestRead(t *testing.T) {
0x72, 0x72, 0x72, 0x72,
}
_, request4, err := ReadAuthentication(bytes.NewReader(rawRequest))
assert.Error(err).Equals(ErrorSocksVersion4)
assert.Error(err).HasCode(1000)
assert.Byte(request4.Version).Named("Version").Equals(0x04)
assert.Byte(request4.Command).Named("Command").Equals(0x01)
assert.Uint16(request4.Port).Named("Port").Equals(53)

15
proxy/socks/socks.go
View File

@ -2,22 +2,23 @@ package socks
import (
_ "bufio"
"errors"
e2 "errors"
"io"
"net"
"strconv"
"sync"
"github.com/v2ray/v2ray-core"
"github.com/v2ray/v2ray-core/common/errors"
"github.com/v2ray/v2ray-core/common/log"
v2net "github.com/v2ray/v2ray-core/common/net"
protocol "github.com/v2ray/v2ray-core/proxy/socks/protocol"
"github.com/v2ray/v2ray-core/proxy/socks/protocol"
)
var (
ErrorAuthenticationFailed = errors.New("None of the authentication methods is allowed.")
ErrorCommandNotSupported = errors.New("Client requested an unsupported command.")
ErrorInvalidUser = errors.New("Invalid username or password.")
ErrorAuthenticationFailed = e2.New("None of the authentication methods is allowed.")
ErrorCommandNotSupported = e2.New("Client requested an unsupported command.")
ErrorInvalidUser = e2.New("Invalid username or password.")
)
// SocksServer is a SOCKS 5 proxy server
@ -66,7 +67,7 @@ func (server *SocksServer) HandleConnection(connection net.Conn) error {
reader := v2net.NewTimeOutReader(4, connection)
auth, auth4, err := protocol.ReadAuthentication(reader)
if err != nil && err != protocol.ErrorSocksVersion4 {
if err != nil && !errors.HasCode(err, 1000) {
log.Error("Error on reading authentication: %v", err)
return err
}
@ -74,7 +75,7 @@ func (server *SocksServer) HandleConnection(connection net.Conn) error {
var dest v2net.Destination
// TODO refactor this part
if err == protocol.ErrorSocksVersion4 {
if errors.HasCode(err, 1000) {
result := protocol.Socks4RequestGranted
if auth4.Command == protocol.CmdBind {
result = protocol.Socks4RequestRejected

6
testing/unit/errorsubject.go
View File

@ -2,7 +2,8 @@ package unit
import (
"fmt"
"strings"
"github.com/v2ray/v2ray-core/common/errors"
)
type ErrorSubject struct {
@ -43,8 +44,7 @@ func (subject *ErrorSubject) IsNil() {
}
func (subject *ErrorSubject) HasCode(code int) {
errorPrefix := fmt.Sprintf("[Error 0x%04X]", code)
if !strings.Contains(subject.value.Error(), errorPrefix) {
if !errors.HasCode(subject.value, code) {
subject.FailWithMessage(fmt.Sprintf("Not ture that %s has error code 0x%04X.", subject.DisplayString(), code))
}
}