icybear/sing-box
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate components to library

Browse Source
This commit is contained in:
世界
2022-07-11 18:44:59 +08:00
parent 3c1190e2c3
commit dc127e2994
46 changed files with 109 additions and 2438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

379
dns/client.go
View File

@@ -1,379 +0,0 @@
package dns
import (
"context"
"net"
"net/netip"
"strings"
"time"
"github.com/sagernet/sing-box/adapter"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/option"
"github.com/sagernet/sing/common"
"github.com/sagernet/sing/common/cache"
E "github.com/sagernet/sing/common/exceptions"
"github.com/sagernet/sing/common/task"
"golang.org/x/net/dns/dnsmessage"
)
const DefaultTTL = 600
var (
ErrNoRawSupport = E.New("no raw query support by current transport")
ErrNotCached = E.New("not cached")
)
var _ adapter.DNSClient = (*Client)(nil)
type Client struct {
cache *cache.LruCache[dnsmessage.Question, *dnsmessage.Message]
disableCache bool
disableExpire bool
strategy C.DomainStrategy
}
func NewClient(options option.DNSClientOptions) *Client {
client := &Client{
disableCache: options.DisableCache,
disableExpire: options.DisableExpire,
strategy: C.DomainStrategy(options.Strategy),
}
if !options.DisableCache {
client.cache = cache.New[dnsmessage.Question, *dnsmessage.Message]()
}
return client
}
func (c *Client) Exchange(ctx context.Context, transport adapter.DNSTransport, message *dnsmessage.Message) (*dnsmessage.Message, error) {
if len(message.Questions) != 1 {
responseMessage := dnsmessage.Message{
Header: dnsmessage.Header{
ID: message.ID,
RCode: dnsmessage.RCodeFormatError,
Response: true,
RecursionDesired: true,
},
}
return &responseMessage, nil
}
question := message.Questions[0]
if !c.disableCache {
cachedAnswer, cached := c.cache.Load(question)
if cached {
cachedAnswer.ID = message.ID
return cachedAnswer, nil
}
}
if !transport.Raw() {
if question.Type == dnsmessage.TypeA || question.Type == dnsmessage.TypeAAAA {
return c.exchangeToLookup(ctx, transport, message, question)
}
return nil, ErrNoRawSupport
}
if question.Type == dnsmessage.TypeA && c.strategy == C.DomainStrategyUseIPv6 || question.Type == dnsmessage.TypeAAAA && c.strategy == C.DomainStrategyUseIPv4 {
responseMessage := dnsmessage.Message{
Header: dnsmessage.Header{
ID: message.ID,
RCode: dnsmessage.RCodeNameError,
Response: true,
RecursionDesired: true,
},
Questions: []dnsmessage.Question{question},
}
return &responseMessage, nil
}
messageId := message.ID
response, err := transport.Exchange(ctx, message)
if err != nil {
return nil, err
}
response.ID = messageId
if !c.disableCache {
c.storeCache(question, response)
}
return response, err
}
func (c *Client) Lookup(ctx context.Context, transport adapter.DNSTransport, domain string, strategy C.DomainStrategy) ([]netip.Addr, error) {
if strings.HasPrefix(domain, ".") {
domain = domain[:len(domain)-1]
}
dnsName, err := dnsmessage.NewName(domain + ".")
if err != nil {
return nil, wrapError(err)
}
if transport.Raw() {
if strategy == C.DomainStrategyUseIPv4 {
return c.lookupToExchange(ctx, transport, dnsName, dnsmessage.TypeA)
} else if strategy == C.DomainStrategyUseIPv6 {
return c.lookupToExchange(ctx, transport, dnsName, dnsmessage.TypeAAAA)
}
var response4 []netip.Addr
var response6 []netip.Addr
err = task.Run(ctx, func() error {
response, err := c.lookupToExchange(ctx, transport, dnsName, dnsmessage.TypeA)
if err != nil {
return err
}
response4 = response
return nil
}, func() error {
response, err := c.lookupToExchange(ctx, transport, dnsName, dnsmessage.TypeAAAA)
if err != nil {
return err
}
response6 = response
return nil
})
if len(response4) == 0 && len(response6) == 0 {
return nil, err
}
return sortAddresses(response4, response6, strategy), nil
}
if !c.disableCache {
if strategy == C.DomainStrategyUseIPv4 {
response, err := c.questionCache(dnsmessage.Question{
Name: dnsName,
Type: dnsmessage.TypeA,
Class: dnsmessage.ClassINET,
})
if err != ErrNotCached {
return response, err
}
} else if strategy == C.DomainStrategyUseIPv6 {
response, err := c.questionCache(dnsmessage.Question{
Name: dnsName,
Type: dnsmessage.TypeAAAA,
Class: dnsmessage.ClassINET,
})
if err != ErrNotCached {
return response, err
}
} else {
response4, _ := c.questionCache(dnsmessage.Question{
Name: dnsName,
Type: dnsmessage.TypeA,
Class: dnsmessage.ClassINET,
})
response6, _ := c.questionCache(dnsmessage.Question{
Name: dnsName,
Type: dnsmessage.TypeAAAA,
Class: dnsmessage.ClassINET,
})
if len(response4) > 0 || len(response6) > 0 {
return sortAddresses(response4, response6, strategy), nil
}
}
}
var rCode dnsmessage.RCode
response, err := transport.Lookup(ctx, domain, strategy)
if err != nil {
err = wrapError(err)
if rCodeError, isRCodeError := err.(RCodeError); !isRCodeError {
return nil, err
} else {
rCode = dnsmessage.RCode(rCodeError)
}
if c.disableCache {
return nil, err
}
}
header := dnsmessage.Header{
Response: true,
Authoritative: true,
RCode: rCode,
}
if !c.disableCache {
if strategy != C.DomainStrategyUseIPv6 {
question4 := dnsmessage.Question{
Name: dnsName,
Type: dnsmessage.TypeA,
Class: dnsmessage.ClassINET,
}
response4 := common.Filter(response, func(addr netip.Addr) bool {
return addr.Is4() || addr.Is4In6()
})
message4 := &dnsmessage.Message{
Header: header,
Questions: []dnsmessage.Question{question4},
}
if len(response4) > 0 {
for _, address := range response4 {
message4.Answers = append(message4.Answers, dnsmessage.Resource{
Header: dnsmessage.ResourceHeader{
Name: question4.Name,
Class: question4.Class,
TTL: DefaultTTL,
},
Body: &dnsmessage.AResource{
A: address.As4(),
},
})
}
}
c.storeCache(question4, message4)
}
if strategy != C.DomainStrategyUseIPv4 {
question6 := dnsmessage.Question{
Name: dnsName,
Type: dnsmessage.TypeAAAA,
Class: dnsmessage.ClassINET,
}
response6 := common.Filter(response, func(addr netip.Addr) bool {
return addr.Is6() && !addr.Is4In6()
})
message6 := &dnsmessage.Message{
Header: header,
Questions: []dnsmessage.Question{question6},
}
if len(response6) > 0 {
for _, address := range response6 {
message6.Answers = append(message6.Answers, dnsmessage.Resource{
Header: dnsmessage.ResourceHeader{
Name: question6.Name,
Class: question6.Class,
TTL: DefaultTTL,
},
Body: &dnsmessage.AAAAResource{
AAAA: address.As16(),
},
})
}
}
c.storeCache(question6, message6)
}
}
return response, err
}
func sortAddresses(response4 []netip.Addr, response6 []netip.Addr, strategy C.DomainStrategy) []netip.Addr {
if strategy == C.DomainStrategyPreferIPv6 {
return append(response6, response4...)
} else {
return append(response4, response6...)
}
}
func (c *Client) storeCache(question dnsmessage.Question, message *dnsmessage.Message) {
if c.disableExpire {
c.cache.Store(question, message)
return
}
timeToLive := DefaultTTL
for _, answer := range message.Answers {
if int(answer.Header.TTL) < timeToLive {
timeToLive = int(answer.Header.TTL)
}
}
expire := time.Now().Add(time.Second * time.Duration(timeToLive))
c.cache.StoreWithExpire(question, message, expire)
}
func (c *Client) exchangeToLookup(ctx context.Context, transport adapter.DNSTransport, message *dnsmessage.Message, question dnsmessage.Question) (*dnsmessage.Message, error) {
domain := question.Name.String()
var strategy C.DomainStrategy
if question.Type == dnsmessage.TypeA {
strategy = C.DomainStrategyUseIPv4
} else {
strategy = C.DomainStrategyUseIPv6
}
var rCode dnsmessage.RCode
result, err := c.Lookup(ctx, transport, domain, strategy)
if err != nil {
err = wrapError(err)
if rCodeError, isRCodeError := err.(RCodeError); !isRCodeError {
return nil, err
} else {
rCode = dnsmessage.RCode(rCodeError)
}
}
response := dnsmessage.Message{
Header: dnsmessage.Header{
ID: message.ID,
RCode: rCode,
RecursionAvailable: true,
RecursionDesired: true,
Response: true,
},
Questions: message.Questions,
}
for _, address := range result {
var resource dnsmessage.Resource
resource.Header = dnsmessage.ResourceHeader{
Name: question.Name,
Class: question.Class,
TTL: DefaultTTL,
}
if address.Is4() || address.Is4In6() {
resource.Body = &dnsmessage.AResource{
A: address.As4(),
}
} else {
resource.Body = &dnsmessage.AAAAResource{
AAAA: address.As16(),
}
}
}
return &response, nil
}
func (c *Client) lookupToExchange(ctx context.Context, transport adapter.DNSTransport, name dnsmessage.Name, qType dnsmessage.Type) ([]netip.Addr, error) {
question := dnsmessage.Question{
Name: name,
Type: qType,
Class: dnsmessage.ClassINET,
}
if !c.disableCache {
cachedAddresses, err := c.questionCache(question)
if err != ErrNotCached {
return cachedAddresses, err
}
}
message := dnsmessage.Message{
Header: dnsmessage.Header{
ID: 0,
RecursionDesired: true,
},
Questions: []dnsmessage.Question{question},
}
response, err := c.Exchange(ctx, transport, &message)
if err != nil {
return nil, err
}
return messageToAddresses(response)
}
func (c *Client) questionCache(question dnsmessage.Question) ([]netip.Addr, error) {
response, cached := c.cache.Load(question)
if !cached {
return nil, ErrNotCached
}
return messageToAddresses(response)
}
func messageToAddresses(response *dnsmessage.Message) ([]netip.Addr, error) {
if response.RCode != dnsmessage.RCodeSuccess {
return nil, RCodeError(response.RCode)
}
addresses := make([]netip.Addr, 0, len(response.Answers))
for _, answer := range response.Answers {
switch resource := answer.Body.(type) {
case *dnsmessage.AResource:
addresses = append(addresses, netip.AddrFrom4(resource.A))
case *dnsmessage.AAAAResource:
addresses = append(addresses, netip.AddrFrom16(resource.AAAA))
}
}
return addresses, nil
}
func wrapError(err error) error {
if dnsErr, isDNSError := err.(*net.DNSError); isDNSError {
if dnsErr.IsNotFound {
return RCodeNameError
}
}
return err
}

