lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2026-06-07 11:39:11 -04:00
Code Issues Releases Wiki Activity

refactor error interface

Browse Source
This commit is contained in:
Darien Raymond
2017-04-06 15:13:09 +02:00
parent 65c6972eb5
commit fc31f9b94c
40 changed files with 272 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
proxy/freedom/freedom.go
View File

@@ -102,7 +102,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
return nil
})
if err != nil {
return errors.Base(err).Message("Freedom: Failed to open connection to ", destination)
return errors.New("failed to open connection to ", destination).Base(err).Path("Freedom")
}
defer conn.Close()
@@ -136,7 +136,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.Base(err).Message("Freedom: Connection ends.")
return errors.New("connection ends").Base(err).Path("Freedom")
}
runtime.KeepAlive(timer)

8
proxy/http/server.go
View File

@@ -94,7 +94,7 @@ func (s *Server) Process(ctx context.Context, network v2net.Network, conn intern
}
dest, err := parseHost(host, defaultPort)
if err != nil {
return errors.Base(err).Message("HTTP: Malformed proxy host: ", host).RequireUserAction()
return errors.New("malformed proxy host: ", host).AtWarning().Base(err).Path("HTTP")
}
log.Access(conn.RemoteAddr(), request.URL, log.AccessAccepted, "")
@@ -118,7 +118,7 @@ func (s *Server) handleConnect(ctx context.Context, request *http.Request, reade
Close: false,
}
if err := response.Write(writer); err != nil {
return errors.Base(err).Message("HTTP|Server: Failed to write back OK response.")
return errors.New("failed to write back OK response").Base(err).Path("HTTP", "Server")
}
timeout := time.Second * time.Duration(s.config.Timeout)
@@ -152,7 +152,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.Base(err).Message("HTTP|Server: Connection ends.")
return errors.New("connection ends").Base(err).Path("HTTP", "Server")
}
runtime.KeepAlive(timer)
@@ -251,7 +251,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.Base(err).Message("HTTP|Server: Connection ends.")
return errors.New("connection ends").Base(err).Path("HTTP", "Server")
}
return nil

14
proxy/shadowsocks/client.go
View File

@@ -60,7 +60,7 @@ func (v *Client) Process(ctx context.Context, outboundRay ray.OutboundRay, diale
return nil
})
if err != nil {
return errors.Base(err).RequireUserAction().Message("Shadowsocks|Client: Failed to find an available destination.")
return errors.New("failed to find an available destination").AtWarning().Base(err).Path("Shadowsocks", "Client")
}
log.Info("Shadowsocks|Client: Tunneling request to ", destination, " via ", server.Destination())
@@ -81,7 +81,7 @@ func (v *Client) Process(ctx context.Context, outboundRay ray.OutboundRay, diale
user := server.PickUser()
rawAccount, err := user.GetTypedAccount()
if err != nil {
return errors.Base(err).Message("Shadowsocks|Client: Failed to get a valid user account.").RequireUserAction()
return errors.New("failed to get a valid user account").AtWarning().Base(err).Path("Shadowsocks", "Client")
}
account := rawAccount.(*ShadowsocksAccount)
request.User = user
@@ -96,7 +96,7 @@ func (v *Client) Process(ctx context.Context, outboundRay ray.OutboundRay, diale
bufferedWriter := buf.NewBufferedWriter(conn)
bodyWriter, err := WriteTCPRequest(request, bufferedWriter)
if err != nil {
return errors.Base(err).Message("Shadowsocks|Client: Failed to write request")
return errors.New("failed to write request").Base(err).Path("Shadowsocks", "Client")
}
if err := bufferedWriter.SetBuffered(false); err != nil {
@@ -127,7 +127,7 @@ func (v *Client) Process(ctx context.Context, outboundRay ray.OutboundRay, diale
})
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
return errors.Base(err).Message("Shadowsocks|Client: Connection ends.")
return errors.New("connection ends").Base(err).Path("Shadowsocks", "Client")
}
return nil
@@ -142,7 +142,7 @@ func (v *Client) Process(ctx context.Context, outboundRay ray.OutboundRay, diale
requestDone := signal.ExecuteAsync(func() error {
if err := buf.PipeUntilEOF(timer, outboundRay.OutboundInput(), writer); err != nil {
return errors.Base(err).Message("Shadowsocks|Client: Failed to transport all UDP request")
return errors.New("failed to transport all UDP request").Base(err).Path("Shadowsocks", "Client")
}
return nil
})
@@ -156,13 +156,13 @@ func (v *Client) Process(ctx context.Context, outboundRay ray.OutboundRay, diale
}
if err := buf.PipeUntilEOF(timer, reader, outboundRay.OutboundOutput()); err != nil {
return errors.Base(err).Message("Shadowsocks|Client: Failed to transport all UDP response.")
return errors.New("failed to transport all UDP response").Base(err).Path("Shadowsocks", "Client")
}
return nil
})
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
return errors.Base(err).Message("Shadowsocks|Client: Connection ends.")
return errors.New("connection ends").Base(err).Path("Shadowsocks", "Client")
}
return nil

