mirror of
https://github.com/shtorm-7/sing-box-extended.git
synced 2026-06-17 00:32:01 +03:00
Init commit
This commit is contained in:
世界
291
adapter/inbound_default.go
Normal file
291
adapter/inbound_default.go
Normal file
@@ -0,0 +1,291 @@
|
||||
package adapter
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"net/netip"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/database64128/tfo-go"
|
||||
C "github.com/sagernet/sing-box/constant"
|
||||
"github.com/sagernet/sing-box/log"
|
||||
"github.com/sagernet/sing/common"
|
||||
"github.com/sagernet/sing/common/buf"
|
||||
E "github.com/sagernet/sing/common/exceptions"
|
||||
M "github.com/sagernet/sing/common/metadata"
|
||||
N "github.com/sagernet/sing/common/network"
|
||||
)
|
||||
|
||||
type InboundHandler interface {
|
||||
Type() string
|
||||
Network() []string
|
||||
NewConnection(ctx context.Context, conn net.Conn, metadata InboundContext) error
|
||||
NewPacket(ctx context.Context, conn N.PacketConn, buffer *buf.Buffer, metadata InboundContext) error
|
||||
}
|
||||
|
||||
var _ Inbound = (*DefaultInboundService)(nil)
|
||||
|
||||
type DefaultInboundService struct {
|
||||
ctx context.Context
|
||||
logger log.Logger
|
||||
tag string
|
||||
listen netip.AddrPort
|
||||
listenerTFO bool
|
||||
handler InboundHandler
|
||||
tcpListener *net.TCPListener
|
||||
udpConn *net.UDPConn
|
||||
forceAddr6 bool
|
||||
access sync.RWMutex
|
||||
closed chan struct{}
|
||||
outbound chan *defaultInboundUDPServiceOutboundPacket
|
||||
}
|
||||
|
||||
func NewDefaultInboundService(ctx context.Context, tag string, logger log.Logger, listen netip.AddrPort, listenerTFO bool, handler InboundHandler) *DefaultInboundService {
|
||||
return &DefaultInboundService{
|
||||
ctx: ctx,
|
||||
logger: logger,
|
||||
tag: tag,
|
||||
listen: listen,
|
||||
listenerTFO: listenerTFO,
|
||||
handler: handler,
|
||||
closed: make(chan struct{}),
|
||||
outbound: make(chan *defaultInboundUDPServiceOutboundPacket),
|
||||
}
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) Type() string {
|
||||
return s.handler.Type()
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) Tag() string {
|
||||
return s.tag
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) Start() error {
|
||||
var listenAddr net.Addr
|
||||
if common.Contains(s.handler.Network(), C.NetworkTCP) {
|
||||
var tcpListener *net.TCPListener
|
||||
var err error
|
||||
if !s.listenerTFO {
|
||||
tcpListener, err = net.ListenTCP(M.NetworkFromNetAddr("tcp", s.listen.Addr()), M.SocksaddrFromNetIP(s.listen).TCPAddr())
|
||||
} else {
|
||||
tcpListener, err = tfo.ListenTCP(M.NetworkFromNetAddr("tcp", s.listen.Addr()), M.SocksaddrFromNetIP(s.listen).TCPAddr())
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.tcpListener = tcpListener
|
||||
go s.loopTCPIn()
|
||||
listenAddr = tcpListener.Addr()
|
||||
}
|
||||
if common.Contains(s.handler.Network(), C.NetworkUDP) {
|
||||
udpConn, err := net.ListenUDP(M.NetworkFromNetAddr("udp", s.listen.Addr()), M.SocksaddrFromNetIP(s.listen).UDPAddr())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.udpConn = udpConn
|
||||
s.forceAddr6 = M.SocksaddrFromNet(udpConn.LocalAddr()).Addr.Is6()
|
||||
if _, threadUnsafeHandler := common.Cast[N.ThreadUnsafeWriter](s.handler); !threadUnsafeHandler {
|
||||
go s.loopUDPIn()
|
||||
} else {
|
||||
go s.loopUDPInThreadSafe()
|
||||
}
|
||||
go s.loopUDPOut()
|
||||
if listenAddr == nil {
|
||||
listenAddr = udpConn.LocalAddr()
|
||||
}
|
||||
}
|
||||
s.logger.Info("server started at ", listenAddr)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) Close() error {
|
||||
return common.Close(
|
||||
common.PtrOrNil(s.tcpListener),
|
||||
common.PtrOrNil(s.udpConn),
|
||||
)
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) Upstream() any {
|
||||
return s.handler
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) loopTCPIn() {
|
||||
tcpListener := s.tcpListener
|
||||
for {
|
||||
conn, err := tcpListener.Accept()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
var metadata InboundContext
|
||||
metadata.Inbound = s.tag
|
||||
metadata.Source = M.AddrPortFromNet(conn.RemoteAddr())
|
||||
go func() {
|
||||
metadata.Network = "tcp"
|
||||
ctx := log.ContextWithID(s.ctx)
|
||||
s.logger.WithContext(ctx).Info("inbound connection from ", conn.RemoteAddr())
|
||||
hErr := s.handler.NewConnection(ctx, conn, metadata)
|
||||
if hErr != nil {
|
||||
s.newContextError(ctx, E.Cause(hErr, "process connection from ", conn.RemoteAddr()))
|
||||
}
|
||||
}()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) loopUDPIn() {
|
||||
defer close(s.closed)
|
||||
_buffer := buf.StackNewPacket()
|
||||
defer common.KeepAlive(_buffer)
|
||||
buffer := common.Dup(_buffer)
|
||||
defer buffer.Release()
|
||||
buffer.IncRef()
|
||||
defer buffer.DecRef()
|
||||
packetService := (*defaultInboundUDPService)(s)
|
||||
var metadata InboundContext
|
||||
metadata.Inbound = s.tag
|
||||
metadata.Network = "udp"
|
||||
for {
|
||||
buffer.Reset()
|
||||
n, addr, err := s.udpConn.ReadFromUDPAddrPort(buffer.FreeBytes())
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
buffer.Truncate(n)
|
||||
metadata.Source = addr
|
||||
err = s.handler.NewPacket(s.ctx, packetService, buffer, metadata)
|
||||
if err != nil {
|
||||
s.newError(E.Cause(err, "process packet from ", addr))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) loopUDPInThreadSafe() {
|
||||
defer close(s.closed)
|
||||
packetService := (*defaultInboundUDPService)(s)
|
||||
var metadata InboundContext
|
||||
metadata.Inbound = s.tag
|
||||
metadata.Network = "udp"
|
||||
for {
|
||||
buffer := buf.NewPacket()
|
||||
n, addr, err := s.udpConn.ReadFromUDPAddrPort(buffer.FreeBytes())
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
buffer.Truncate(n)
|
||||
metadata.Source = addr
|
||||
err = s.handler.NewPacket(s.ctx, packetService, buffer, metadata)
|
||||
if err != nil {
|
||||
buffer.Release()
|
||||
s.newError(E.Cause(err, "process packet from ", addr))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) loopUDPOut() {
|
||||
for {
|
||||
select {
|
||||
case packet := <-s.outbound:
|
||||
err := s.writePacket(packet.buffer, packet.destination)
|
||||
if err != nil && !E.IsClosed(err) {
|
||||
s.newError(E.New("write back udp: ", err))
|
||||
}
|
||||
continue
|
||||
case <-s.closed:
|
||||
}
|
||||
for {
|
||||
select {
|
||||
case packet := <-s.outbound:
|
||||
packet.buffer.Release()
|
||||
default:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) newError(err error) {
|
||||
s.logger.Warn(err)
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) newContextError(ctx context.Context, err error) {
|
||||
common.Close(err)
|
||||
if E.IsClosed(err) {
|
||||
s.logger.WithContext(ctx).Debug("connection closed")
|
||||
return
|
||||
}
|
||||
s.logger.Error(err)
|
||||
}
|
||||
|
||||
func (s *DefaultInboundService) writePacket(buffer *buf.Buffer, destination M.Socksaddr) error {
|
||||
defer buffer.Release()
|
||||
if destination.Family().IsFqdn() {
|
||||
udpAddr, err := net.ResolveUDPAddr("udp", destination.String())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return common.Error(s.udpConn.WriteTo(buffer.Bytes(), udpAddr))
|
||||
}
|
||||
if s.forceAddr6 && destination.Addr.Is4() {
|
||||
destination.Addr = netip.AddrFrom16(destination.Addr.As16())
|
||||
}
|
||||
return common.Error(s.udpConn.WriteToUDPAddrPort(buffer.Bytes(), destination.AddrPort()))
|
||||
}
|
||||
|
||||
type defaultInboundUDPService DefaultInboundService
|
||||
|
||||
func (s *defaultInboundUDPService) ReadPacket(buffer *buf.Buffer) (M.Socksaddr, error) {
|
||||
n, addr, err := s.udpConn.ReadFromUDPAddrPort(buffer.FreeBytes())
|
||||
if err != nil {
|
||||
return M.Socksaddr{}, err
|
||||
}
|
||||
buffer.Truncate(n)
|
||||
return M.SocksaddrFromNetIP(addr), nil
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) WriteIsThreadUnsafe() {
|
||||
}
|
||||
|
||||
type defaultInboundUDPServiceOutboundPacket struct {
|
||||
buffer *buf.Buffer
|
||||
destination M.Socksaddr
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) Upstream() any {
|
||||
return s.udpConn
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) WritePacket(buffer *buf.Buffer, destination M.Socksaddr) error {
|
||||
s.access.RLock()
|
||||
defer s.access.RUnlock()
|
||||
|
||||
select {
|
||||
case <-s.closed:
|
||||
return os.ErrClosed
|
||||
default:
|
||||
}
|
||||
|
||||
s.outbound <- &defaultInboundUDPServiceOutboundPacket{buffer, destination}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) Close() error {
|
||||
return s.udpConn.Close()
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) LocalAddr() net.Addr {
|
||||
return s.udpConn.LocalAddr()
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) SetDeadline(t time.Time) error {
|
||||
return s.udpConn.SetDeadline(t)
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) SetReadDeadline(t time.Time) error {
|
||||
return s.udpConn.SetReadDeadline(t)
|
||||
}
|
||||
|
||||
func (s *defaultInboundUDPService) SetWriteDeadline(t time.Time) error {
|
||||
return s.udpConn.SetWriteDeadline(t)
|
||||
}
|
||||
Reference in New Issue
Block a user