lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2026-02-09 17:55:23 -05:00
Code Issues Releases Wiki Activity

refactor error messages

Browse Source
This commit is contained in:
Darien Raymond
2017-04-09 01:43:25 +02:00
parent 8175a751db
commit 35248497d2
141 changed files with 710 additions and 481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
proxy/blackhole/blackhole.go
View File

@@ -1,6 +1,8 @@
// Package blackhole is an outbound handler that blocks all connections.
package blackhole
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg blackhole -path Proxy,Blackhole
import (
"context"
"time"

7
proxy/blackhole/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package blackhole
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "Blackhole")
}

17
proxy/dokodemo/dokodemo.go
View File

@@ -1,5 +1,7 @@
package dokodemo
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg dokodemo -path Proxy,Dokodemo
import (
"context"
"runtime"
@@ -10,7 +12,6 @@ import (
"v2ray.com/core/app/log"
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/signal"
"v2ray.com/core/proxy"
@@ -26,10 +27,10 @@ type DokodemoDoor struct {
func New(ctx context.Context, config *Config) (*DokodemoDoor, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("Dokodemo: No space in context.")
return nil, newError("Dokodemo: No space in context.")
}
if config.NetworkList == nil || config.NetworkList.Size() == 0 {
return nil, errors.New("DokodemoDoor: No network specified.")
return nil, newError("DokodemoDoor: No network specified.")
}
d := &DokodemoDoor{
config: config,
@@ -44,7 +45,7 @@ func (d *DokodemoDoor) Network() net.NetworkList {
}
func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn internet.Connection, dispatcher dispatcher.Interface) error {
log.Trace(errors.New("Dokodemo: processing connection from: ", conn.RemoteAddr()).AtDebug())
log.Trace(newError("Dokodemo: processing connection from: ", conn.RemoteAddr()).AtDebug())
dest := net.Destination{
Network: network,
Address: d.address,
@@ -56,7 +57,7 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn in
}
}
if !dest.IsValid() || dest.Address == nil {
return errors.New("unable to get destination").Path("Proxy", "Dokodemo")
return newError("unable to get destination")
}
timeout := time.Second * time.Duration(d.config.Timeout)
@@ -76,7 +77,7 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn in
chunkReader := buf.NewReader(conn)
if err := buf.PipeUntilEOF(timer, chunkReader, inboundRay.InboundInput()); err != nil {
return errors.New("failed to transport request").Base(err).Path("Proxy", "Dokodemo")
return newError("failed to transport request").Base(err)
}
return nil
@@ -86,7 +87,7 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn in
v2writer := buf.NewWriter(conn)
if err := buf.PipeUntilEOF(timer, inboundRay.InboundOutput(), v2writer); err != nil {
return errors.New("failed to transport response").Base(err).Path("Proxy", "Dokodemo")
return newError("failed to transport response").Base(err)
}
return nil
})
@@ -94,7 +95,7 @@ func (d *DokodemoDoor) Process(ctx context.Context, network net.Network, conn in
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
inboundRay.InboundInput().CloseError()
inboundRay.InboundOutput().CloseError()
return errors.New("connection ends").Base(err).Path("Proxy", "Dokodemo")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)

7
proxy/dokodemo/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package dokodemo
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "Dokodemo")
}

5
proxy/errors.generated.go Normal file
View File

@@ -0,0 +1,5 @@
package proxy
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error { return errors.New(values...).Path("Proxy") }

7
proxy/freedom/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package freedom
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "Freedom")
}

20
proxy/freedom/freedom.go
View File

@@ -1,10 +1,11 @@
package freedom
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg freedom -path Proxy,Freedom
import (
"context"
"time"
"runtime"
"time"
"v2ray.com/core/app"
"v2ray.com/core/app/dns"
@@ -12,7 +13,6 @@ import (
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/dice"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/retry"
"v2ray.com/core/common/signal"
@@ -31,7 +31,7 @@ type Handler struct {
func New(ctx context.Context, config *Config) (*Handler, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("no space in context").Path("Proxy", "Freedom")
return nil, newError("no space in context")
}
f := &Handler{
domainStrategy: config.DomainStrategy,
@@ -42,7 +42,7 @@ func New(ctx context.Context, config *Config) (*Handler, error) {
if config.DomainStrategy == Config_USE_IP {
f.dns = dns.FromSpace(space)
if f.dns == nil {
return errors.New("DNS server is not found in the space").Path("Proxy", "Freedom")
return newError("DNS server is not found in the space")
}
}
return nil
@@ -57,7 +57,7 @@ func (v *Handler) ResolveIP(destination net.Destination) net.Destination {
ips := v.dns.Get(destination.Address.Domain())
if len(ips) == 0 {
log.Trace(errors.New("DNS returns nil answer. Keep domain as is.").Path("Proxy", "Freedom"))
log.Trace(newError("DNS returns nil answer. Keep domain as is."))
return destination
}
@@ -68,7 +68,7 @@ func (v *Handler) ResolveIP(destination net.Destination) net.Destination {
} else {
newDest = net.UDPDestination(net.IPAddress(ip), destination.Port)
}
log.Trace(errors.New("changing destination from ", destination, " to ", newDest).Path("Proxy", "Freedom"))
log.Trace(newError("changing destination from ", destination, " to ", newDest))
return newDest
}
@@ -82,7 +82,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
Port: net.Port(server.Port),
}
}
log.Trace(errors.New("opening connection to ", destination).Path("Proxy", "Freedom"))
log.Trace(newError("opening connection to ", destination))
input := outboundRay.OutboundInput()
output := outboundRay.OutboundOutput()
@@ -101,7 +101,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
return nil
})
if err != nil {
return errors.New("failed to open connection to ", destination).Base(err).Path("Proxy", "Freedom")
return newError("failed to open connection to ", destination).Base(err)
}
defer conn.Close()
@@ -132,7 +132,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
input.CloseError()
output.CloseError()
return errors.New("connection ends").Base(err).Path("Proxy", "Freedom")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)

5
proxy/handler_cache.go
View File

@@ -4,7 +4,6 @@ import (
"context"
"v2ray.com/core/common"
"v2ray.com/core/common/errors"
)
func CreateInboundHandler(ctx context.Context, config interface{}) (Inbound, error) {
@@ -16,7 +15,7 @@ func CreateInboundHandler(ctx context.Context, config interface{}) (Inbound, err
case Inbound:
return h, nil
default:
return nil, errors.New("Proxy: Not a InboundHandler.")
return nil, newError("Proxy: Not a InboundHandler.")
}
}
@@ -29,6 +28,6 @@ func CreateOutboundHandler(ctx context.Context, config interface{}) (Outbound, e
case Outbound:
return h, nil
default:
return nil, errors.New("Proxy: Not a OutboundHandler.")
return nil, newError("Proxy: Not a OutboundHandler.")
}
}

5
proxy/http/errors.generated.go Normal file
View File

@@ -0,0 +1,5 @@
package http
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error { return errors.New(values...).Path("Proxy", "HTTP") }

3
proxy/http/http.go Normal file
View File

@@ -0,0 +1,3 @@
package http
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg http -path Proxy,HTTP

16
proxy/http/server.go
View File