2
proxy/shadowsocks/config.go
View File

@@ -41,7 +41,7 @@ func (v *Account) GetCipher() (Cipher, error) {
func (v *Account) AsAccount() (protocol.Account, error) {
cipher, err := v.GetCipher()
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|Account: Failed to get cipher.")
return nil, errors.New("failed to get cipher").Base(err).Path("Shadowsocks", "Account")
}
return &ShadowsocksAccount{
Cipher: cipher,

56
proxy/shadowsocks/protocol.go
View File

@@ -25,7 +25,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.Base(err).Message("Shadowsocks|TCP: Failed to parse account.")
return nil, nil, errors.New("failed to parse account").Path("Shadowsocks", "TCP").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -35,14 +35,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.Base(err).Message("Shadowsocks|TCP: Failed to read IV.")
return nil, nil, errors.New("failed to read IV").Path("Shadowsocks", "TCP").Base(err)
}
iv := append([]byte(nil), buffer.BytesTo(ivLen)...)
stream, err := account.Cipher.NewDecodingStream(account.Key, iv)
if err != nil {
return nil, nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to initialize decoding stream.")
return nil, nil, errors.New("failed to initialize decoding stream").Path("Shadowsocks", "TCP").Base(err)
}
reader = crypto.NewCryptionReader(stream, reader)
@@ -56,7 +56,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.Base(err).Message("Shadowsocks|TCP: Failed to read address type.")
return nil, nil, errors.New("failed to read address type").Path("Shadowsocks", "TCP").Base(err)
}
addrType := (buffer.Byte(0) & 0x0F)
@@ -65,35 +65,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("Shadowsocks|TCP: Rejecting connection with OTA enabled, while server disables OTA.")
return nil, nil, errors.New("rejecting connection with OTA enabled, while server disables OTA").Path("Shadowsocks", "TCP")
}
if !request.Option.Has(RequestOptionOneTimeAuth) && account.OneTimeAuth == Account_Enabled {
return nil, nil, errors.New("Shadowsocks|TCP: Rejecting connection with OTA disabled, while server enables OTA.")
return nil, nil, errors.New("rejecting connection with OTA disabled, while server enables OTA").Path("Shadowsocks", "TCP")
}
switch addrType {
case AddrTypeIPv4:
err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 4))
if err != nil {
return nil, nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to read IPv4 address.")
return nil, nil, errors.New("failed to read IPv4 address").Path("Shadowsocks", "TCP").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.Base(err).Message("Shadowsocks|TCP: Failed to read IPv6 address.")
return nil, nil, errors.New("failed to read IPv6 address").Path("Shadowsocks", "TCP").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.Base(err).Message("Shadowsocks|TCP: Failed to read domain lenth.")
return nil, nil, errors.New("failed to read domain lenth.").Path("Shadowsocks", "TCP").Base(err)
}
domainLength := int(buffer.BytesFrom(-1)[0])
err = buffer.AppendSupplier(buf.ReadFullFrom(reader, domainLength))
if err != nil {
return nil, nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to read domain.")
return nil, nil, errors.New("failed to read domain").Path("Shadowsocks", "TCP").Base(err)
}
request.Address = v2net.DomainAddress(string(buffer.BytesFrom(-domainLength)))
default:
@@ -102,7 +102,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.Base(err).Message("Shadowsocks|TCP: Failed to read port.")
return nil, nil, errors.New("failed to read port").Path("Shadowsocks", "TCP").Base(err)
}
request.Port = v2net.PortFromBytes(buffer.BytesFrom(-2))
@@ -112,16 +112,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.Base(err).Message("Shadowsocks|TCP: Failed to read OTA.")
return nil, nil, errors.New("Failed to read OTA").Path("Shadowsocks", "TCP").Base(err)
}
if !bytes.Equal(actualAuth, buffer.BytesFrom(-AuthSize)) {
return nil, nil, errors.New("Shadowsocks|TCP: Invalid OTA")
return nil, nil, errors.New("invalid OTA").Path("Shadowsocks", "TCP")
}
}
if request.Address == nil {
return nil, nil, errors.New("Shadowsocks|TCP: Invalid remote address.")
return nil, nil, errors.New("invalid remote address.").Path("Shadowsocks", "TCP")
}
var chunkReader buf.Reader
@@ -138,7 +138,7 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
user := request.User
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to parse account.")
return nil, errors.New("failed to parse account").Path("Shadowsocks", "TCP").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -146,12 +146,12 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
rand.Read(iv)
_, err = writer.Write(iv)
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to write IV.")
return nil, errors.New("failed to write IV").Path("Shadowsocks", "TCP")
}
stream, err := account.Cipher.NewEncodingStream(account.Key, iv)
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to create encoding stream.")
return nil, errors.New("failed to create encoding stream").Path("Shadowsocks", "TCP").Base(err)
}
writer = crypto.NewCryptionWriter(stream, writer)
@@ -183,7 +183,7 @@ func WriteTCPRequest(request *protocol.RequestHeader, writer io.Writer) (buf.Wri
_, err = writer.Write(header.Bytes())
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to write header.")
return nil, errors.New("Shadowsocks|TCP: Failed to write header.").Base(err)
}
var chunkWriter buf.Writer
@@ -199,19 +199,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.Base(err).Message("Shadowsocks|TCP: Failed to parse account.")
return nil, errors.New("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.Base(err).Message("Shadowsocks|TCP: Failed to read IV.")
return nil, errors.New("Shadowsocks|TCP: Failed to read IV.").Base(err)
}
stream, err := account.Cipher.NewDecodingStream(account.Key, iv)
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to initialize decoding stream.")
return nil, errors.New("Shadowsocks|TCP: Failed to initialize decoding stream.").Base(err)
}
return buf.NewReader(crypto.NewCryptionReader(stream, reader)), nil
}
@@ -220,7 +220,7 @@ func WriteTCPResponse(request *protocol.RequestHeader, writer io.Writer) (buf.Wr
user := request.User
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to parse account.")
return nil, errors.New("Shadowsocks|TCP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -228,12 +228,12 @@ func WriteTCPResponse(request *protocol.RequestHeader, writer io.Writer) (buf.Wr
rand.Read(iv)
_, err = writer.Write(iv)
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to write IV.")
return nil, errors.New("Shadowsocks|TCP: Failed to write IV.").Base(err)
}
stream, err := account.Cipher.NewEncodingStream(account.Key, iv)
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to create encoding stream.")
return nil, errors.New("Shadowsocks|TCP: Failed to create encoding stream.").Base(err)
}
return buf.NewWriter(crypto.NewCryptionWriter(stream, writer)), nil
@@ -243,7 +243,7 @@ func EncodeUDPPacket(request *protocol.RequestHeader, payload *buf.Buffer) (*buf
user := request.User
rawAccount, err := user.GetTypedAccount()
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|UDP: Failed to parse account.")
return nil, errors.New("Shadowsocks|UDP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -278,7 +278,7 @@ func EncodeUDPPacket(request *protocol.RequestHeader, payload *buf.Buffer) (*buf
stream, err := account.Cipher.NewEncodingStream(account.Key, iv)
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|TCP: Failed to create encoding stream.")
return nil, errors.New("Shadowsocks|TCP: Failed to create encoding stream.").Base(err)
}
stream.XORKeyStream(buffer.BytesFrom(ivLen), buffer.BytesFrom(ivLen))
@@ -288,7 +288,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.Base(err).Message("Shadowsocks|UDP: Failed to parse account.")
return nil, nil, errors.New("Shadowsocks|UDP: Failed to parse account.").Base(err)
}
account := rawAccount.(*ShadowsocksAccount)
@@ -298,7 +298,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.Base(err).Message("Shadowsocks|UDP: Failed to initialize decoding stream.")
return nil, nil, errors.New("Shadowsocks|UDP: Failed to initialize decoding stream.").Base(err)
}
stream.XORKeyStream(payload.Bytes(), payload.Bytes())