33
dns/client_test.go
View File

@@ -1,33 +0,0 @@
package dns_test
import (
"context"
"testing"
"time"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/dns"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"github.com/stretchr/testify/require"
)
func TestClient(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
client := dns.NewClient(option.DNSClientOptions{})
dnsTransport := dns.NewTCPTransport(context.Background(), N.SystemDialer, log.NewNopLogger(), M.ParseSocksaddr("1.0.0.1:53"))
response, err := client.Exchange(ctx, dnsTransport, makeQuery())
require.NoError(t, err)
require.NotEmpty(t, response.Answers, "no answers")
response, err = client.Exchange(ctx, dnsTransport, makeQuery())
require.NoError(t, err)
require.NotEmpty(t, response.Answers, "no answers")
addresses, err := client.Lookup(ctx, dnsTransport, "www.google.com", C.DomainStrategyAsIS)
require.NoError(t, err)
require.NotEmpty(t, addresses, "no answers")
cancel()
}

49
dns/dialer.go
View File

@@ -1,49 +0,0 @@
package dns
import (
"context"
"net"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/dialer"
C "github.com/sagernet/sing-box/constant"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
)
type DialerWrapper struct {
dialer N.Dialer
strategy C.DomainStrategy
client adapter.DNSClient
transport adapter.DNSTransport
}
func NewDialerWrapper(dialer N.Dialer, strategy C.DomainStrategy, client adapter.DNSClient, transport adapter.DNSTransport) N.Dialer {
return &DialerWrapper{dialer, strategy, client, transport}
}
func (d *DialerWrapper) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
if destination.IsIP() {
return d.dialer.DialContext(ctx, network, destination)
}
addresses, err := d.client.Lookup(ctx, d.transport, destination.Fqdn, d.strategy)
if err != nil {
return nil, err
}
return dialer.DialSerial(ctx, d.dialer, network, destination, addresses)
}
func (d *DialerWrapper) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
if destination.IsIP() {
return d.dialer.ListenPacket(ctx, destination)
}
addresses, err := d.client.Lookup(ctx, d.transport, destination.Fqdn, d.strategy)
if err != nil {
return nil, err
}
return dialer.ListenSerial(ctx, d.dialer, destination, addresses)
}
func (d *DialerWrapper) Upstream() any {
return d.dialer
}

