sing-box/outbound/default.go

245 lines
7.6 KiB
Go
Raw Normal View History

package outbound
import (
"context"
"net"
2023-04-02 04:01:19 +00:00
"net/netip"
2022-10-20 02:57:57 +00:00
"os"
"time"
2022-07-08 15:03:57 +00:00
"github.com/sagernet/sing-box/adapter"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
2023-06-13 14:38:05 +00:00
"github.com/sagernet/sing-box/option"
2023-10-08 14:11:03 +00:00
"github.com/sagernet/sing-dns"
"github.com/sagernet/sing/common"
"github.com/sagernet/sing/common/buf"
"github.com/sagernet/sing/common/bufio"
2023-03-23 07:14:21 +00:00
"github.com/sagernet/sing/common/canceler"
E "github.com/sagernet/sing/common/exceptions"
2023-10-25 04:00:00 +00:00
M "github.com/sagernet/sing/common/metadata"
2022-07-07 15:36:32 +00:00
N "github.com/sagernet/sing/common/network"
)
type myOutboundAdapter struct {
2023-06-13 14:38:05 +00:00
protocol string
network []string
router adapter.Router
logger log.ContextLogger
tag string
dependencies []string
}
func (a *myOutboundAdapter) Type() string {
return a.protocol
}
func (a *myOutboundAdapter) Tag() string {
return a.tag
}
func (a *myOutboundAdapter) Network() []string {
return a.network
}
2023-06-13 14:38:05 +00:00
func (a *myOutboundAdapter) Dependencies() []string {
return a.dependencies
}
2023-04-13 08:02:28 +00:00
func (a *myOutboundAdapter) NewError(ctx context.Context, err error) {
NewError(a.logger, ctx, err)
}
2023-06-13 14:38:05 +00:00
func withDialerDependency(options option.DialerOptions) []string {
if options.Detour != "" {
return []string{options.Detour}
}
return nil
}
2022-07-07 15:36:32 +00:00
func NewConnection(ctx context.Context, this N.Dialer, conn net.Conn, metadata adapter.InboundContext) error {
ctx = adapter.WithContext(ctx, &metadata)
var outConn net.Conn
var err error
if len(metadata.DestinationAddresses) > 0 {
2022-07-29 16:29:22 +00:00
outConn, err = N.DialSerial(ctx, this, N.NetworkTCP, metadata.Destination, metadata.DestinationAddresses)
2022-07-07 15:36:32 +00:00
} else {
2022-07-29 16:29:22 +00:00
outConn, err = this.DialContext(ctx, N.NetworkTCP, metadata.Destination)
2022-07-07 15:36:32 +00:00
}
if err != nil {
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
}
err = N.ReportHandshakeSuccess(conn)
if err != nil {
outConn.Close()
2023-08-31 12:07:32 +00:00
return err
2022-07-07 15:36:32 +00:00
}
return CopyEarlyConn(ctx, conn, outConn)
}
2023-10-08 14:11:03 +00:00
func NewDirectConnection(ctx context.Context, router adapter.Router, this N.Dialer, conn net.Conn, metadata adapter.InboundContext, domainStrategy dns.DomainStrategy) error {
2023-09-06 11:13:39 +00:00
ctx = adapter.WithContext(ctx, &metadata)
var outConn net.Conn
var err error
if len(metadata.DestinationAddresses) > 0 {
outConn, err = N.DialSerial(ctx, this, N.NetworkTCP, metadata.Destination, metadata.DestinationAddresses)
} else if metadata.Destination.IsFqdn() {
var destinationAddresses []netip.Addr
2023-10-08 14:11:03 +00:00
destinationAddresses, err = router.Lookup(ctx, metadata.Destination.Fqdn, domainStrategy)
2023-09-06 11:13:39 +00:00
if err != nil {
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
2023-09-06 11:13:39 +00:00
}
outConn, err = N.DialSerial(ctx, this, N.NetworkTCP, metadata.Destination, destinationAddresses)
} else {
outConn, err = this.DialContext(ctx, N.NetworkTCP, metadata.Destination)
}
if err != nil {
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
}
err = N.ReportHandshakeSuccess(conn)
if err != nil {
outConn.Close()
2023-08-31 12:07:32 +00:00
return err
2023-09-06 11:13:39 +00:00
}
return CopyEarlyConn(ctx, conn, outConn)
}
2022-07-07 15:36:32 +00:00
func NewPacketConnection(ctx context.Context, this N.Dialer, conn N.PacketConn, metadata adapter.InboundContext) error {
ctx = adapter.WithContext(ctx, &metadata)
var outConn net.PacketConn
2023-04-02 04:01:19 +00:00
var destinationAddress netip.Addr
2022-07-07 15:36:32 +00:00
var err error
if len(metadata.DestinationAddresses) > 0 {
2023-04-02 04:01:19 +00:00
outConn, destinationAddress, err = N.ListenSerial(ctx, this, metadata.Destination, metadata.DestinationAddresses)
2022-07-07 15:36:32 +00:00
} else {
outConn, err = this.ListenPacket(ctx, metadata.Destination)
}
if err != nil {
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
}
err = N.ReportHandshakeSuccess(conn)
if err != nil {
outConn.Close()
2023-08-31 12:07:32 +00:00
return err
2022-07-07 15:36:32 +00:00
}
2023-04-02 04:01:19 +00:00
if destinationAddress.IsValid() {
2023-10-25 04:00:00 +00:00
if metadata.Destination.IsFqdn() {
if metadata.InboundOptions.UDPDisableDomainUnmapping {
outConn = bufio.NewUnidirectionalNATPacketConn(bufio.NewPacketConn(outConn), M.SocksaddrFrom(destinationAddress, metadata.Destination.Port), metadata.Destination)
} else {
outConn = bufio.NewNATPacketConn(bufio.NewPacketConn(outConn), M.SocksaddrFrom(destinationAddress, metadata.Destination.Port), metadata.Destination)
}
2023-10-25 04:00:00 +00:00
}
if natConn, loaded := common.Cast[bufio.NATPacketConn](conn); loaded {
2023-04-02 04:01:19 +00:00
natConn.UpdateDestination(destinationAddress)
}
}
2022-08-12 04:13:57 +00:00
switch metadata.Protocol {
case C.ProtocolSTUN:
ctx, conn = canceler.NewPacketConn(ctx, conn, C.STUNTimeout)
case C.ProtocolQUIC:
ctx, conn = canceler.NewPacketConn(ctx, conn, C.QUICTimeout)
case C.ProtocolDNS:
ctx, conn = canceler.NewPacketConn(ctx, conn, C.DNSTimeout)
}
2022-11-24 04:00:01 +00:00
return bufio.CopyPacketConn(ctx, conn, bufio.NewPacketConn(outConn))
}
2023-10-08 14:11:03 +00:00
func NewDirectPacketConnection(ctx context.Context, router adapter.Router, this N.Dialer, conn N.PacketConn, metadata adapter.InboundContext, domainStrategy dns.DomainStrategy) error {
2023-09-06 11:13:39 +00:00
ctx = adapter.WithContext(ctx, &metadata)
var outConn net.PacketConn
var destinationAddress netip.Addr
var err error
if len(metadata.DestinationAddresses) > 0 {
outConn, destinationAddress, err = N.ListenSerial(ctx, this, metadata.Destination, metadata.DestinationAddresses)
} else if metadata.Destination.IsFqdn() {
var destinationAddresses []netip.Addr
2023-10-08 14:11:03 +00:00
destinationAddresses, err = router.Lookup(ctx, metadata.Destination.Fqdn, domainStrategy)
2023-09-06 11:13:39 +00:00
if err != nil {
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
2023-09-06 11:13:39 +00:00
}
outConn, destinationAddress, err = N.ListenSerial(ctx, this, metadata.Destination, destinationAddresses)
} else {
outConn, err = this.ListenPacket(ctx, metadata.Destination)
}
if err != nil {
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
}
err = N.ReportHandshakeSuccess(conn)
if err != nil {
outConn.Close()
2023-08-31 12:07:32 +00:00
return err
2023-09-06 11:13:39 +00:00
}
if destinationAddress.IsValid() {
2023-10-25 04:00:00 +00:00
if metadata.Destination.IsFqdn() {
outConn = bufio.NewNATPacketConn(bufio.NewPacketConn(outConn), M.SocksaddrFrom(destinationAddress, metadata.Destination.Port), metadata.Destination)
}
if natConn, loaded := common.Cast[bufio.NATPacketConn](conn); loaded {
2023-09-06 11:13:39 +00:00
natConn.UpdateDestination(destinationAddress)
}
}
switch metadata.Protocol {
case C.ProtocolSTUN:
ctx, conn = canceler.NewPacketConn(ctx, conn, C.STUNTimeout)
case C.ProtocolQUIC:
ctx, conn = canceler.NewPacketConn(ctx, conn, C.QUICTimeout)
case C.ProtocolDNS:
ctx, conn = canceler.NewPacketConn(ctx, conn, C.DNSTimeout)
}
return bufio.CopyPacketConn(ctx, conn, bufio.NewPacketConn(outConn))
}
func CopyEarlyConn(ctx context.Context, conn net.Conn, serverConn net.Conn) error {
2022-08-08 12:56:53 +00:00
if cachedReader, isCached := conn.(N.CachedReader); isCached {
2022-07-11 12:55:14 +00:00
payload := cachedReader.ReadCached()
if payload != nil && !payload.IsEmpty() {
_, err := serverConn.Write(payload.Bytes())
2023-09-24 06:39:56 +00:00
payload.Release()
2022-07-11 12:55:14 +00:00
if err != nil {
serverConn.Close()
2022-07-11 12:55:14 +00:00
return err
}
return bufio.CopyConn(ctx, conn, serverConn)
}
}
2023-02-28 12:16:15 +00:00
if earlyConn, isEarlyConn := common.Cast[N.EarlyConn](serverConn); isEarlyConn && earlyConn.NeedHandshake() {
2023-07-03 13:45:32 +00:00
payload := buf.NewPacket()
2023-02-26 15:08:20 +00:00
err := conn.SetReadDeadline(time.Now().Add(C.ReadPayloadTimeout))
if err != os.ErrInvalid {
if err != nil {
2023-09-24 06:39:56 +00:00
payload.Release()
serverConn.Close()
2023-02-26 15:08:20 +00:00
return err
}
_, err = payload.ReadOnceFrom(conn)
if err != nil && !E.IsTimeout(err) {
2023-09-24 06:39:56 +00:00
payload.Release()
serverConn.Close()
2023-02-26 15:08:20 +00:00
return E.Cause(err, "read payload")
}
err = conn.SetReadDeadline(time.Time{})
if err != nil {
payload.Release()
serverConn.Close()
2023-02-26 15:08:20 +00:00
return err
}
2022-10-20 02:57:57 +00:00
}
2023-02-26 15:08:20 +00:00
_, err = serverConn.Write(payload.Bytes())
2023-09-24 06:39:56 +00:00
payload.Release()
2022-10-20 02:57:57 +00:00
if err != nil {
serverConn.Close()
2023-08-31 12:07:32 +00:00
return N.ReportHandshakeFailure(conn, err)
2022-10-20 02:57:57 +00:00
}
}
return bufio.CopyConn(ctx, conn, serverConn)
}
2023-04-13 08:02:28 +00:00
func NewError(logger log.ContextLogger, ctx context.Context, err error) {
common.Close(err)
if E.IsClosedOrCanceled(err) {
logger.DebugContext(ctx, "connection closed: ", err)
return
}
logger.ErrorContext(ctx, err)
}