30
proxy/shadowsocks/server.go
View File

@@ -28,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("Shadowsocks|Server: No space in context.")
return nil, errors.New("no space in context").Path("Shadowsocks", "Server")
}
if config.GetUser() == nil {
return nil, errors.New("Shadowsocks|Server: User is not specified.")
return nil, errors.New("user is not specified").Path("Shadowsocks", "Server")
}
rawAccount, err := config.User.GetTypedAccount()
if err != nil {
return nil, errors.Base(err).Message("Shadowsocks|Server: Failed to get user account.")
return nil, errors.New("failed to get user account").Base(err).Path("Shadowsocks", "Server")
}
account := rawAccount.(*ShadowsocksAccount)
@@ -68,7 +68,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("Shadowsocks|Server: Unknown network: ", network)
return errors.New("unknown network: ", network).Path("Shadowsocks", "Server")
}
}
@@ -85,7 +85,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.Info("Shadowsocks|Server: Skipping invalid UDP packet from: ", source, ": ", err)
log.Trace(errors.New("dropping invalid UDP packet from: ", source).Base(err).Path("Shadowsocks", "Server"))
log.Access(source, "", log.AccessRejected, err)
}
payload.Release()
@@ -93,13 +93,13 @@ func (v *Server) handlerUDPPayload(ctx context.Context, conn internet.Connection
}
if request.Option.Has(RequestOptionOneTimeAuth) && v.account.OneTimeAuth == Account_Disabled {
log.Info("Shadowsocks|Server: Client payload enables OTA but server doesn't allow it.")
log.Trace(errors.New("client payload enables OTA but server doesn't allow it").Path("Shadowsocks", "Server"))
payload.Release()
continue
}
if !request.Option.Has(RequestOptionOneTimeAuth) && v.account.OneTimeAuth == Account_Enabled {
log.Info("Shadowsocks|Server: Client payload disables OTA but server forces it.")
log.Trace(errors.New("client payload disables OTA but server forces it").Path("Shadowsocks", "Server"))
payload.Release()
continue
}
@@ -108,7 +108,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.Info("Shadowsocks|Server: Tunnelling request to ", dest)
log.Trace(errors.New("tunnelling request to ", dest).Path("Shadowsocks", "Server"))
ctx = protocol.ContextWithUser(ctx, request.User)
udpServer.Dispatch(ctx, dest, data, func(payload *buf.Buffer) {
@@ -116,7 +116,7 @@ func (v *Server) handlerUDPPayload(ctx context.Context, conn internet.Connection
data, err := EncodeUDPPacket(request, payload)
if err != nil {
log.Warning("Shadowsocks|Server: Failed to encode UDP packet: ", err)
log.Trace(errors.New("failed to encode UDP packet").Base(err).Path("Shadowsocks", "Server").AtWarning())
return
}
defer data.Release()
@@ -134,7 +134,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.Base(err).Message("Shadowsocks|Server: Failed to create request from: ", conn.RemoteAddr())
return errors.New("failed to create request from: ", conn.RemoteAddr()).Base(err).Path("Shadowsocks", "Server")
}
conn.SetReadDeadline(time.Time{})
@@ -142,7 +142,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
dest := request.Destination()
log.Access(conn.RemoteAddr(), dest, log.AccessAccepted, "")
log.Info("Shadowsocks|Server: Tunnelling request to ", dest)
log.Trace(errors.New("tunnelling request to ", dest).Path("Shadowsocks", "Server"))
ctx = protocol.ContextWithUser(ctx, request.User)
@@ -157,7 +157,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.Base(err).Message("Shadowsocks|Server: Failed to write response.")
return errors.New("failed to write response").Base(err).Path("Shadowsocks", "Server")
}
payload, err := ray.InboundOutput().Read()
@@ -174,7 +174,7 @@ func (s *Server) handleConnection(ctx context.Context, conn internet.Connection,
}
if err := buf.PipeUntilEOF(timer, ray.InboundOutput(), responseWriter); err != nil {
return errors.Base(err).Message("Shadowsocks|Server: Failed to transport all TCP response.")
return errors.New("failed to transport all TCP response").Base(err).Path("Shadowsocks", "Server")
}
return nil
@@ -184,7 +184,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.Base(err).Message("Shadowsocks|Server: Failed to transport all TCP request.")
return errors.New("failed to transport all TCP request").Base(err).Path("Shadowsocks", "Server")
}
return nil
})
@@ -192,7 +192,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.Base(err).Message("Shadowsocks|Server: Connection ends.")
return errors.New("connection ends").Base(err).Path("Shadowsocks", "Server")
}
runtime.KeepAlive(timer)