33
dns/rcode.go
View File

@@ -1,33 +0,0 @@
package dns
import F "github.com/sagernet/sing/common/format"
const (
RCodeSuccess RCodeError = 0 // NoError
RCodeFormatError RCodeError = 1 // FormErr
RCodeServerFailure RCodeError = 2 // ServFail
RCodeNameError RCodeError = 3 // NXDomain
RCodeNotImplemented RCodeError = 4 // NotImp
RCodeRefused RCodeError = 5 // Refused
)
type RCodeError uint16
func (e RCodeError) Error() string {
switch e {
case RCodeSuccess:
return "success"
case RCodeFormatError:
return "format error"
case RCodeServerFailure:
return "server failure"
case RCodeNameError:
return "name error"
case RCodeNotImplemented:
return "not implemented"
case RCodeRefused:
return "refused"
default:
return F.ToString("unknown error: ", uint16(e))
}
}

50
dns/transport.go
View File

@@ -1,50 +0,0 @@
package dns
import (
"context"
"net/url"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/log"
E "github.com/sagernet/sing/common/exceptions"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
)
func NewTransport(ctx context.Context, dialer N.Dialer, logger log.Logger, address string) (adapter.DNSTransport, error) {
if address == "local" {
return NewLocalTransport(), nil
}
serverURL, err := url.Parse(address)
if err != nil {
return nil, err
}
host := serverURL.Hostname()
if host == "" {
host = address
}
port := serverURL.Port()
switch serverURL.Scheme {
case "tls":
if port == "" {
port = "853"
}
default:
if port == "" {
port = "53"
}
}
destination := M.ParseSocksaddrHostPortStr(host, port)
switch serverURL.Scheme {
case "", "udp":
return NewUDPTransport(ctx, dialer, logger, destination), nil
case "tcp":
return NewTCPTransport(ctx, dialer, logger, destination), nil
case "tls":
return NewTLSTransport(ctx, dialer, logger, destination), nil
case "https":
return NewHTTPSTransport(dialer, serverURL.String()), nil
default:
return nil, E.New("unknown dns scheme: " + serverURL.Scheme)
}
}