@@ -31,7 +31,7 @@ type Server struct {
func NewServer(ctx context.Context, config *ServerConfig) (*Server, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("no space in context.").Path("Proxy", "HTTP", "Server")
return nil, newError("no space in context.")
}
s := &Server{
config: config,
@@ -75,11 +75,11 @@ func (s *Server) Process(ctx context.Context, network v2net.Network, conn intern
request, err := http.ReadRequest(reader)
if err != nil {
if errors.Cause(err) != io.EOF {
log.Trace(errors.New("failed to read http request").Base(err).AtWarning().Path("Proxy", "HTTP", "Server"))
log.Trace(newError("failed to read http request").Base(err).AtWarning())
}
return err
}
log.Trace(errors.New("request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]").Path("Proxy", "HTTP", "Server"))
log.Trace(newError("request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]"))
conn.SetReadDeadline(time.Time{})
defaultPort := v2net.Port(80)
@@ -92,7 +92,7 @@ func (s *Server) Process(ctx context.Context, network v2net.Network, conn intern
}
dest, err := parseHost(host, defaultPort)
if err != nil {
return errors.New("malformed proxy host: ", host).AtWarning().Base(err).Path("Proxy", "HTTP", "Server")
return newError("malformed proxy host: ", host).AtWarning().Base(err)
}
log.Access(conn.RemoteAddr(), request.URL, log.AccessAccepted, "")
@@ -116,7 +116,7 @@ func (s *Server) handleConnect(ctx context.Context, request *http.Request, reade
Close: false,
}
if err := response.Write(writer); err != nil {
return errors.New("failed to write back OK response").Base(err).Path("Proxy", "HTTP", "Server")
return newError("failed to write back OK response").Base(err)
}
timeout := time.Second * time.Duration(s.config.Timeout)
@@ -150,7 +150,7 @@ func (s *Server) handleConnect(ctx context.Context, request *http.Request, reade
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
ray.InboundInput().CloseError()
ray.InboundOutput().CloseError()
return errors.New("connection ends").Base(err).Path("Proxy", "HTTP", "Server")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)
@@ -232,7 +232,7 @@ func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, rea
responseReader := bufio.NewReader(buf.ToBytesReader(ray.InboundOutput()))
response, err := http.ReadResponse(responseReader, request)
if err != nil {
log.Trace(errors.New("failed to read response").Base(err).AtWarning().Path("Proxy", "HTTP", "Server"))
log.Trace(newError("failed to read response").Base(err).AtWarning())
response = generateResponse(503, "Service Unavailable")
}
responseWriter := buf.NewBufferedWriter(writer)
@@ -249,7 +249,7 @@ func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, rea
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
input.CloseError()
output.CloseError()
return errors.New("connection ends").Base(err).Path("Proxy", "HTTP", "Server")
return newError("connection ends").Base(err)
}
return nil

2
proxy/proxy.go
View File

@@ -5,6 +5,8 @@
// 2. Register a config creator through common.RegisterConfig.
package proxy
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg proxy -path Proxy
import (
"context"

5
proxy/shadowsocks/config.go
View File

@@ -6,7 +6,6 @@ import (
"crypto/md5"
"v2ray.com/core/common/crypto"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/protocol"
)
@@ -34,14 +33,14 @@ func (v *Account) GetCipher() (Cipher, error) {
case CipherType_CHACHA20_IETF:
return &ChaCha20{IVBytes: 12}, nil
default:
return nil, errors.New("Unsupported cipher.")
return nil, newError("Unsupported cipher.")
}
}
func (v *Account) AsAccount() (protocol.Account, error) {
cipher, err := v.GetCipher()
if err != nil {
return nil, errors.New("failed to get cipher").Base(err).Path("Shadowsocks", "Account")
return nil, newError("failed to get cipher").Base(err)
}
return &ShadowsocksAccount{
Cipher: cipher,

3
proxy/shadowsocks/ota.go
View File

@@ -7,7 +7,6 @@ import (
"io"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/serial"
)
@@ -97,7 +96,7 @@ func (v *ChunkReader) Read() (*buf.Buffer, error) {
v.auth.Authenticate(payload)(actualAuthBytes)
if !bytes.Equal(authBytes, actualAuthBytes) {
buffer.Release()
return nil, errors.New("invalid auth").Path("Proxy", "Shadowsocks", "ChunkReader")
return nil, newError("invalid auth")
}
buffer.SliceFrom(AuthSize)

69
proxy/shadowsocks/protocol.go
View File

@@ -7,7 +7,6 @@ import (
"v2ray.com/core/common/buf"
"v2ray.com/core/common/crypto"
"v2ray.com/core/common/errors"
v2net "v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
@@ -25,7 +24,7 @@ const (
func ReadTCPSession(user *protocol.User, reader io.Reader) (*protocol.RequestHeader, buf.Reader, error) {
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, nil, errors.New("failed to parse account").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to parse account").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -35,14 +34,14 @@ func ReadTCPSession(user *protocol.User, reader io.Reader) (*protocol.RequestHea
ivLen := account.Cipher.IVSize()
err = buffer.AppendSupplier(buf.ReadFullFrom(reader, ivLen))
if err != nil {
return nil, nil, errors.New("failed to read IV").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read IV").Base(err)
}
iv := append([]byte(nil), buffer.BytesTo(ivLen)...)
stream, err := account.Cipher.NewDecodingStream(account.Key, iv)
if err != nil {
return nil, nil, errors.New("failed to initialize decoding stream").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to initialize decoding stream").Base(err)
}
reader = crypto.NewCryptionReader(stream, reader)
@@ -56,7 +55,7 @@ func ReadTCPSession(user *protocol.User, reader io.Reader) (*protocol.RequestHea
buffer.Clear()
err = buffer.AppendSupplier(buf.ReadFullFrom(reader, 1))
if err != nil {
return nil, nil, errors.New("failed to read address type").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read address type").Base(err)
}
addrType := (buffer.Byte(0) & 0x0F)
@@ -65,35 +64,35 @@ func ReadTCPSession(user *protocol.User, reader io.Reader) (*protocol.RequestHea
}
if request.Option.Has(RequestOptionOneTimeAuth) && account.OneTimeAuth == Account_Disabled {
return nil, nil, errors.New("rejecting connection with OTA enabled, while server disables OTA").Path("Shadowsocks", "TCP")
return nil, nil, newError("rejecting connection with OTA enabled, while server disables OTA")
}
if !request.Option.Has(RequestOptionOneTimeAuth) && account.OneTimeAuth == Account_Enabled {
return nil, nil, errors.New("rejecting connection with OTA disabled, while server enables OTA").Path("Shadowsocks", "TCP")
return nil, nil, newError("rejecting connection with OTA disabled, while server enables OTA")
}
switch addrType {
case AddrTypeIPv4:
err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 4))
if err != nil {
return nil, nil, errors.New("failed to read IPv4 address").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read IPv4 address").Base(err)
}
request.Address = v2net.IPAddress(buffer.BytesFrom(-4))
case AddrTypeIPv6:
err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 16))
if err != nil {
return nil, nil, errors.New("failed to read IPv6 address").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read IPv6 address").Base(err)
}
request.Address = v2net.IPAddress(buffer.BytesFrom(-16))
case AddrTypeDomain:
err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 1))
if err != nil {
return nil, nil, errors.New("failed to read domain lenth.").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read domain lenth.").Base(err)
}
domainLength := int(buffer.BytesFrom(-1)[0])
err = buffer.AppendSupplier(buf.ReadFullFrom(reader, domainLength))
if err != nil {
return nil, nil, errors.New("failed to read domain").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read domain").Base(err)
}
request.Address = v2net.DomainAddress(string(buffer.BytesFrom(-domainLength)))
default:
@@ -102,7 +101,7 @@ func ReadTCPSession(user *protocol.User, reader io.Reader) (*protocol.RequestHea
err = buffer.AppendSupplier(buf.ReadFullFrom(reader, 2))
if err != nil {
return nil, nil, errors.New("failed to read port").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("failed to read port").Base(err)
}
request.Port = v2net.PortFromBytes(buffer.BytesFrom(-2))
@@ -112,16 +111,16 @@ func ReadTCPSession(user *protocol.User, reader io.Reader) (*protocol.RequestHea
err := buffer.AppendSupplier(buf.ReadFullFrom(reader, AuthSize))
if err != nil {
return nil, nil, errors.New("Failed to read OTA").Path("Shadowsocks", "TCP").Base(err)
return nil, nil, newError("Failed to read OTA").Base(err)
}
if !bytes.Equal(actualAuth, buffer.BytesFrom(-AuthSize)) {
return nil, nil, errors.New("invalid OTA").Path("Shadowsocks", "TCP")
return nil, nil, newError("invalid OTA")
}
}
if request.Address == nil {
return nil, nil, errors.New("invalid remote address.").Path("Shadowsocks", "TCP")
return nil, nil, newError("invalid remote address.")
}
var chunkReader buf.Reader
@@ -138,7 +137,7 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
user := request.User
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.New("failed to parse account").Path("Shadowsocks", "TCP").Base(err)
return nil, newError("failed to parse account").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -146,12 +145,12 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
rand.Read(iv)
_, err = writer.Write(iv)
if err != nil {
return nil, errors.New("failed to write IV").Path("Shadowsocks", "TCP")
return nil, newError("failed to write IV")
}
stream, err := account.Cipher.NewEncodingStream(account.Key, iv)
if err != nil {
return nil, errors.New("failed to create encoding stream").Path("Shadowsocks", "TCP").Base(err)
return nil, newError("failed to create encoding stream").Base(err)
}
writer = crypto.NewCryptionWriter(stream, writer)
@@ -169,7 +168,7 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
header.AppendBytes(AddrTypeDomain, byte(len(request.Address.Domain())))
header.Append([]byte(request.Address.Domain()))
default:
return nil, errors.New("Shadowsocks|TCP: Unsupported address type: ", request.Address.Family())
return nil, newError("Shadowsocks|TCP: Unsupported address type: ", request.Address.Family())
}
header.AppendSupplier(serial.WriteUint16(uint16(request.Port)))
@@ -183,7 +182,7 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
_, err = writer.Write(header.Bytes())
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to write header.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to write header.").Base(err)
}
var chunkWriter buf.Writer
@@ -199,19 +198,19 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
func ReadTCPResponse(user *protocol.User, reader io.Reader) (buf.Reader, error) {
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to parse account.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
iv := make([]byte, account.Cipher.IVSize())
_, err = io.ReadFull(reader, iv)
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to read IV.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to read IV.").Base(err)
}
stream, err := account.Cipher.NewDecodingStream(account.Key, iv)
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to initialize decoding stream.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to initialize decoding stream.").Base(err)
}
return buf.NewReader(crypto.NewCryptionReader(stream, reader)), nil
}
@@ -220,7 +219,7 @@ func WriteTCPResponse(request *protocol.RequestHeader, writer io.Writer) (buf.Wr
user := request.User
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to parse account.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -228,12 +227,12 @@ func WriteTCPResponse(request *protocol.RequestHeader, writer io.Writer) (buf.Wr
rand.Read(iv)
_, err = writer.Write(iv)
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to write IV.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to write IV.").Base(err)
}
stream, err := account.Cipher.NewEncodingStream(account.Key, iv)
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to create encoding stream.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to create encoding stream.").Base(err)
}
return buf.NewWriter(crypto.NewCryptionWriter(stream, writer)), nil
@@ -243,7 +242,7 @@ func EncodeUDPPacket(request *protocol.RequestHeader, payload *buf.Buffer) (*buf
user := request.User
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.New("Shadowsocks|UDP: Failed to parse account.").Base(err)
return nil, newError("Shadowsocks|UDP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -263,7 +262,7 @@ func EncodeUDPPacket(request *protocol.RequestHeader, payload *buf.Buffer) (*buf
buffer.AppendBytes(AddrTypeDomain, byte(len(request.Address.Domain())))
buffer.Append([]byte(request.Address.Domain()))
default:
return nil, errors.New("Shadowsocks|UDP: Unsupported address type: ", request.Address.Family())
return nil, newError("Shadowsocks|UDP: Unsupported address type: ", request.Address.Family())
}
buffer.AppendSupplier(serial.WriteUint16(uint16(request.Port)))
@@ -278,7 +277,7 @@ func EncodeUDPPacket(request *protocol.RequestHeader, payload *buf.Buffer) (*buf
stream, err := account.Cipher.NewEncodingStream(account.Key, iv)
if err != nil {
return nil, errors.New("Shadowsocks|TCP: Failed to create encoding stream.").Base(err)
return nil, newError("Shadowsocks|TCP: Failed to create encoding stream.").Base(err)
}
stream.XORKeyStream(buffer.BytesFrom(ivLen), buffer.BytesFrom(ivLen))
@@ -288,7 +287,7 @@ func EncodeUDPPacket(request *protocol.RequestHeader, payload *buf.Buffer) (*buf
func DecodeUDPPacket(user *protocol.User, payload *buf.Buffer) (*protocol.RequestHeader, *buf.Buffer, error) {
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, nil, errors.New("Shadowsocks|UDP: Failed to parse account.").Base(err)
return nil, nil, newError("Shadowsocks|UDP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -298,7 +297,7 @@ func DecodeUDPPacket(user *protocol.User, payload *buf.Buffer) (*protocol.Reques
stream, err := account.Cipher.NewDecodingStream(account.Key, iv)
if err != nil {
return nil, nil, errors.New("Shadowsocks|UDP: Failed to initialize decoding stream.").Base(err)
return nil, nil, newError("Shadowsocks|UDP: Failed to initialize decoding stream.").Base(err)
}
stream.XORKeyStream(payload.Bytes(), payload.Bytes())
@@ -315,11 +314,11 @@ func DecodeUDPPacket(user *protocol.User, payload *buf.Buffer) (*protocol.Reques
}
if request.Option.Has(RequestOptionOneTimeAuth) && account.OneTimeAuth == Account_Disabled {
return nil, nil, errors.New("Shadowsocks|UDP: Rejecting packet with OTA enabled, while server disables OTA.")
return nil, nil, newError("Shadowsocks|UDP: Rejecting packet with OTA enabled, while server disables OTA.")
}
if !request.Option.Has(RequestOptionOneTimeAuth) && account.OneTimeAuth == Account_Enabled {
return nil, nil, errors.New("Shadowsocks|UDP: Rejecting packet with OTA disabled, while server enables OTA.")
return nil, nil, newError("Shadowsocks|UDP: Rejecting packet with OTA disabled, while server enables OTA.")
}
if request.Option.Has(RequestOptionOneTimeAuth) {
@@ -329,7 +328,7 @@ func DecodeUDPPacket(user *protocol.User, payload *buf.Buffer) (*protocol.Reques
actualAuth := make([]byte, AuthSize)
authenticator.Authenticate(payload.BytesTo(payloadLen))(actualAuth)
if !bytes.Equal(actualAuth, authBytes) {
return nil, nil, errors.New("Shadowsocks|UDP: Invalid OTA.")
return nil, nil, newError("Shadowsocks|UDP: Invalid OTA.")
}
payload.Slice(0, payloadLen)
@@ -349,7 +348,7 @@ func DecodeUDPPacket(user *protocol.User, payload *buf.Buffer) (*protocol.Reques
request.Address = v2net.DomainAddress(string(payload.BytesRange(1, 1+domainLength)))
payload.SliceFrom(1 + domainLength)
default:
return nil, nil, errors.New("Shadowsocks|UDP: Unknown address type: ", addrType)
return nil, nil, newError("Shadowsocks|UDP: Unknown address type: ", addrType)
}
request.Port = v2net.PortFromBytes(payload.BytesTo(2))

31
proxy/shadowsocks/server.go
View File

@@ -10,7 +10,6 @@ import (
"v2ray.com/core/app/log"
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/signal"
@@ -29,15 +28,15 @@ type Server struct {
func NewServer(ctx context.Context, config *ServerConfig) (*Server, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("no space in context").Path("Proxy", "Shadowsocks", "Server")
return nil, newError("no space in context")
}
if config.GetUser() == nil {
return nil, errors.New("user is not specified").Path("Proxy", "Shadowsocks", "Server")
return nil, newError("user is not specified")
}
rawAccount, err := config.User.GetTypedAccount()
if err != nil {
return nil, errors.New("failed to get user account").Base(err).Path("Proxy", "Shadowsocks", "Server")
return nil, newError("failed to get user account").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -67,7 +66,7 @@ func (s *Server) Process(ctx context.Context, network net.Network, conn internet
case net.Network_UDP:
return s.handlerUDPPayload(ctx, conn, dispatcher)
default:
return errors.New("unknown network: ", network).Path("Proxy", "Shadowsocks", "Server")
return newError("unknown network: ", network)
}
}
@@ -84,7 +83,7 @@ func (v *Server) handlerUDPPayload(ctx context.Context, conn internet.Connection
request, data, err := DecodeUDPPacket(v.user, payload)
if err != nil {
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Trace(errors.New("dropping invalid UDP packet from: ", source).Base(err).Path("Proxy", "Shadowsocks", "Server"))
log.Trace(newError("dropping invalid UDP packet from: ", source).Base(err))
log.Access(source, "", log.AccessRejected, err)
}
payload.Release()
@@ -92,13 +91,13 @@ func (v *Server) handlerUDPPayload(ctx context.Context, conn internet.Connection
}
if request.Option.Has(RequestOptionOneTimeAuth) && v.account.OneTimeAuth == Account_Disabled {
log.Trace(errors.New("client payload enables OTA but server doesn't allow it").Path("Proxy", "Shadowsocks", "Server"))
log.Trace(newError("client payload enables OTA but server doesn't allow it"))
payload.Release()
continue
}
if !request.Option.Has(RequestOptionOneTimeAuth) && v.account.OneTimeAuth == Account_Enabled {
log.Trace(errors.New("client payload disables OTA but server forces it").Path("Proxy", "Shadowsocks", "Server"))
log.Trace(newError("client payload disables OTA but server forces it"))
payload.Release()
continue
}
@@ -107,7 +106,7 @@ func (v *Server) handlerUDPPayload(ctx context.Context, conn internet.Connection
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, dest, log.AccessAccepted, "")
}
log.Trace(errors.New("tunnelling request to ", dest).Path("Proxy", "Shadowsocks", "Server"))
log.Trace(newError("tunnelling request to ", dest))
ctx = protocol.ContextWithUser(ctx, request.User)
udpServer.Dispatch(ctx, dest, data, func(payload *buf.Buffer) {
@@ -115,7 +114,7 @@ func (v *Server) handlerUDPPayload(ctx context.Context, conn internet.Connection
data, err := EncodeUDPPacket(request, payload)
if err != nil {
log.Trace(errors.New("failed to encode UDP packet").Base(err).Path("Proxy", "Shadowsocks", "Server").AtWarning())
log.Trace(newError("failed to encode UDP packet").Base(err).AtWarning())
return
}
defer data.Release()
@@ -133,7 +132,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
request, bodyReader, err := ReadTCPSession(s.user, bufferedReader)
if err != nil {
log.Access(conn.RemoteAddr(), "", log.AccessRejected, err)
return errors.New("failed to create request from: ", conn.RemoteAddr()).Base(err).Path("Proxy", "Shadowsocks", "Server")
return newError("failed to create request from: ", conn.RemoteAddr()).Base(err)
}
conn.SetReadDeadline(time.Time{})
@@ -141,7 +140,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
dest := request.Destination()
log.Access(conn.RemoteAddr(), dest, log.AccessAccepted, "")
log.Trace(errors.New("tunnelling request to ", dest).Path("Proxy", "Shadowsocks", "Server"))
log.Trace(newError("tunnelling request to ", dest))
ctx = protocol.ContextWithUser(ctx, request.User)
@@ -156,7 +155,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
bufferedWriter := buf.NewBufferedWriter(conn)
responseWriter, err := WriteTCPResponse(request, bufferedWriter)
if err != nil {
return errors.New("failed to write response").Base(err).Path("Proxy", "Shadowsocks", "Server")
return newError("failed to write response").Base(err)
}
mergeReader := buf.NewMergingReader(ray.InboundOutput())
@@ -174,7 +173,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
}
if err := buf.PipeUntilEOF(timer, mergeReader, responseWriter); err != nil {
return errors.New("failed to transport all TCP response").Base(err).Path("Proxy", "Shadowsocks", "Server")
return newError("failed to transport all TCP response").Base(err)
}
return nil
@@ -184,7 +183,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
defer ray.InboundInput().Close()
if err := buf.PipeUntilEOF(timer, bodyReader, ray.InboundInput()); err != nil {
return errors.New("failed to transport all TCP request").Base(err).Path("Proxy", "Shadowsocks", "Server")
return newError("failed to transport all TCP request").Base(err)
}
return nil
})
@@ -192,7 +191,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
ray.InboundInput().CloseError()
ray.InboundOutput().CloseError()
return errors.New("connection ends").Base(err).Path("Proxy", "Shadowsocks", "Server")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)

11
proxy/socks/client.go
View File

@@ -7,7 +7,6 @@ import (
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/retry"
@@ -36,7 +35,7 @@ func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.Dialer) error {
destination, ok := proxy.TargetFromContext(ctx)
if !ok {
return errors.New("target not specified.").Path("Proxy", "Socks", "Client")
return newError("target not specified.")
}
var server *protocol.ServerSpec
@@ -55,7 +54,7 @@ func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.
})
if err != nil {
return errors.New("failed to find an available destination").Base(err).Path("Proxy", "Socks", "Client")
return newError("failed to find an available destination").Base(err)
}
defer conn.Close()
@@ -77,7 +76,7 @@ func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.
udpRequest, err := ClientHandshake(request, conn, conn)
if err != nil {
return errors.New("failed to establish connection to server").AtWarning().Base(err).Path("Proxy", "Socks", "Client")
return newError("failed to establish connection to server").AtWarning().Base(err)
}
ctx, timer := signal.CancelAfterInactivity(ctx, time.Minute*2)
@@ -95,7 +94,7 @@ func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.
} else if request.Command == protocol.RequestCommandUDP {
udpConn, err := dialer.Dial(ctx, udpRequest.Destination())
if err != nil {
return errors.New("failed to create UDP connection").Base(err).Path("Proxy", "Socks", "Client")
return newError("failed to create UDP connection").Base(err)
}
defer udpConn.Close()
requestFunc = func() error {
@@ -111,7 +110,7 @@ func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.
requestDone := signal.ExecuteAsync(requestFunc)
responseDone := signal.ExecuteAsync(responseFunc)
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
return errors.New("connection ends").Base(err).Path("Proxy", "Socks", "Client")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)

7
proxy/socks/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package socks
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "Socks")
}

53
proxy/socks/protocol.go
View File

@@ -4,7 +4,6 @@ import (
"io"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
v2net "v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
@@ -44,13 +43,13 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
request := new(protocol.RequestHeader)
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 2)); err != nil {
return nil, errors.New("insufficient header").Base(err).Path("Socks", "Server")
return nil, newError("insufficient header").Base(err)
}
version := buffer.Byte(0)
if version == socks4Version {
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 6)); err != nil {
return nil, errors.New("insufficient header").Base(err).Path("Socks", "Server")
return nil, newError("insufficient header").Base(err)
}
port := v2net.PortFromBytes(buffer.BytesRange(2, 4))
address := v2net.IPAddress(buffer.BytesRange(4, 8))
@@ -61,7 +60,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
if address.IP()[0] == 0x00 {
domain, err := readUntilNull(reader)
if err != nil {
return nil, errors.New("failed to read domain for socks 4a").Base(err).Path("Socks", "Server")
return nil, newError("failed to read domain for socks 4a").Base(err)
}
address = v2net.DomainAddress(domain)
}
@@ -78,14 +77,14 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
return request, nil
default:
writeSocks4Response(writer, socks4RequestRejected, v2net.AnyIP, v2net.Port(0))
return nil, errors.New("Socks|Server: Unsupported command: ", buffer.Byte(1))
return nil, newError("Socks|Server: Unsupported command: ", buffer.Byte(1))
}
}
if version == socks5Version {
nMethod := int(buffer.Byte(1))
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, nMethod)); err != nil {
return nil, errors.New("failed to read auth methods").Base(err).Path("Socks", "Server")
return nil, newError("failed to read auth methods").Base(err)
}
var expectedAuth byte = authNotRequired
@@ -95,37 +94,37 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
if !hasAuthMethod(expectedAuth, buffer.BytesRange(2, 2+nMethod)) {
writeSocks5AuthenticationResponse(writer, socks5Version, authNoMatchingMethod)
return nil, errors.New("no matching auth method").Path("Socks", "Server")
return nil, newError("no matching auth method")
}
if err := writeSocks5AuthenticationResponse(writer, socks5Version, expectedAuth); err != nil {
return nil, errors.New("failed to write auth response").Base(err).Path("Socks", "Server")
return nil, newError("failed to write auth response").Base(err)
}
if expectedAuth == authPassword {
username, password, err := readUsernamePassword(reader)
if err != nil {
return nil, errors.New("failed to read username and password for authentication").Base(err).Path("Socks", "Server")
return nil, newError("failed to read username and password for authentication").Base(err)
}
if !s.config.HasAccount(username, password) {
writeSocks5AuthenticationResponse(writer, 0x01, 0xFF)
return nil, errors.New("invalid username or password").Path("Socks", "Server")
return nil, newError("invalid username or password")
}
if err := writeSocks5AuthenticationResponse(writer, 0x01, 0x00); err != nil {
return nil, errors.New("failed to write auth response").Base(err).Path("Socks", "Server")
return nil, newError("failed to write auth response").Base(err)
}
}
buffer.Clear()
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 4)); err != nil {
return nil, errors.New("failed to read request").Base(err).Path("Socks", "Server")
return nil, newError("failed to read request").Base(err)
}
cmd := buffer.Byte(1)
if cmd == cmdTCPBind || (cmd == cmdUDPPort && !s.config.UdpEnabled) {
writeSocks5Response(writer, statusCmdNotSupport, v2net.AnyIP, v2net.Port(0))
return nil, errors.New("unsupported command: ", cmd).Path("Socks", "Server")
return nil, newError("unsupported command: ", cmd)
}
switch cmd {
@@ -161,7 +160,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
}
request.Address = v2net.ParseAddress(string(buffer.BytesFrom(-domainLength)))
default:
return nil, errors.New("Unknown address type: ", addrType).Path("Socks", "Server")
return nil, newError("Unknown address type: ", addrType)
}
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 2)); err != nil {
@@ -186,7 +185,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
return request, nil
}
return nil, errors.New("unknown Socks version: ", version).Path("Socks", "Server")
return nil, newError("unknown Socks version: ", version)
}
func readUsernamePassword(reader io.Reader) (string, string, error) {
@@ -230,7 +229,7 @@ func readUntilNull(reader io.Reader) (string, error) {
}
size++
if size == 256 {
return "", errors.New("buffer overrun").Path("Socks", "Server")
return "", newError("buffer overrun")
}
}
}
@@ -284,7 +283,7 @@ func writeSocks4Response(writer io.Writer, errCode byte, address v2net.Address,
func DecodeUDPPacket(packet []byte) (*protocol.RequestHeader, []byte, error) {
if len(packet) < 5 {
return nil, nil, errors.New("Socks|UDP: Insufficient length of packet.")
return nil, nil, newError("Socks|UDP: Insufficient length of packet.")
}
request := &protocol.RequestHeader{
Version: socks5Version,
@@ -293,7 +292,7 @@ func DecodeUDPPacket(packet []byte) (*protocol.RequestHeader, []byte, error) {
// packet[0] and packet[1] are reserved
if packet[2] != 0 /* fragments */ {
return nil, nil, errors.New("Socks|UDP: Fragmented payload.")
return nil, nil, newError("Socks|UDP: Fragmented payload.")
}
addrType := packet[3]
@@ -302,7 +301,7 @@ func DecodeUDPPacket(packet []byte) (*protocol.RequestHeader, []byte, error) {
switch addrType {
case addrTypeIPv4:
if len(packet) < 10 {
return nil, nil, errors.New("Socks|UDP: Insufficient length of packet.")
return nil, nil, newError("Socks|UDP: Insufficient length of packet.")
}
ip := packet[4:8]
request.Port = v2net.PortFromBytes(packet[8:10])
@@ -310,7 +309,7 @@ func DecodeUDPPacket(packet []byte) (*protocol.RequestHeader, []byte, error) {
dataBegin = 10
case addrTypeIPv6:
if len(packet) < 22 {
return nil, nil, errors.New("Socks|UDP: Insufficient length of packet.")
return nil, nil, newError("Socks|UDP: Insufficient length of packet.")
}
ip := packet[4:20]
request.Port = v2net.PortFromBytes(packet[20:22])
@@ -319,14 +318,14 @@ func DecodeUDPPacket(packet []byte) (*protocol.RequestHeader, []byte, error) {
case addrTypeDomain:
domainLength := int(packet[4])
if len(packet) < 5+domainLength+2 {
return nil, nil, errors.New("Socks|UDP: Insufficient length of packet.")
return nil, nil, newError("Socks|UDP: Insufficient length of packet.")
}
domain := string(packet[5 : 5+domainLength])
request.Port = v2net.PortFromBytes(packet[5+domainLength : 5+domainLength+2])
request.Address = v2net.ParseAddress(domain)
dataBegin = 5 + domainLength + 2
default:
return nil, nil, errors.New("Socks|UDP: Unknown address type ", addrType)
return nil, nil, newError("Socks|UDP: Unknown address type ", addrType)
}
return request, packet[dataBegin:], nil
@@ -400,10 +399,10 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
}
if b.Byte(0) != socks5Version {
return nil, errors.New("Socks|Client: Unexpected server version: ", b.Byte(0)).AtWarning()
return nil, newError("Socks|Client: Unexpected server version: ", b.Byte(0)).AtWarning()
}
if b.Byte(1) != authByte {
return nil, errors.New("Socks|Client: auth method not supported.").AtWarning()
return nil, newError("Socks|Client: auth method not supported.").AtWarning()
}
if authByte == authPassword {
@@ -426,7 +425,7 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
return nil, err
}
if b.Byte(1) != 0x00 {
return nil, errors.New("Socks|Client: Server rejects account: ", b.Byte(1))
return nil, newError("Socks|Client: Server rejects account: ", b.Byte(1))
}
}
@@ -449,7 +448,7 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
resp := b.Byte(1)
if resp != 0x00 {
return nil, errors.New("Socks|Client: Server rejects request: ", resp)
return nil, newError("Socks|Client: Server rejects request: ", resp)
}
addrType := b.Byte(3)
@@ -478,7 +477,7 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
}
address = v2net.DomainAddress(string(b.BytesFrom(-domainLength)))
default:
return nil, errors.New("Socks|Server: Unknown address type: ", addrType)
return nil, newError("Socks|Server: Unknown address type: ", addrType)
}
if err := b.AppendSupplier(buf.ReadFullFrom(reader, 2)); err != nil {

25
proxy/socks/server.go
View File

@@ -11,7 +11,6 @@ import (
"v2ray.com/core/app/log"
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/signal"
@@ -29,7 +28,7 @@ type Server struct {
func NewServer(ctx context.Context, config *ServerConfig) (*Server, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("no space in context").AtWarning().Path("Proxy", "Socks", "Server")
return nil, newError("no space in context").AtWarning()
}
s := &Server{
config: config,
@@ -54,7 +53,7 @@ func (s *Server) Process(ctx context.Context, network net.Network, conn internet
case net.Network_UDP:
return s.handleUDPPayload(ctx, conn, dispatcher)
default:
return errors.New("unknown network: ", network).Path("Proxy", "Socks", "Server")
return newError("unknown network: ", network)
}
}
@@ -64,7 +63,7 @@ func (s *Server) processTCP(ctx context.Context, conn internet.Connection, dispa
inboundDest, ok := proxy.InboundEntryPointFromContext(ctx)
if !ok {
return errors.New("inbound entry point not specified").Path("Proxy", "Socks", "Server")
return newError("inbound entry point not specified")
}
session := &ServerSession{
config: s.config,
@@ -76,14 +75,14 @@ func (s *Server) processTCP(ctx context.Context, conn internet.Connection, dispa
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, "", log.AccessRejected, err)
}
log.Trace(errors.New("failed to read request").Base(err).Path("Proxy", "Socks", "Server"))
log.Trace(newError("failed to read request").Base(err))
return err
}
conn.SetReadDeadline(time.Time{})
if request.Command == protocol.RequestCommandTCP {
dest := request.Destination()
log.Trace(errors.New("TCP Connect request to ", dest).Path("Proxy", "Socks", "Server"))
log.Trace(newError("TCP Connect request to ", dest))
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, dest, log.AccessAccepted, "")
}
@@ -127,7 +126,7 @@ func (v *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
v2reader := buf.NewReader(reader)
if err := buf.PipeUntilEOF(timer, v2reader, input); err != nil {
return errors.New("failed to transport all TCP request").Base(err).Path("Proxy", "Socks", "Server")
return newError("failed to transport all TCP request").Base(err)
}
return nil
})
@@ -135,7 +134,7 @@ func (v *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
responseDone := signal.ExecuteAsync(func() error {
v2writer := buf.NewWriter(writer)
if err := buf.PipeUntilEOF(timer, output, v2writer); err != nil {
return errors.New("failed to transport all TCP response").Base(err).Path("Proxy", "Socks", "Server")
return newError("failed to transport all TCP response").Base(err)
}
return nil
})
@@ -143,7 +142,7 @@ func (v *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
input.CloseError()
output.CloseError()
return errors.New("connection ends").Base(err).Path("Proxy", "Socks", "Server")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)
@@ -155,7 +154,7 @@ func (v *Server) handleUDPPayload(ctx context.Context, conn internet.Connection,
udpServer := udp.NewDispatcher(dispatcher)
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Trace(errors.New("client UDP connection from ", source).Path("Proxy", "Socks", "Server"))
log.Trace(newError("client UDP connection from ", source))
}
reader := buf.NewReader(conn)
@@ -167,7 +166,7 @@ func (v *Server) handleUDPPayload(ctx context.Context, conn internet.Connection,
request, data, err := DecodeUDPPacket(payload.Bytes())
if err != nil {
log.Trace(errors.New("failed to parse UDP request").Base(err).Path("Proxy", "Socks", "Server"))
log.Trace(newError("failed to parse UDP request").Base(err))
continue
}
@@ -175,7 +174,7 @@ func (v *Server) handleUDPPayload(ctx context.Context, conn internet.Connection,
continue
}
log.Trace(errors.New("send packet to ", request.Destination(), " with ", len(data), " bytes").Path("Proxy", "Socks", "Server").AtDebug())
log.Trace(newError("send packet to ", request.Destination(), " with ", len(data), " bytes").AtDebug())
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Access(source, request.Destination, log.AccessAccepted, "")
}
@@ -185,7 +184,7 @@ func (v *Server) handleUDPPayload(ctx context.Context, conn internet.Connection,
udpServer.Dispatch(ctx, request.Destination(), dataBuf, func(payload *buf.Buffer) {
defer payload.Release()
log.Trace(errors.New("writing back UDP response with ", payload.Len(), " bytes").Path("Proxy", "Socks", "Server").AtDebug())
log.Trace(newError("writing back UDP response with ", payload.Len(), " bytes").AtDebug())
udpMessage := EncodeUDPPacket(request, payload.Bytes())
defer udpMessage.Release()

2
proxy/socks/socks.go
View File

@@ -1,2 +1,4 @@
// Package socks provides implements of Socks protocol 4, 4a and 5.
package socks
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg socks -path Proxy,Socks

3
proxy/vmess/account.go
View File

@@ -3,7 +3,6 @@ package vmess
import (
"v2ray.com/core/app/log"
"v2ray.com/core/common/dice"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/uuid"
)
@@ -33,7 +32,7 @@ func (v *InternalAccount) Equals(account protocol.Account) bool {
func (v *Account) AsAccount() (protocol.Account, error) {
id, err := uuid.ParseString(v.Id)
if err != nil {
log.Trace(errors.New("failed to parse ID").Path("VMess", "Account").Base(err).AtError())
log.Trace(newError("failed to parse ID").Base(err).AtError())
return nil, err
}
protoID := protocol.NewID(id)

3
proxy/vmess/encoding/auth.go
View File

@@ -4,7 +4,6 @@ import (
"crypto/md5"
"hash/fnv"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/serial"
)
@@ -58,7 +57,7 @@ func (v *FnvAuthenticator) Seal(dst, nonce, plaintext, additionalData []byte) []
// Open implements AEAD.Open().
func (v *FnvAuthenticator) Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error) {
if serial.BytesToUint32(ciphertext[:4]) != Authenticate(ciphertext[4:]) {
return dst, errors.New("invalid authentication").Path("Proxy", "VMess", "Encoding", "FnvAuthenticator")
return dst, newError("invalid authentication")
}
return append(dst, ciphertext[4:]...), nil
}

9
proxy/vmess/encoding/client.go
View File

@@ -14,7 +14,6 @@ import (
"v2ray.com/core/common/buf"
"v2ray.com/core/common/crypto"
"v2ray.com/core/common/dice"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
@@ -63,7 +62,7 @@ func (v *ClientSession) EncodeRequestHeader(header *protocol.RequestHeader, writ
timestamp := protocol.NewTimestampGenerator(protocol.NowTime(), 30)()
account, err := header.User.GetTypedAccount()
if err != nil {
log.Trace(errors.New("failed to get user account: ", err).AtError().Path("Proxy", "VMess", "Encoding", "ClientSession"))
log.Trace(newError("failed to get user account: ", err).AtError())
return
}
idHash := v.idHash(account.(*vmess.InternalAccount).AnyValidID().Bytes())
@@ -186,12 +185,12 @@ func (v *ClientSession) DecodeResponseHeader(reader io.Reader) (*protocol.Respon
_, err := io.ReadFull(v.responseReader, buffer[:4])
if err != nil {
log.Trace(errors.New("failed to read response header").Base(err).Path("Proxy", "VMess", "Encoding", "ClientSession"))
log.Trace(newError("failed to read response header").Base(err))
return nil, err
}
if buffer[0] != v.responseHeader {
return nil, errors.New("unexpected response header. Expecting ", int(v.responseHeader), " but actually ", int(buffer[0])).Path("Proxy", "VMess", "Encoding", "ClientSession")
return nil, newError("unexpected response header. Expecting ", int(v.responseHeader), " but actually ", int(buffer[0]))
}
header := &protocol.ResponseHeader{
@@ -203,7 +202,7 @@ func (v *ClientSession) DecodeResponseHeader(reader io.Reader) (*protocol.Respon
dataLen := int(buffer[3])
_, err := io.ReadFull(v.responseReader, buffer[:dataLen])
if err != nil {
log.Trace(errors.New("failed to read response command").Base(err).Path("Proxy", "VMess", "Encoding", "ClientSession"))
log.Trace(newError("failed to read response command").Base(err))
return nil, err
}
data := buffer[:dataLen]

25
proxy/vmess/encoding/commands.go
View File

@@ -4,7 +4,6 @@ import (
"io"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
@@ -12,9 +11,9 @@ import (
)
var (
ErrCommandTypeMismatch = errors.New("Command type mismatch.")
ErrUnknownCommand = errors.New("Unknown command.")
ErrCommandTooLarge = errors.New("Command too large.")
ErrCommandTypeMismatch = newError("Command type mismatch.")
ErrUnknownCommand = newError("Unknown command.")
ErrCommandTooLarge = newError("Command too large.")
)
func MarshalCommand(command interface{}, writer io.Writer) error {
@@ -53,12 +52,12 @@ func MarshalCommand(command interface{}, writer io.Writer) error {
func UnmarshalCommand(cmdID byte, data []byte) (protocol.ResponseCommand, error) {
if len(data) <= 4 {
return nil, errors.New("insufficient length").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length")
}
expectedAuth := Authenticate(data[4:])
actualAuth := serial.BytesToUint32(data[:4])
if expectedAuth != actualAuth {
return nil, errors.New("invalid auth").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("invalid auth")
}
var factory CommandFactory
@@ -110,38 +109,38 @@ func (v *CommandSwitchAccountFactory) Marshal(command interface{}, writer io.Wri
func (v *CommandSwitchAccountFactory) Unmarshal(data []byte) (interface{}, error) {
cmd := new(protocol.CommandSwitchAccount)
if len(data) == 0 {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
lenHost := int(data[0])
if len(data) < lenHost+1 {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
if lenHost > 0 {
cmd.Host = net.ParseAddress(string(data[1 : 1+lenHost]))
}
portStart := 1 + lenHost
if len(data) < portStart+2 {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
cmd.Port = net.PortFromBytes(data[portStart : portStart+2])
idStart := portStart + 2
if len(data) < idStart+16 {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
cmd.ID, _ = uuid.ParseBytes(data[idStart : idStart+16])
alterIDStart := idStart + 16
if len(data) < alterIDStart+2 {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
cmd.AlterIds = serial.BytesToUint16(data[alterIDStart : alterIDStart+2])
levelStart := alterIDStart + 2
if len(data) < levelStart+1 {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
cmd.Level = uint32(data[levelStart])
timeStart := levelStart + 1
if len(data) < timeStart {
return nil, errors.New("insufficient length.").Path("Proxy", "VMess", "Encoding", "Command")
return nil, newError("insufficient length.")
}
cmd.ValidMin = data[timeStart]
return cmd, nil

3
proxy/vmess/encoding/encoding.go Normal file
View File

@@ -0,0 +1,3 @@
package encoding
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg encoding -path Proxy,VMess,Encoding

7
proxy/vmess/encoding/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package encoding
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "VMess", "Encoding")
}

31
proxy/vmess/encoding/server.go
View File

@@ -13,7 +13,6 @@ import (
"golang.org/x/crypto/chacha20poly1305"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/crypto"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
@@ -123,12 +122,12 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
_, err := io.ReadFull(reader, buffer[:protocol.IDBytesLen])
if err != nil {
return nil, errors.New("failed to read request header").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read request header").Base(err)
}
user, timestamp, valid := v.userValidator.Get(buffer[:protocol.IDBytesLen])
if !valid {
return nil, errors.New("invalid user").Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("invalid user")
}
timestampHash := md5.New()
@@ -136,7 +135,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
iv := timestampHash.Sum(nil)
account, err := user.GetTypedAccount()
if err != nil {
return nil, errors.New("failed to get user account").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to get user account").Base(err)
}
vmessAccount := account.(*vmess.InternalAccount)
@@ -145,7 +144,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
nBytes, err := io.ReadFull(decryptor, buffer[:41])
if err != nil {
return nil, errors.New("failed to read request header").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read request header").Base(err)
}
bufferLen := nBytes
@@ -155,7 +154,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
}
if request.Version != Version {
return nil, errors.New("invalid protocol version ", request.Version).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("invalid protocol version ", request.Version)
}
v.requestBodyIV = append([]byte(nil), buffer[1:17]...) // 16 bytes
@@ -165,7 +164,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
copy(sid.key[:], v.requestBodyKey)
copy(sid.nonce[:], v.requestBodyIV)
if v.sessionHistory.has(sid) {
return nil, errors.New("duplicated session id, possibly under replay attack").Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("duplicated session id, possibly under replay attack")
}
v.sessionHistory.add(sid)
@@ -183,28 +182,28 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
_, err = io.ReadFull(decryptor, buffer[41:45]) // 4 bytes
bufferLen += 4
if err != nil {
return nil, errors.New("failed to read IPv4 address").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read IPv4 address").Base(err)
}
request.Address = net.IPAddress(buffer[41:45])
case AddrTypeIPv6:
_, err = io.ReadFull(decryptor, buffer[41:57]) // 16 bytes
bufferLen += 16
if err != nil {
return nil, errors.New("failed to read IPv6 address").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read IPv6 address").Base(err)
}
request.Address = net.IPAddress(buffer[41:57])
case AddrTypeDomain:
_, err = io.ReadFull(decryptor, buffer[41:42])
if err != nil {
return nil, errors.New("failed to read domain address").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read domain address").Base(err)
}
domainLength := int(buffer[41])
if domainLength == 0 {
return nil, errors.New("zero length domain").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("zero length domain").Base(err)
}
_, err = io.ReadFull(decryptor, buffer[42:42+domainLength])
if err != nil {
return nil, errors.New("failed to read domain address").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read domain address").Base(err)
}
bufferLen += 1 + domainLength
request.Address = net.DomainAddress(string(buffer[42 : 42+domainLength]))
@@ -213,14 +212,14 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
if padingLen > 0 {
_, err = io.ReadFull(decryptor, buffer[bufferLen:bufferLen+padingLen])
if err != nil {
return nil, errors.New("failed to read padding").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read padding").Base(err)
}
bufferLen += padingLen
}
_, err = io.ReadFull(decryptor, buffer[bufferLen:bufferLen+4])
if err != nil {
return nil, errors.New("failed to read checksum").Base(err).Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("failed to read checksum").Base(err)
}
fnv1a := fnv.New32a()
@@ -229,11 +228,11 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
expectedHash := serial.BytesToUint32(buffer[bufferLen : bufferLen+4])
if actualHash != expectedHash {
return nil, errors.New("invalid auth").Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("invalid auth")
}
if request.Address == nil {
return nil, errors.New("invalid remote address").Path("Proxy", "VMess", "Encoding", "ServerSession")
return nil, newError("invalid remote address")
}
return request, nil

7
proxy/vmess/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package vmess
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "VMess")
}

7
proxy/vmess/inbound/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package inbound
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "VMess", "Inbound")
}

18
proxy/vmess/inbound/inbound.go
View File

@@ -1,5 +1,7 @@
package inbound
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg inbound -path Proxy,VMess,Inbound
import (
"context"
"io"
@@ -82,7 +84,7 @@ type Handler struct {
func New(ctx context.Context, config *Config) (*Handler, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("no space in context").Path("Proxy", "VMess", "Inbound")
return nil, newError("no space in context")
}
allowedClients := vmess.NewTimedUserValidator(ctx, protocol.DefaultIDHash)
@@ -100,7 +102,7 @@ func New(ctx context.Context, config *Config) (*Handler, error) {
space.OnInitialize(func() error {
handler.inboundHandlerManager = proxyman.InboundHandlerManagerFromSpace(space)
if handler.inboundHandlerManager == nil {
return errors.New("InboundHandlerManager is not found is space").Path("Proxy", "VMess", "Inbound")
return newError("InboundHandlerManager is not found is space")
}
return nil
})
@@ -180,12 +182,12 @@ func (v *Handler) Process(ctx context.Context, network net.Network, connection i
if err != nil {
if errors.Cause(err) != io.EOF {
log.Access(connection.RemoteAddr(), "", log.AccessRejected, err)
log.Trace(errors.New("invalid request from ", connection.RemoteAddr(), ": ", err).Path("Proxy", "VMess", "Inbound"))
log.Trace(newError("invalid request from ", connection.RemoteAddr(), ": ", err))
}
return err
}
log.Access(connection.RemoteAddr(), request.Destination(), log.AccessAccepted, "")
log.Trace(errors.New("received request for ", request.Destination()).Path("Proxy", "VMess", "Inbound"))
log.Trace(newError("received request for ", request.Destination()))
connection.SetReadDeadline(time.Time{})
@@ -220,11 +222,11 @@ func (v *Handler) Process(ctx context.Context, network net.Network, connection i
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
input.CloseError()
output.CloseError()
return errors.New("error during processing").Base(err).Path("Proxy", "VMess", "Inbound")
return newError("error during processing").Base(err)
}
if err := writer.Flush(); err != nil {
return errors.New("error during flushing remaining data").Base(err).Path("Proxy", "VMess", "Inbound")
return newError("error during flushing remaining data").Base(err)
}
runtime.KeepAlive(timer)
@@ -238,7 +240,7 @@ func (v *Handler) generateCommand(ctx context.Context, request *protocol.Request
if v.inboundHandlerManager != nil {
handler, err := v.inboundHandlerManager.GetHandler(ctx, tag)
if err != nil {
log.Trace(errors.New("failed to get detour handler: ", tag, err).AtWarning().Path("Proxy", "VMess", "Inbound"))
log.Trace(newError("failed to get detour handler: ", tag, err).AtWarning())
return nil
}
proxyHandler, port, availableMin := handler.GetRandomInboundProxy()
@@ -248,7 +250,7 @@ func (v *Handler) generateCommand(ctx context.Context, request *protocol.Request
availableMin = 255
}
log.Trace(errors.New("pick detour handler for port ", port, " for ", availableMin, " minutes.").Path("Proxy", "VMess", "Inbound").AtDebug())
log.Trace(newError("pick detour handler for port ", port, " for ", availableMin, " minutes.").AtDebug())
user := inboundHandler.GetUser(request.User.Email)
if user == nil {
return nil

7
proxy/vmess/outbound/errors.generated.go Normal file
View File

@@ -0,0 +1,7 @@
package outbound
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).Path("Proxy", "VMess", "Outbound")
}

19
proxy/vmess/outbound/outbound.go
View File

@@ -1,5 +1,7 @@
package outbound
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg outbound -path Proxy,VMess,Outbound
import (
"context"
"runtime"
@@ -9,7 +11,6 @@ import (
"v2ray.com/core/app/log"
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/errors"
"v2ray.com/core/common/net"
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/retry"
@@ -30,7 +31,7 @@ type Handler struct {
func New(ctx context.Context, config *Config) (*Handler, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("no space in context.").Path("Proxy", "VMess", "Outbound")
return nil, newError("no space in context.")
}
serverList := protocol.NewServerList()
@@ -61,15 +62,15 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
return nil
})
if err != nil {
return errors.New("failed to find an available destination").Base(err).AtWarning().Path("Proxy", "VMess", "Outbound")
return newError("failed to find an available destination").Base(err).AtWarning()
}
defer conn.Close()
target, ok := proxy.TargetFromContext(ctx)
if !ok {
return errors.New("target not specified").Path("Proxy", "VMess", "Outbound").AtError()
return newError("target not specified").AtError()
}
log.Trace(errors.New("tunneling request to ", target, " via ", rec.Destination()).Path("Proxy", "VMess", "Outbound"))
log.Trace(newError("tunneling request to ", target, " via ", rec.Destination()))
command := protocol.RequestCommandTCP
if target.Network == net.Network_UDP {
@@ -86,7 +87,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
rawAccount, err := request.User.GetTypedAccount()
if err != nil {
return errors.New("failed to get user account").Base(err).AtWarning().Path("Proxy", "VMess", "Outbound")
return newError("failed to get user account").Base(err).AtWarning()
}
account := rawAccount.(*vmess.InternalAccount)
request.Security = account.Security
@@ -109,11 +110,11 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
bodyWriter := session.EncodeRequestBody(request, writer)
firstPayload, err := input.ReadTimeout(time.Millisecond * 500)
if err != nil && err != buf.ErrReadTimeout {
return errors.New("failed to get first payload").Base(err).Path("Proxy", "VMess", "Outbound")
return newError("failed to get first payload").Base(err)
}
if !firstPayload.IsEmpty() {
if err := bodyWriter.Write(firstPayload); err != nil {
return errors.New("failed to write first payload").Base(err).Path("Proxy", "VMess", "Outbound")
return newError("failed to write first payload").Base(err)
}
firstPayload.Release()
}
@@ -159,7 +160,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
})
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
return errors.New("connection ends").Base(err).Path("Proxy", "VMess", "Outbound")
return newError("connection ends").Base(err)
}
runtime.KeepAlive(timer)

2
proxy/vmess/vmess.go
View File

@@ -5,6 +5,8 @@
// clients with 'socks' for proxying.
package vmess
//go:generate go run $GOPATH/src/v2ray.com/core/tools/generrorgen/main.go -pkg vmess -path Proxy,VMess
import (
"context"
"sync"