8
proxy/socks/client.go
View File

@@ -55,7 +55,7 @@ func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.
})
if err != nil {
return errors.Base(err).Message("Socks|Client: Failed to find an available destination.")
return errors.New("failed to find an available destination").Base(err).Path("Socks", "Client")
}
defer conn.Close()
@@ -78,7 +78,7 @@ func (c *Client) Process(ctx context.Context, ray ray.OutboundRay, dialer proxy.
udpRequest, err := ClientHandshake(request, conn, conn)
if err != nil {
return errors.Base(err).RequireUserAction().Message("Socks|Client: Failed to establish connection to server.")
return errors.New("failed to establish connection to server").AtWarning().Base(err).Path("Socks", "Client")
}
ctx, timer := signal.CancelAfterInactivity(ctx, time.Minute*2)
@@ -96,7 +96,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.Base(err).Message("Socks|Client: Failed to create UDP connection.")
return errors.New("failed to create UDP connection").Base(err).Path("Socks", "Client")
}
defer udpConn.Close()
requestFunc = func() error {
@@ -112,7 +112,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.Base(err).Message("Socks|Client: Connection ends.")
return errors.New("connection ends").Base(err).Path("Socks", "Client")
}
runtime.KeepAlive(timer)

32
proxy/socks/protocol.go
View File