45
dns/transport_base.go
View File

@@ -1,45 +0,0 @@
package dns
import (
"context"
"net/netip"
"os"
"sync"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
)
type myTransportAdapter struct {
ctx context.Context
dialer N.Dialer
logger log.Logger
destination M.Socksaddr
done chan struct{}
access sync.RWMutex
connection *dnsConnection
}
func (t *myTransportAdapter) Start() error {
return nil
}
func (t *myTransportAdapter) Close() error {
select {
case <-t.done:
return os.ErrClosed
default:
}
close(t.done)
return nil
}
func (t *myTransportAdapter) Raw() bool {
return true
}
func (t *myTransportAdapter) Lookup(ctx context.Context, domain string, strategy C.DomainStrategy) ([]netip.Addr, error) {
return nil, os.ErrInvalid
}

94
dns/transport_https.go
View File

@@ -1,94 +0,0 @@
package dns
import (
"bytes"
"context"
"net"
"net/http"
"net/netip"
"os"
"github.com/sagernet/sing-box/adapter"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing/common"
"github.com/sagernet/sing/common/buf"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"golang.org/x/net/dns/dnsmessage"
)
const dnsMimeType = "application/dns-message"
var _ adapter.DNSTransport = (*HTTPSTransport)(nil)
type HTTPSTransport struct {
destination string
transport *http.Transport
}
func NewHTTPSTransport(dialer N.Dialer, destination string) *HTTPSTransport {
return &HTTPSTransport{
destination: destination,
transport: &http.Transport{
ForceAttemptHTTP2: true,
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
return dialer.DialContext(ctx, network, M.ParseSocksaddr(addr))
},
},
}
}
func (t *HTTPSTransport) Start() error {
return nil
}
func (t *HTTPSTransport) Close() error {
t.transport.CloseIdleConnections()
return nil
}
func (t *HTTPSTransport) Raw() bool {
return true
}
func (t *HTTPSTransport) Exchange(ctx context.Context, message *dnsmessage.Message) (*dnsmessage.Message, error) {
message.ID = 0
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
rawMessage, err := message.AppendPack(buffer.Index(0))
if err != nil {
return nil, err
}
buffer.Truncate(len(rawMessage))
request, err := http.NewRequestWithContext(ctx, http.MethodPost, t.destination, bytes.NewReader(buffer.Bytes()))
if err != nil {
return nil, err
}
request.Header.Set("content-type", dnsMimeType)
request.Header.Set("accept", dnsMimeType)
client := &http.Client{Transport: t.transport}
response, err := client.Do(request)
if err != nil {
return nil, err
}
defer response.Body.Close()
buffer.FullReset()
_, err = buffer.ReadAllFrom(response.Body)
if err != nil {
return nil, err
}
var responseMessage dnsmessage.Message
err = responseMessage.Unpack(buffer.Bytes())
if err != nil {
return nil, err
}
return &responseMessage, nil
}
func (t *HTTPSTransport) Lookup(ctx context.Context, domain string, strategy C.DomainStrategy) ([]netip.Addr, error) {
return nil, os.ErrInvalid
}

