mirrors/Xray-core
1
0
Fork 0
mirror of https://github.com/XTLS/Xray-core.git synced 2025-04-30 09:18:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

Refactor log (#3446)

Browse source 
* Refactor log

* Add new log methods

* Fix logger test

* Change all logging code

* Clean up pathObj

* Rebase to latest main

* Remove invoking method name after the dot
This commit is contained in:
yuhan6665 2024-06-29 14:32:57 -04:00 • committed by GitHub
parent 8320732743
commit 079d0bd8a9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
291 changed files with 1837 additions and 2368 deletions
Download patch file Download diff file Expand all files Collapse all files

27
proxy/socks/client.go
View file

@ -6,6 +6,7 @@ import (
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/buf"
"github.com/xtls/xray-core/common/errors"
"github.com/xtls/xray-core/common/net"
"github.com/xtls/xray-core/common/protocol"
"github.com/xtls/xray-core/common/retry"
@ -34,12 +35,12 @@ func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
for _, rec := range config.Server {
s, err := protocol.NewServerSpecFromPB(rec)
if err != nil {
return nil, newError("failed to get server spec").Base(err)
return nil, errors.New("failed to get server spec").Base(err)
}
serverList.AddServer(s)
}
if serverList.Size() == 0 {
return nil, newError("0 target server")
return nil, errors.New("0 target server")
}
v := core.MustFromContext(ctx)
@ -58,9 +59,9 @@ func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
// Process implements proxy.Outbound.Process.
func (c *Client) Process(ctx context.Context, link *transport.Link, dialer internet.Dialer) error {
outbounds := session.OutboundsFromContext(ctx)
ob := outbounds[len(outbounds) - 1]
ob := outbounds[len(outbounds)-1]
if !ob.Target.IsValid() {
return newError("target not specified.")
return errors.New("target not specified.")
}
ob.Name = "socks"
ob.CanSpliceCopy = 2
@ -85,12 +86,12 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
return nil
}); err != nil {
return newError("failed to find an available destination").Base(err)
return errors.New("failed to find an available destination").Base(err)
}
defer func() {
if err := conn.Close(); err != nil {
newError("failed to closed connection").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to closed connection")
}
}()
@ -121,9 +122,9 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
request.Version = socks4Version
if destination.Network == net.Network_UDP {
return newError("udp is not supported in socks4")
return errors.New("udp is not supported in socks4")
} else if destination.Address.Family().IsIPv6() {
return newError("ipv6 is not supported in socks4")
return errors.New("ipv6 is not supported in socks4")
}
}
@ -138,11 +139,11 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
}
if err := conn.SetDeadline(time.Now().Add(p.Timeouts.Handshake)); err != nil {
newError("failed to set deadline for handshake").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to set deadline for handshake")
}
udpRequest, err := ClientHandshake(request, conn, conn)
if err != nil {
return newError("failed to establish connection to server").AtWarning().Base(err)
return errors.New("failed to establish connection to server").AtWarning().Base(err)
}
if udpRequest != nil {
if udpRequest.Address == net.AnyIP || udpRequest.Address == net.AnyIPv6 {
@ -151,7 +152,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
}
if err := conn.SetDeadline(time.Time{}); err != nil {
newError("failed to clear deadline after handshake").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to clear deadline after handshake")
}
var newCtx context.Context
@ -182,7 +183,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
} else if request.Command == protocol.RequestCommandUDP {
udpConn, err := dialer.Dial(ctx, udpRequest.Destination())
if err != nil {
return newError("failed to create UDP connection").Base(err)
return errors.New("failed to create UDP connection").Base(err)
}
defer udpConn.Close()
requestFunc = func() error {
@ -203,7 +204,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
responseDonePost := task.OnSuccess(responseFunc, task.Close(link.Writer))
if err := task.Run(ctx, requestFunc, responseDonePost); err != nil {
return newError("connection ends").Base(err)
return errors.New("connection ends").Base(err)
}
return nil

9
proxy/socks/errors.generated.go
View file

@ -1,9 +0,0 @@
package socks
import "github.com/xtls/xray-core/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}

51
proxy/socks/protocol.go
View file

@ -6,6 +6,7 @@ import (
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/buf"
"github.com/xtls/xray-core/common/errors"
"github.com/xtls/xray-core/common/net"
"github.com/xtls/xray-core/common/protocol"
)
@ -48,7 +49,7 @@ type ServerSession struct {
func (s *ServerSession) handshake4(cmd byte, reader io.Reader, writer io.Writer) (*protocol.RequestHeader, error) {
if s.config.AuthType == AuthType_PASSWORD {
writeSocks4Response(writer, socks4RequestRejected, net.AnyIP, net.Port(0))
return nil, newError("socks 4 is not allowed when auth is required.")
return nil, errors.New("socks 4 is not allowed when auth is required.")
}
var port net.Port
@ -58,7 +59,7 @@ func (s *ServerSession) handshake4(cmd byte, reader io.Reader, writer io.Writer)
buffer := buf.StackNew()
if _, err := buffer.ReadFullFrom(reader, 6); err != nil {
buffer.Release()
return nil, newError("insufficient header").Base(err)
return nil, errors.New("insufficient header").Base(err)
}
port = net.PortFromBytes(buffer.BytesRange(0, 2))
address = net.IPAddress(buffer.BytesRange(2, 6))
@ -71,7 +72,7 @@ func (s *ServerSession) handshake4(cmd byte, reader io.Reader, writer io.Writer)
if address.IP()[0] == 0x00 {
domain, err := ReadUntilNull(reader)
if err != nil {
return nil, newError("failed to read domain for socks 4a").Base(err)
return nil, errors.New("failed to read domain for socks 4a").Base(err)
}
address = net.DomainAddress(domain)
}
@ -90,7 +91,7 @@ func (s *ServerSession) handshake4(cmd byte, reader io.Reader, writer io.Writer)
return request, nil
default:
writeSocks4Response(writer, socks4RequestRejected, net.AnyIP, net.Port(0))
return nil, newError("unsupported command: ", cmd)
return nil, errors.New("unsupported command: ", cmd)
}
}
@ -99,7 +100,7 @@ func (s *ServerSession) auth5(nMethod byte, reader io.Reader, writer io.Writer)
defer buffer.Release()
if _, err = buffer.ReadFullFrom(reader, int32(nMethod)); err != nil {
return "", newError("failed to read auth methods").Base(err)
return "", errors.New("failed to read auth methods").Base(err)
}
var expectedAuth byte = authNotRequired
@ -109,26 +110,26 @@ func (s *ServerSession) auth5(nMethod byte, reader io.Reader, writer io.Writer)
if !hasAuthMethod(expectedAuth, buffer.BytesRange(0, int32(nMethod))) {
writeSocks5AuthenticationResponse(writer, socks5Version, authNoMatchingMethod)
return "", newError("no matching auth method")
return "", errors.New("no matching auth method")
}
if err := writeSocks5AuthenticationResponse(writer, socks5Version, expectedAuth); err != nil {
return "", newError("failed to write auth response").Base(err)
return "", errors.New("failed to write auth response").Base(err)
}
if expectedAuth == authPassword {
username, password, err := ReadUsernamePassword(reader)
if err != nil {
return "", newError("failed to read username and password for authentication").Base(err)
return "", errors.New("failed to read username and password for authentication").Base(err)
}
if !s.config.HasAccount(username, password) {
writeSocks5AuthenticationResponse(writer, 0x01, 0xFF)
return "", newError("invalid username or password")
return "", errors.New("invalid username or password")
}
if err := writeSocks5AuthenticationResponse(writer, 0x01, 0x00); err != nil {
return "", newError("failed to write auth response").Base(err)
return "", errors.New("failed to write auth response").Base(err)
}
return username, nil
}
@ -150,7 +151,7 @@ func (s *ServerSession) handshake5(nMethod byte, reader io.Reader, writer io.Wri
buffer := buf.StackNew()
if _, err := buffer.ReadFullFrom(reader, 3); err != nil {
buffer.Release()
return nil, newError("failed to read request").Base(err)
return nil, errors.New("failed to read request").Base(err)
}
cmd = buffer.Byte(1)
buffer.Release()
@ -167,22 +168,22 @@ func (s *ServerSession) handshake5(nMethod byte, reader io.Reader, writer io.Wri
case cmdUDPAssociate:
if !s.config.UdpEnabled {
writeSocks5Response(writer, statusCmdNotSupport, net.AnyIP, net.Port(0))
return nil, newError("UDP is not enabled.")
return nil, errors.New("UDP is not enabled.")
}
request.Command = protocol.RequestCommandUDP
case cmdTCPBind:
writeSocks5Response(writer, statusCmdNotSupport, net.AnyIP, net.Port(0))
return nil, newError("TCP bind is not supported.")
return nil, errors.New("TCP bind is not supported.")
default:
writeSocks5Response(writer, statusCmdNotSupport, net.AnyIP, net.Port(0))
return nil, newError("unknown command ", cmd)
return nil, errors.New("unknown command ", cmd)
}
request.Version = socks5Version
addr, port, err := addrParser.ReadAddressPort(nil, reader)
if err != nil {
return nil, newError("failed to read address").Base(err)
return nil, errors.New("failed to read address").Base(err)
}
request.Address = addr
request.Port = port
@ -211,7 +212,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
buffer := buf.StackNew()
if _, err := buffer.ReadFullFrom(reader, 2); err != nil {
buffer.Release()
return nil, newError("insufficient header").Base(err)
return nil, errors.New("insufficient header").Base(err)
}
version := buffer.Byte(0)
@ -224,7 +225,7 @@ func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol
case socks5Version:
return s.handshake5(cmd, reader, writer)
default:
return nil, newError("unknown Socks version: ", version)
return nil, errors.New("unknown Socks version: ", version)
}
}
@ -278,7 +279,7 @@ func ReadUntilNull(reader io.Reader) (string, error) {
return b.String(), nil
}
if b.IsFull() {
return "", newError("buffer overrun")
return "", errors.New("buffer overrun")
}
}
}
@ -322,7 +323,7 @@ func writeSocks4Response(writer io.Writer, errCode byte, address net.Address, po
func DecodeUDPPacket(packet *buf.Buffer) (*protocol.RequestHeader, error) {
if packet.Len() < 5 {
return nil, newError("insufficient length of packet.")
return nil, errors.New("insufficient length of packet.")
}
request := &protocol.RequestHeader{
Version: socks5Version,
@ -331,14 +332,14 @@ func DecodeUDPPacket(packet *buf.Buffer) (*protocol.RequestHeader, error) {
// packet[0] and packet[1] are reserved
if packet.Byte(2) != 0 /* fragments */ {
return nil, newError("discarding fragmented payload.")
return nil, errors.New("discarding fragmented payload.")
}
packet.Advance(3)
addr, port, err := addrParser.ReadAddressPort(nil, packet)
if err != nil {
return nil, newError("failed to read UDP header").Base(err)
return nil, errors.New("failed to read UDP header").Base(err)
}
request.Address = addr
request.Port = port
@ -432,10 +433,10 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
}
if b.Byte(0) != socks5Version {
return nil, newError("unexpected server version: ", b.Byte(0)).AtWarning()
return nil, errors.New("unexpected server version: ", b.Byte(0)).AtWarning()
}
if b.Byte(1) != authByte {
return nil, newError("auth method not supported.").AtWarning()
return nil, errors.New("auth method not supported.").AtWarning()
}
if authByte == authPassword {
@ -455,7 +456,7 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
return nil, err
}
if b.Byte(1) != 0x00 {
return nil, newError("server rejects account: ", b.Byte(1))
return nil, errors.New("server rejects account: ", b.Byte(1))
}
}
@ -485,7 +486,7 @@ func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer i
resp := b.Byte(1)
if resp != 0x00 {
return nil, newError("server rejects request: ", resp)
return nil, errors.New("server rejects request: ", resp)
}
b.Clear()

31
proxy/socks/server.go
View file

@ -7,6 +7,7 @@ import (
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/buf"
"github.com/xtls/xray-core/common/errors"
"github.com/xtls/xray-core/common/log"
"github.com/xtls/xray-core/common/net"
"github.com/xtls/xray-core/common/protocol"
@ -80,19 +81,19 @@ func (s *Server) Process(ctx context.Context, network net.Network, conn stat.Con
case net.Network_UDP:
return s.handleUDPPayload(ctx, conn, dispatcher)
default:
return newError("unknown network: ", network)
return errors.New("unknown network: ", network)
}
}
func (s *Server) processTCP(ctx context.Context, conn stat.Connection, dispatcher routing.Dispatcher) error {
plcy := s.policy()
if err := conn.SetReadDeadline(time.Now().Add(plcy.Timeouts.Handshake)); err != nil {
newError("failed to set deadline").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to set deadline")
}
inbound := session.InboundFromContext(ctx)
if inbound == nil || !inbound.Gateway.IsValid() {
return newError("inbound gateway not specified")
return errors.New("inbound gateway not specified")
}
svrSession := &ServerSession{
@ -113,19 +114,19 @@ func (s *Server) processTCP(ctx context.Context, conn stat.Connection, dispatche
Reason: err,
})
}
return newError("failed to read request").Base(err)
return errors.New("failed to read request").Base(err)
}
if request.User != nil {
inbound.User.Email = request.User.Email
}
if err := conn.SetReadDeadline(time.Time{}); err != nil {
newError("failed to clear deadline").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to clear deadline")
}
if request.Command == protocol.RequestCommandTCP {
dest := request.Destination()
newError("TCP Connect request to ", dest).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfo(ctx, "TCP Connect request to ", dest)
if inbound.Source.IsValid() {
ctx = log.ContextWithAccessMessage(ctx, &log.AccessMessage{
From: inbound.Source,
@ -172,7 +173,7 @@ func (s *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
requestDone := func() error {
defer timer.SetTimeout(plcy.Timeouts.DownlinkOnly)
if err := buf.Copy(buf.NewReader(reader), link.Writer, buf.UpdateActivity(timer)); err != nil {
return newError("failed to transport all TCP request").Base(err)
return errors.New("failed to transport all TCP request").Base(err)
}
return nil
@ -183,7 +184,7 @@ func (s *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
v2writer := buf.NewWriter(writer)
if err := buf.Copy(link.Reader, v2writer, buf.UpdateActivity(timer)); err != nil {
return newError("failed to transport all TCP response").Base(err)
return errors.New("failed to transport all TCP response").Base(err)
}
return nil
@ -193,7 +194,7 @@ func (s *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
if err := task.Run(ctx, requestDonePost, responseDone); err != nil {
common.Interrupt(link.Reader)
common.Interrupt(link.Writer)
return newError("connection ends").Base(err)
return errors.New("connection ends").Base(err)
}
return nil
@ -201,12 +202,12 @@ func (s *Server) transport(ctx context.Context, reader io.Reader, writer io.Writ
func (s *Server) handleUDPPayload(ctx context.Context, conn stat.Connection, dispatcher routing.Dispatcher) error {
if s.udpFilter != nil && !s.udpFilter.Check(conn.RemoteAddr()) {
newError("Unauthorized UDP access from ", conn.RemoteAddr().String()).AtDebug().WriteToLog(session.ExportIDToError(ctx))
errors.LogDebug(ctx, "Unauthorized UDP access from ", conn.RemoteAddr().String())
return nil
}
udpServer := udp.NewDispatcher(dispatcher, func(ctx context.Context, packet *udp_proto.Packet) {
payload := packet.Payload
newError("writing back UDP response with ", payload.Len(), " bytes").AtDebug().WriteToLog(session.ExportIDToError(ctx))
errors.LogDebug(ctx, "writing back UDP response with ", payload.Len(), " bytes")
request := protocol.RequestHeaderFromContext(ctx)
if request == nil {
@ -226,7 +227,7 @@ func (s *Server) handleUDPPayload(ctx context.Context, conn stat.Connection, dis
defer udpMessage.Release()
if err != nil {
newError("failed to write UDP response").AtWarning().Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogWarningInner(ctx, err, "failed to write UDP response")
}
conn.Write(udpMessage.Bytes())
@ -234,7 +235,7 @@ func (s *Server) handleUDPPayload(ctx context.Context, conn stat.Connection, dis
inbound := session.InboundFromContext(ctx)
if inbound != nil && inbound.Source.IsValid() {
newError("client UDP connection from ", inbound.Source).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfo(ctx, "client UDP connection from ", inbound.Source)
}
var dest *net.Destination
@ -249,7 +250,7 @@ func (s *Server) handleUDPPayload(ctx context.Context, conn stat.Connection, dis
for _, payload := range mpayload {
request, err := DecodeUDPPacket(payload)
if err != nil {
newError("failed to parse UDP request").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to parse UDP request")
payload.Release()
continue
}
@ -262,7 +263,7 @@ func (s *Server) handleUDPPayload(ctx context.Context, conn stat.Connection, dis
destination := request.Destination()
currentPacketCtx := ctx
newError("send packet to ", destination, " with ", payload.Len(), " bytes").AtDebug().WriteToLog(session.ExportIDToError(ctx))
errors.LogDebug(ctx, "send packet to ", destination, " with ", payload.Len(), " bytes")
if inbound != nil && inbound.Source.IsValid() {
currentPacketCtx = log.ContextWithAccessMessage(ctx, &log.AccessMessage{
From: inbound.Source,