@@ -44,13 +44,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.Base(err).Message("Socks|Server: Insufficient header.")
return nil, errors.New("insufficient header").Base(err).Path("Socks", "Server")
}
version := buffer.Byte(0)
if version == socks4Version {
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 6)); err != nil {
return nil, errors.Base(err).Message("Socks|Server: Insufficient header.")
return nil, errors.New("insufficient header").Base(err).Path("Socks", "Server")
}
port := v2net.PortFromBytes(buffer.BytesRange(2, 4))
address := v2net.IPAddress(buffer.BytesRange(4, 8))
@@ -61,7 +61,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.Base(err).Message("Socks|Server: Failed to read domain for socks 4a.")
return nil, errors.New("failed to read domain for socks 4a").Base(err).Path("Socks", "Server")
}
address = v2net.DomainAddress(domain)
}
@@ -85,7 +85,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
if version == socks5Version {
nMethod := int(buffer.Byte(1))
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, nMethod)); err != nil {
return nil, errors.Base(err).Message("Socks|Server: Failed to read auth methods.")
return nil, errors.New("failed to read auth methods").Base(err).Path("Socks", "Server")
}
var expectedAuth byte = authNotRequired
@@ -95,37 +95,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("Socks|Server: No matching auth method.")
return nil, errors.New("no matching auth method").Path("Socks", "Server")
}
if err := writeSocks5AuthenticationResponse(writer, socks5Version, expectedAuth); err != nil {
return nil, errors.Base(err).Message("Socks|Server: Failed to write auth response.")
return nil, errors.New("failed to write auth response").Base(err).Path("Socks", "Server")
}
if expectedAuth == authPassword {
username, password, err := readUsernamePassword(reader)
if err != nil {
return nil, errors.Base(err).Message("Socks|Server: Failed to read username and password for authentication.")
return nil, errors.New("failed to read username and password for authentication").Base(err).Path("Socks", "Server")
}
if !s.config.HasAccount(username, password) {
writeSocks5AuthenticationResponse(writer, 0x01, 0xFF)
return nil, errors.New("Socks|Server: Invalid username or password.")
return nil, errors.New("invalid username or password").Path("Socks", "Server")
}
if err := writeSocks5AuthenticationResponse(writer, 0x01, 0x00); err != nil {
return nil, errors.Base(err).Message("Socks|Server: Failed to write auth response.")
return nil, errors.New("failed to write auth response").Base(err).Path("Socks", "Server")
}
}
buffer.Clear()
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 4)); err != nil {
return nil, errors.Base(err).Message("Socks|Server: Failed to read request.")
return nil, errors.New("failed to read request").Base(err).Path("Socks", "Server")
}
cmd := buffer.Byte(1)
if cmd == cmdTCPBind || (cmd == cmdUDPPort && !s.config.UdpEnabled) {
writeSocks5Response(writer, statusCmdNotSupport, v2net.AnyIP, v2net.Port(0))
return nil, errors.New("Socks|Server: Unsupported command: ", cmd)
return nil, errors.New("unsupported command: ", cmd).Path("Socks", "Server")
}
switch cmd {
@@ -161,7 +161,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("Socks|Server: Unknown address type: ", addrType)
return nil, errors.New("Unknown address type: ", addrType).Path("Socks", "Server")
}
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 2)); err != nil {
@@ -186,7 +186,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
return request, nil
}
return nil, errors.New("Socks|Server: Unknown Socks version: ", version)
return nil, errors.New("unknown Socks version: ", version).Path("Socks", "Server")
}
func readUsernamePassword(reader io.Reader) (string, string, error) {
@@ -230,7 +230,7 @@ func readUntilNull(reader io.Reader) (string, error) {
}
size++
if size == 256 {
return "", errors.New("Socks|Server: Buffer overrun.")
return "", errors.New("buffer overrun").Path("Socks", "Server")
}
}
}
@@ -400,10 +400,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)).RequireUserAction()
return nil, errors.New("Socks|Client: Unexpected server version: ", b.Byte(0)).AtWarning()
}
if b.Byte(1) != authByte {
return nil, errors.New("Socks|Client: auth method not supported.").RequireUserAction()
return nil, errors.New("Socks|Client: auth method not supported.").AtWarning()
}
if authByte == authPassword {

10
proxy/socks/server.go
View File

@@ -29,7 +29,7 @@ type Server struct {
func NewServer(ctx context.Context, config *ServerConfig) (*Server, error) {
space := app.SpaceFromContext(ctx)
if space == nil {
return nil, errors.New("Socks|Server: No space in context.").RequireUserAction()
return nil, errors.New("Socks|Server: No space in context.").AtWarning()
}
s := &Server{
config: config,
@@ -129,7 +129,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.Base(err).Message("Socks|Server: Failed to transport all TCP request.")
return errors.New("failed to transport all TCP request").Base(err).Path("Socks", "Server")
}
return nil
})
@@ -137,7 +137,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.Base(err).Message("Socks|Server: Failed to transport all TCP response.")
return errors.New("failed to transport all TCP response").Base(err).Path("Socks", "Server")
}
return nil
})
@@ -145,7 +145,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.Base(err).Message("Socks|Server: Connection ends.")
return errors.New("connection ends").Base(err).Path("Socks", "Server")
}
runtime.KeepAlive(timer)
@@ -157,7 +157,7 @@ func (v *Server) handleUDPPayload(ctx context.Context, conn internet.Connection,
udpServer := udp.NewDispatcher(dispatcher)
if source, ok := proxy.SourceFromContext(ctx); ok {
log.Info("Socks|Server: Client UDP connection from ", source)
log.Trace(errors.New("client UDP connection from ", source).Path("Socks", "Server"))
}
reader := buf.NewReader(conn)

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

@@ -123,7 +123,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
_, err := io.ReadFull(reader, buffer[:protocol.IDBytesLen])
if err != nil {
return nil, errors.Base(err).Message("VMess|Server: Failed to read request header.")
return nil, errors.New("failed to read request header").Base(err).Path("VMess", "Server")
}
user, timestamp, valid := v.userValidator.Get(buffer[:protocol.IDBytesLen])
@@ -136,7 +136,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
iv := timestampHash.Sum(nil)
account, err := user.GetTypedAccount()
if err != nil {
return nil, errors.Base(err).Message("VMess|Server: Failed to get user account.")
return nil, errors.New("failed to get user account").Base(err).Path("VMess", "Server")
}
vmessAccount := account.(*vmess.InternalAccount)
@@ -145,7 +145,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
nBytes, err := io.ReadFull(decryptor, buffer[:41])
if err != nil {
return nil, errors.Base(err).Message("VMess|Server: Failed to read request header.")
return nil, errors.New("failed to read request header").Base(err).Path("VMess", "Server")
}
bufferLen := nBytes
@@ -155,7 +155,7 @@ func (v *ServerSession) DecodeRequestHeader(reader io.Reader) (*protocol.Request
}
if request.Version != Version {
return nil, errors.New("VMess|Server: Invalid protocol version ", request.Version)
return nil, errors.New("invalid protocol version ", request.Version).Path("VMess", "Server")
}
v.requestBodyIV = append([]byte(nil), buffer[1:17]...) // 16 bytes
@@ -165,7 +165,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("VMess|Server: Duplicated session id. Possibly under replay attack.")
return nil, errors.New("duplicated session id, possibly under replay attack").Path("VMess", "Server")
}
v.sessionHistory.add(sid)
@@ -183,28 +183,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.Base(err).Message("VMess|Server: Failed to read IPv4.")
return nil, errors.New("failed to read IPv4 address").Base(err).Path("VMess", "Server")
}
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.Base(err).Message("VMess|Server: Failed to read IPv6 address.")
return nil, errors.New("failed to read IPv6 address").Base(err).Path("VMess", "Server")
}
request.Address = net.IPAddress(buffer[41:57])
case AddrTypeDomain:
_, err = io.ReadFull(decryptor, buffer[41:42])
if err != nil {
return nil, errors.Base(err).Message("VMess:Server: Failed to read domain.")
return nil, errors.New("failed to read domain address").Base(err).Path("VMess", "Server")
}
domainLength := int(buffer[41])
if domainLength == 0 {
return nil, errors.New("VMess|Server: Zero length domain.")
return nil, errors.New("zero length domain").Base(err).Path("VMess", "Server")
}
_, err = io.ReadFull(decryptor, buffer[42:42+domainLength])
if err != nil {
return nil, errors.Base(err).Message("VMess|Server: Failed to read domain.")
return nil, errors.New("failed to read domain address").Base(err).Path("VMess", "Server")
}
bufferLen += 1 + domainLength
request.Address = net.DomainAddress(string(buffer[42 : 42+domainLength]))
@@ -213,14 +213,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.Base(err).Message("VMess|Server: Failed to read padding.")
return nil, errors.New("failed to read padding").Base(err).Path("VMess", "Server")
}
bufferLen += padingLen
}
_, err = io.ReadFull(decryptor, buffer[bufferLen:bufferLen+4])
if err != nil {
return nil, errors.Base(err).Message("VMess|Server: Failed to read checksum.")
return nil, errors.New("failed to read checksum").Base(err).Path("VMess", "Server")
}
fnv1a := fnv.New32a()

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