79
dns/transport_local.go
View File

@@ -1,79 +0,0 @@
package dns
import (
"context"
"net"
"net/netip"
"os"
"sort"
"github.com/sagernet/sing-box/adapter"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing/common"
"golang.org/x/net/dns/dnsmessage"
)
var LocalTransportConstructor func() adapter.DNSTransport
func NewLocalTransport() adapter.DNSTransport {
if LocalTransportConstructor != nil {
return LocalTransportConstructor()
}
return &LocalTransport{}
}
var _ adapter.DNSTransport = (*LocalTransport)(nil)
type LocalTransport struct {
resolver net.Resolver
}
func (t *LocalTransport) Start() error {
return nil
}
func (t *LocalTransport) Close() error {
return nil
}
func (t *LocalTransport) Raw() bool {
return false
}
func (t *LocalTransport) Exchange(ctx context.Context, message *dnsmessage.Message) (*dnsmessage.Message, error) {
return nil, os.ErrInvalid
}
func (t *LocalTransport) Lookup(ctx context.Context, domain string, strategy C.DomainStrategy) ([]netip.Addr, error) {
var network string
switch strategy {
case C.DomainStrategyAsIS, C.DomainStrategyPreferIPv4, C.DomainStrategyPreferIPv6:
network = "ip"
case C.DomainStrategyUseIPv4:
network = "ip4"
case C.DomainStrategyUseIPv6:
network = "ip6"
}
addrs, err := t.resolver.LookupNetIP(ctx, network, domain)
if err != nil {
return nil, err
}
addrs = common.Map(addrs, func(it netip.Addr) netip.Addr {
if it.Is4In6() {
return netip.AddrFrom4(it.As4())
}
return it
})
switch strategy {
case C.DomainStrategyPreferIPv4:
sort.Slice(addrs, func(i, j int) bool {
return addrs[i].Is4() && addrs[j].Is6()
})
case C.DomainStrategyPreferIPv6:
sort.Slice(addrs, func(i, j int) bool {
return addrs[i].Is6() && addrs[j].Is4()
})
}
return addrs, nil
}

183
dns/transport_tcp.go
View File

@@ -1,183 +0,0 @@
package dns
import (
"context"
"encoding/binary"
"net"
"os"
"sync"
"github.com/sagernet/sing-box/adapter"
"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"
"github.com/sagernet/sing/common/task"
"golang.org/x/net/dns/dnsmessage"
)
var _ adapter.DNSTransport = (*TCPTransport)(nil)
type TCPTransport struct {
myTransportAdapter
}
func NewTCPTransport(ctx context.Context, dialer N.Dialer, logger log.Logger, destination M.Socksaddr) *TCPTransport {
return &TCPTransport{
myTransportAdapter{
ctx: ctx,
dialer: dialer,
logger: logger,
destination: destination,
done: make(chan struct{}),
},
}
}
func (t *TCPTransport) offer() (*dnsConnection, error) {
t.access.RLock()
connection := t.connection
t.access.RUnlock()
if connection != nil {
select {
case <-connection.done:
default:
return connection, nil
}
}
t.access.Lock()
connection = t.connection
if connection != nil {
select {
case <-connection.done:
default:
t.access.Unlock()
return connection, nil
}
}
tcpConn, err := t.dialer.DialContext(t.ctx, "tcp", t.destination)
if err != nil {
return nil, err
}
connection = &dnsConnection{
Conn: tcpConn,
done: make(chan struct{}),
callbacks: make(map[uint16]chan *dnsmessage.Message),
}
t.connection = connection
t.access.Unlock()
go t.newConnection(connection)
return connection, nil
}
func (t *TCPTransport) newConnection(conn *dnsConnection) {
defer close(conn.done)
defer conn.Close()
err := task.Any(t.ctx, func(ctx context.Context) error {
return t.loopIn(conn)
}, func(ctx context.Context) error {
select {
case <-ctx.Done():
return nil
case <-t.done:
return os.ErrClosed
}
})
conn.err = err
if err != nil && !E.IsClosed(err) {
t.logger.Debug("connection closed: ", err)
}
}
func (t *TCPTransport) loopIn(conn *dnsConnection) error {
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
for {
buffer.FullReset()
_, err := buffer.ReadFullFrom(conn, 2)
if err != nil {
return err
}
length := binary.BigEndian.Uint16(buffer.Bytes())
if length > 512 {
return E.New("invalid length received: ", length)
}
buffer.FullReset()
_, err = buffer.ReadFullFrom(conn, int(length))
if err != nil {
return err
}
var message dnsmessage.Message
err = message.Unpack(buffer.Bytes())
if err != nil {
return err
}
conn.access.Lock()
callback, loaded := conn.callbacks[message.ID]
if loaded {
delete(conn.callbacks, message.ID)
}
conn.access.Unlock()
if !loaded {
continue
}
callback <- &message
}
}
type dnsConnection struct {
net.Conn
done chan struct{}
err error
access sync.Mutex
queryId uint16
callbacks map[uint16]chan *dnsmessage.Message
}
func (t *TCPTransport) Exchange(ctx context.Context, message *dnsmessage.Message) (*dnsmessage.Message, error) {
var connection *dnsConnection
err := task.Run(ctx, func() error {
var innerErr error
connection, innerErr = t.offer()
return innerErr
})
if err != nil {
return nil, err
}
connection.access.Lock()
connection.queryId++
message.ID = connection.queryId
callback := make(chan *dnsmessage.Message)
connection.callbacks[message.ID] = callback
connection.access.Unlock()
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
length := buffer.Extend(2)
rawMessage, err := message.AppendPack(buffer.Index(2))
if err != nil {
return nil, err
}
buffer.Truncate(2 + len(rawMessage))
binary.BigEndian.PutUint16(length, uint16(len(rawMessage)))
err = task.Run(ctx, func() error {
return common.Error(connection.Write(buffer.Bytes()))
})
if err != nil {
return nil, err
}
select {
case response := <-callback:
return response, nil
case <-connection.done:
return nil, connection.err
case <-ctx.Done():
return nil, ctx.Err()
}
}

93
dns/transport_test.go
View File

@@ -1,93 +0,0 @@
package dns_test
import (
"context"
"testing"
"time"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/dns"
"github.com/sagernet/sing-box/log"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
"github.com/stretchr/testify/require"
"golang.org/x/net/dns/dnsmessage"
)
func TestTCPDNS(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
transport := dns.NewTCPTransport(ctx, N.SystemDialer, log.NewNopLogger(), M.ParseSocksaddr("1.0.0.1:53"))
response, err := transport.Exchange(ctx, makeQuery())
cancel()
require.NoError(t, err)
require.NotEmpty(t, response.Answers, "no answers")
for _, answer := range response.Answers {
t.Log(answer)
}
}
func TestTLSDNS(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
transport := dns.NewTLSTransport(ctx, N.SystemDialer, log.NewNopLogger(), M.ParseSocksaddr("1.0.0.1:853"))
response, err := transport.Exchange(ctx, makeQuery())
cancel()
require.NoError(t, err)
require.NotEmpty(t, response.Answers, "no answers")
for _, answer := range response.Answers {
t.Log(answer)
}
}
func TestHTTPSDNS(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
transport := dns.NewHTTPSTransport(N.SystemDialer, "https://1.0.0.1:443/dns-query")
response, err := transport.Exchange(ctx, makeQuery())
cancel()
require.NoError(t, err)
require.NotEmpty(t, response.Answers, "no answers")
for _, answer := range response.Answers {
t.Log(answer)
}
}
func TestUDPDNS(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
transport := dns.NewUDPTransport(ctx, N.SystemDialer, log.NewNopLogger(), M.ParseSocksaddr("1.0.0.1:53"))
response, err := transport.Exchange(ctx, makeQuery())
cancel()
require.NoError(t, err)
require.NotEmpty(t, response.Answers, "no answers")
for _, answer := range response.Answers {
t.Log(answer)
}
}
func TestLocalDNS(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
transport := dns.NewLocalTransport()
response, err := transport.Lookup(ctx, "google.com", C.DomainStrategyAsIS)
cancel()
require.NoError(t, err)
require.NotEmpty(t, response, "no answers")
for _, answer := range response {
t.Log(answer)
}
}
func makeQuery() *dnsmessage.Message {
message := &dnsmessage.Message{}
message.Header.ID = 1
message.Header.RecursionDesired = true
message.Questions = append(message.Questions, dnsmessage.Question{
Name: dnsmessage.MustNewName("google.com."),
Type: dnsmessage.TypeA,
Class: dnsmessage.ClassINET,
})
return message
}