@@ -226,12 +226,12 @@ func (v *Handler) Process(ctx context.Context, network net.Network, connection i
connection.SetReusable(false)
input.CloseError()
output.CloseError()
return errors.Base(err).Message("VMess|Inbound: Error during processing.")
return errors.New("error during processing").Base(err).Path("VMess", "Inbound")
}
if err := writer.Flush(); err != nil {
connection.SetReusable(false)
return errors.Base(err).Message("VMess|Inbound: Error during flushing remaining data.")
return errors.New("error during flushing remaining data").Base(err).Path("VMess", "Inbound")
}
runtime.KeepAlive(timer)

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

@@ -61,7 +61,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
return nil
})
if err != nil {
return errors.Base(err).RequireUserAction().Message("VMess|Outbound: Failed to find an available destination.")
return errors.New("VMess|Outbound: Failed to find an available destination.").Base(err).AtWarning()
}
defer conn.Close()
@@ -86,7 +86,7 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
rawAccount, err := request.User.GetTypedAccount()
if err != nil {
return errors.Base(err).RequireUserAction().Message("VMess|Outbound: Failed to get user account.")
return errors.New("VMess|Outbound: Failed to get user account.").Base(err).AtWarning()
}
account := rawAccount.(*vmess.InternalAccount)
request.Security = account.Security
@@ -114,11 +114,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.Base(err).Message("VMess|Outbound: Failed to get first payload.")
return errors.New("failed to get first payload").Base(err).Path("VMess", "Outbound")
}
if !firstPayload.IsEmpty() {
if err := bodyWriter.Write(firstPayload); err != nil {
return errors.Base(err).Message("VMess|Outbound: Failed to write first payload.")
return errors.New("failed to write first payload").Base(err).Path("VMess", "Outbound")
}
firstPayload.Release()
}
@@ -166,9 +166,8 @@ func (v *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
})
if err := signal.ErrorOrFinish2(ctx, requestDone, responseDone); err != nil {
log.Info("VMess|Outbound: Connection ending with ", err)
conn.SetReusable(false)
return err
return errors.New("connection ends").Base(err).Path("VMess", "Outbound")
}
runtime.KeepAlive(timer)