182
dns/transport_tls.go
View File

@@ -1,182 +0,0 @@
package dns
import (
"context"
"crypto/tls"
"encoding/binary"
"os"
"github.com/sagernet/sing-box/adapter"
"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"
"github.com/sagernet/sing/common/task"
"golang.org/x/net/dns/dnsmessage"
)
var _ adapter.DNSTransport = (*TLSTransport)(nil)
type TLSTransport struct {
myTransportAdapter
}
func NewTLSTransport(ctx context.Context, dialer N.Dialer, logger log.Logger, destination M.Socksaddr) *TLSTransport {
return &TLSTransport{
myTransportAdapter{
ctx: ctx,
dialer: dialer,
logger: logger,
destination: destination,
done: make(chan struct{}),
},
}
}
func (t *TLSTransport) offer(ctx context.Context) (*dnsConnection, error) {
t.access.RLock()
connection := t.connection
t.access.RUnlock()
if connection != nil {
select {
case <-connection.done:
default:
return connection, nil
}
}
t.access.Lock()
connection = t.connection
if connection != nil {
select {
case <-connection.done:
default:
t.access.Unlock()
return connection, nil
}
}
tcpConn, err := t.dialer.DialContext(t.ctx, "tcp", t.destination)
if err != nil {
return nil, err
}
tlsConn := tls.Client(tcpConn, &tls.Config{
ServerName: t.destination.AddrString(),
})
err = task.Run(t.ctx, func() error {
return tlsConn.HandshakeContext(ctx)
})
if err != nil {
return nil, err
}
connection = &dnsConnection{
Conn: tlsConn,
done: make(chan struct{}),
callbacks: make(map[uint16]chan *dnsmessage.Message),
}
t.connection = connection
t.access.Unlock()
go t.newConnection(connection)
return connection, nil
}
func (t *TLSTransport) newConnection(conn *dnsConnection) {
defer close(conn.done)
defer conn.Close()
err := task.Any(t.ctx, func(ctx context.Context) error {
return t.loopIn(conn)
}, func(ctx context.Context) error {
select {
case <-ctx.Done():
return nil
case <-t.done:
return os.ErrClosed
}
})
conn.err = err
if err != nil && !E.IsClosed(err) {
t.logger.Debug("connection closed: ", err)
}
}
func (t *TLSTransport) loopIn(conn *dnsConnection) error {
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
for {
buffer.FullReset()
_, err := buffer.ReadFullFrom(conn, 2)
if err != nil {
return err
}
length := binary.BigEndian.Uint16(buffer.Bytes())
if length > 512 {
return E.New("invalid length received: ", length)
}
buffer.FullReset()
_, err = buffer.ReadFullFrom(conn, int(length))
if err != nil {
return err
}
var message dnsmessage.Message
err = message.Unpack(buffer.Bytes())
if err != nil {
return err
}
conn.access.Lock()
callback, loaded := conn.callbacks[message.ID]
if loaded {
delete(conn.callbacks, message.ID)
}
conn.access.Unlock()
if !loaded {
continue
}
callback <- &message
}
}
func (t *TLSTransport) Exchange(ctx context.Context, message *dnsmessage.Message) (*dnsmessage.Message, error) {
var connection *dnsConnection
err := task.Run(ctx, func() error {
var innerErr error
connection, innerErr = t.offer(ctx)
return innerErr
})
if err != nil {
return nil, err
}
connection.access.Lock()
connection.queryId++
message.ID = connection.queryId
callback := make(chan *dnsmessage.Message)
connection.callbacks[message.ID] = callback
connection.access.Unlock()
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
length := buffer.Extend(2)
rawMessage, err := message.AppendPack(buffer.Index(2))
if err != nil {
return nil, err
}
buffer.Truncate(2 + len(rawMessage))
binary.BigEndian.PutUint16(length, uint16(len(rawMessage)))
err = task.Run(ctx, func() error {
return common.Error(connection.Write(buffer.Bytes()))
})
if err != nil {
return nil, err
}
select {
case response := <-callback:
return response, nil
case <-connection.done:
return nil, connection.err
case <-ctx.Done():
return nil, ctx.Err()
}
}

160
dns/transport_udp.go
View File

@@ -1,160 +0,0 @@
package dns
import (
"context"
"os"
"github.com/sagernet/sing-box/adapter"
"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"
"github.com/sagernet/sing/common/task"
"golang.org/x/net/dns/dnsmessage"
)
var _ adapter.DNSTransport = (*UDPTransport)(nil)
type UDPTransport struct {
myTransportAdapter
}
func NewUDPTransport(ctx context.Context, dialer N.Dialer, logger log.Logger, destination M.Socksaddr) *UDPTransport {
return &UDPTransport{
myTransportAdapter{
ctx: ctx,
dialer: dialer,
logger: logger,
destination: destination,
done: make(chan struct{}),
},
}
}
func (t *UDPTransport) offer() (*dnsConnection, error) {
t.access.RLock()
connection := t.connection
t.access.RUnlock()
if connection != nil {
select {
case <-connection.done:
default:
return connection, nil
}
}
t.access.Lock()
connection = t.connection
if connection != nil {
select {
case <-connection.done:
default:
t.access.Unlock()
return connection, nil
}
}
tcpConn, err := t.dialer.DialContext(t.ctx, "udp", t.destination)
if err != nil {
return nil, err
}
connection = &dnsConnection{
Conn: tcpConn,
done: make(chan struct{}),
callbacks: make(map[uint16]chan *dnsmessage.Message),
}
t.connection = connection
t.access.Unlock()
go t.newConnection(connection)
return connection, nil
}
func (t *UDPTransport) newConnection(conn *dnsConnection) {
defer close(conn.done)
defer conn.Close()
err := task.Any(t.ctx, func(ctx context.Context) error {
return t.loopIn(conn)
}, func(ctx context.Context) error {
select {
case <-ctx.Done():
return nil
case <-t.done:
return os.ErrClosed
}
})
conn.err = err
if err != nil && !E.IsClosed(err) {
t.logger.Debug("connection closed: ", err)
}
}
func (t *UDPTransport) loopIn(conn *dnsConnection) error {
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
for {
buffer.FullReset()
_, err := buffer.ReadFrom(conn)
if err != nil {
return err
}
var message dnsmessage.Message
err = message.Unpack(buffer.Bytes())
if err != nil {
return err
}
conn.access.Lock()
callback, loaded := conn.callbacks[message.ID]
if loaded {
delete(conn.callbacks, message.ID)
}
conn.access.Unlock()
if !loaded {
continue
}
callback <- &message
}
}
func (t *UDPTransport) Exchange(ctx context.Context, message *dnsmessage.Message) (*dnsmessage.Message, error) {
var connection *dnsConnection
err := task.Run(ctx, func() error {
var innerErr error
connection, innerErr = t.offer()
return innerErr
})
if err != nil {
return nil, err
}
connection.access.Lock()
connection.queryId++
message.ID = connection.queryId
callback := make(chan *dnsmessage.Message)
connection.callbacks[message.ID] = callback
connection.access.Unlock()
_buffer := buf.StackNewSize(1024)
defer common.KeepAlive(_buffer)
buffer := common.Dup(_buffer)
defer buffer.Release()
rawMessage, err := message.AppendPack(buffer.Index(0))
if err != nil {
return nil, err
}
buffer.Truncate(len(rawMessage))
err = task.Run(ctx, func() error {
return common.Error(connection.Write(buffer.Bytes()))
})
if err != nil {
return nil, err
}
select {
case response := <-callback:
return response, nil
case <-connection.done:
return nil, connection.err
case <-ctx.Done():
return nil, ctx.Err()
}
}