mirror of
https://github.com/Sagit-chu/flvx.git
synced 2026-10-10 19:36:36 +08:00
init
This commit is contained in:
qaq
@@ -0,0 +1,227 @@
|
||||
package exchanger
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-gost/core/chain"
|
||||
"github.com/go-gost/core/logger"
|
||||
xchain "github.com/go-gost/x/chain"
|
||||
"github.com/miekg/dns"
|
||||
)
|
||||
|
||||
type Options struct {
|
||||
router chain.Router
|
||||
tlsConfig *tls.Config
|
||||
timeout time.Duration
|
||||
logger logger.Logger
|
||||
}
|
||||
|
||||
// Option allows a common way to set Exchanger options.
|
||||
type Option func(opts *Options)
|
||||
|
||||
// RouterOption sets the router for Exchanger.
|
||||
func RouterOption(router chain.Router) Option {
|
||||
return func(opts *Options) {
|
||||
opts.router = router
|
||||
}
|
||||
}
|
||||
|
||||
// TLSConfigOption sets the TLS config for Exchanger.
|
||||
func TLSConfigOption(cfg *tls.Config) Option {
|
||||
return func(opts *Options) {
|
||||
opts.tlsConfig = cfg
|
||||
}
|
||||
}
|
||||
|
||||
// LoggerOption sets the logger for Exchanger.
|
||||
func LoggerOption(logger logger.Logger) Option {
|
||||
return func(opts *Options) {
|
||||
opts.logger = logger
|
||||
}
|
||||
}
|
||||
|
||||
// TimeoutOption sets the timeout for Exchanger.
|
||||
func TimeoutOption(timeout time.Duration) Option {
|
||||
return func(opts *Options) {
|
||||
opts.timeout = timeout
|
||||
}
|
||||
}
|
||||
|
||||
// Exchanger is an interface for DNS synchronous query.
|
||||
type Exchanger interface {
|
||||
Exchange(ctx context.Context, msg []byte) ([]byte, error)
|
||||
String() string
|
||||
}
|
||||
|
||||
type exchanger struct {
|
||||
network string
|
||||
addr string
|
||||
rawAddr string
|
||||
router chain.Router
|
||||
client *http.Client
|
||||
options Options
|
||||
}
|
||||
|
||||
// NewExchanger create an Exchanger.
|
||||
// The addr should be URL-like format,
|
||||
// e.g. udp://1.1.1.1:53, tls://1.1.1.1:853, https://1.0.0.1/dns-query
|
||||
func NewExchanger(addr string, opts ...Option) (Exchanger, error) {
|
||||
var options Options
|
||||
for _, opt := range opts {
|
||||
opt(&options)
|
||||
}
|
||||
|
||||
if !strings.Contains(addr, "://") {
|
||||
addr = "udp://" + addr
|
||||
}
|
||||
u, err := url.Parse(addr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if options.timeout <= 0 {
|
||||
options.timeout = 5 * time.Second
|
||||
}
|
||||
|
||||
ex := &exchanger{
|
||||
network: u.Scheme,
|
||||
addr: u.Host,
|
||||
rawAddr: addr,
|
||||
router: options.router,
|
||||
options: options,
|
||||
}
|
||||
if _, port, _ := net.SplitHostPort(ex.addr); port == "" {
|
||||
ex.addr = net.JoinHostPort(ex.addr, "53")
|
||||
}
|
||||
if ex.router == nil {
|
||||
ex.router = xchain.NewRouter(chain.LoggerRouterOption(options.logger))
|
||||
}
|
||||
|
||||
switch ex.network {
|
||||
case "tcp":
|
||||
case "dot", "tls":
|
||||
if ex.options.tlsConfig == nil {
|
||||
ex.options.tlsConfig = &tls.Config{
|
||||
InsecureSkipVerify: true,
|
||||
}
|
||||
}
|
||||
ex.network = "tcp"
|
||||
case "https":
|
||||
ex.addr = addr
|
||||
if ex.options.tlsConfig == nil {
|
||||
ex.options.tlsConfig = &tls.Config{
|
||||
InsecureSkipVerify: true,
|
||||
}
|
||||
}
|
||||
ex.client = &http.Client{
|
||||
Timeout: options.timeout,
|
||||
Transport: &http.Transport{
|
||||
TLSClientConfig: options.tlsConfig,
|
||||
ForceAttemptHTTP2: true,
|
||||
MaxIdleConns: 100,
|
||||
IdleConnTimeout: 90 * time.Second,
|
||||
TLSHandshakeTimeout: options.timeout,
|
||||
ExpectContinueTimeout: 1 * time.Second,
|
||||
DialContext: ex.dial,
|
||||
},
|
||||
}
|
||||
default:
|
||||
ex.network = "udp"
|
||||
}
|
||||
|
||||
return ex, nil
|
||||
}
|
||||
|
||||
func (ex *exchanger) Exchange(ctx context.Context, msg []byte) ([]byte, error) {
|
||||
if ex.network == "https" {
|
||||
return ex.dohExchange(ctx, msg)
|
||||
}
|
||||
return ex.exchange(ctx, msg)
|
||||
}
|
||||
|
||||
func (ex *exchanger) dohExchange(ctx context.Context, msg []byte) ([]byte, error) {
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", ex.addr, bytes.NewBuffer(msg))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create an HTTPS request: %w", err)
|
||||
}
|
||||
|
||||
// req.Header.Add("Content-Type", "application/dns-udpwireformat")
|
||||
req.Header.Add("Content-Type", "application/dns-message")
|
||||
|
||||
client := ex.client
|
||||
if client == nil {
|
||||
client = http.DefaultClient
|
||||
}
|
||||
resp, err := client.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to perform an HTTPS request: %w", err)
|
||||
}
|
||||
|
||||
// Check response status code
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return nil, fmt.Errorf("returned status code %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
// Read wireformat response from the body
|
||||
buf, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read the response body: %w", err)
|
||||
}
|
||||
|
||||
return buf, nil
|
||||
}
|
||||
|
||||
func (ex *exchanger) exchange(ctx context.Context, msg []byte) ([]byte, error) {
|
||||
if ex.options.timeout > 0 {
|
||||
var cancel context.CancelFunc
|
||||
ctx, cancel = context.WithTimeout(ctx, ex.options.timeout)
|
||||
defer cancel()
|
||||
}
|
||||
|
||||
c, err := ex.dial(ctx, ex.network, ex.addr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer c.Close()
|
||||
|
||||
if ex.options.tlsConfig != nil {
|
||||
c = tls.Client(c, ex.options.tlsConfig)
|
||||
}
|
||||
if ex.options.timeout > 0 {
|
||||
c.SetDeadline(time.Now().Add(ex.options.timeout))
|
||||
}
|
||||
|
||||
conn := &dns.Conn{
|
||||
UDPSize: 1024,
|
||||
Conn: c,
|
||||
}
|
||||
|
||||
if _, err = conn.Write(msg); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
mr, err := conn.ReadMsg()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return mr.Pack()
|
||||
}
|
||||
|
||||
func (ex *exchanger) dial(ctx context.Context, network, address string) (net.Conn, error) {
|
||||
return ex.router.Dial(ctx, network, address)
|
||||
}
|
||||
|
||||
func (ex *exchanger) String() string {
|
||||
return ex.rawAddr
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package resolver
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"net"
|
||||
|
||||
"github.com/go-gost/core/logger"
|
||||
"github.com/go-gost/core/resolver"
|
||||
"github.com/go-gost/plugin/resolver/proto"
|
||||
ctxvalue "github.com/go-gost/x/ctx"
|
||||
"github.com/go-gost/x/internal/plugin"
|
||||
"google.golang.org/grpc"
|
||||
)
|
||||
|
||||
type grpcPlugin struct {
|
||||
conn grpc.ClientConnInterface
|
||||
client proto.ResolverClient
|
||||
log logger.Logger
|
||||
}
|
||||
|
||||
// NewGRPCPlugin creates a Resolver plugin based on gRPC.
|
||||
func NewGRPCPlugin(name string, addr string, opts ...plugin.Option) (resolver.Resolver, error) {
|
||||
var options plugin.Options
|
||||
for _, opt := range opts {
|
||||
opt(&options)
|
||||
}
|
||||
|
||||
log := logger.Default().WithFields(map[string]any{
|
||||
"kind": "resolver",
|
||||
"resolover": name,
|
||||
})
|
||||
conn, err := plugin.NewGRPCConn(addr, &options)
|
||||
if err != nil {
|
||||
log.Error(err)
|
||||
}
|
||||
p := &grpcPlugin{
|
||||
conn: conn,
|
||||
log: log,
|
||||
}
|
||||
if conn != nil {
|
||||
p.client = proto.NewResolverClient(conn)
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
|
||||
func (p *grpcPlugin) Resolve(ctx context.Context, network, host string, opts ...resolver.Option) (ips []net.IP, err error) {
|
||||
p.log.Debugf("resolve %s/%s", host, network)
|
||||
|
||||
if p.client == nil {
|
||||
return
|
||||
}
|
||||
|
||||
r, err := p.client.Resolve(ctx,
|
||||
&proto.ResolveRequest{
|
||||
Network: network,
|
||||
Host: host,
|
||||
Client: string(ctxvalue.ClientIDFromContext(ctx)),
|
||||
})
|
||||
if err != nil {
|
||||
p.log.Error(err)
|
||||
return
|
||||
}
|
||||
for _, s := range r.Ips {
|
||||
if ip := net.ParseIP(s); ip != nil {
|
||||
ips = append(ips, ip)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (p *grpcPlugin) Close() error {
|
||||
if p.conn == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
if closer, ok := p.conn.(io.Closer); ok {
|
||||
return closer.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
package resolver
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/http"
|
||||
|
||||
"github.com/go-gost/core/logger"
|
||||
"github.com/go-gost/core/resolver"
|
||||
ctxvalue "github.com/go-gost/x/ctx"
|
||||
"github.com/go-gost/x/internal/plugin"
|
||||
)
|
||||
|
||||
type httpPluginRequest struct {
|
||||
Network string `json:"network"`
|
||||
Host string `json:"host"`
|
||||
Client string `json:"client"`
|
||||
}
|
||||
|
||||
type httpPluginResponse struct {
|
||||
IPs []string `json:"ips"`
|
||||
OK bool `json:"ok"`
|
||||
}
|
||||
|
||||
type httpPlugin struct {
|
||||
url string
|
||||
client *http.Client
|
||||
header http.Header
|
||||
log logger.Logger
|
||||
}
|
||||
|
||||
// NewHTTPPlugin creates an Resolver plugin based on HTTP.
|
||||
func NewHTTPPlugin(name string, url string, opts ...plugin.Option) resolver.Resolver {
|
||||
var options plugin.Options
|
||||
for _, opt := range opts {
|
||||
opt(&options)
|
||||
}
|
||||
|
||||
return &httpPlugin{
|
||||
url: url,
|
||||
client: plugin.NewHTTPClient(&options),
|
||||
header: options.Header,
|
||||
log: logger.Default().WithFields(map[string]any{
|
||||
"kind": "resolver",
|
||||
"resolver": name,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
func (p *httpPlugin) Resolve(ctx context.Context, network, host string, opts ...resolver.Option) (ips []net.IP, err error) {
|
||||
p.log.Debugf("resolve %s/%s", host, network)
|
||||
|
||||
if p.client == nil {
|
||||
return
|
||||
}
|
||||
|
||||
rb := httpPluginRequest{
|
||||
Network: network,
|
||||
Host: host,
|
||||
Client: string(ctxvalue.ClientIDFromContext(ctx)),
|
||||
}
|
||||
v, err := json.Marshal(&rb)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, p.url, bytes.NewReader(v))
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if p.header != nil {
|
||||
req.Header = p.header.Clone()
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
resp, err := p.client.Do(req)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
err = fmt.Errorf("%s", resp.Status)
|
||||
return
|
||||
}
|
||||
|
||||
res := httpPluginResponse{}
|
||||
if err = json.NewDecoder(resp.Body).Decode(&res); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
if !res.OK {
|
||||
return nil, errors.New("resolve failed")
|
||||
}
|
||||
|
||||
for _, s := range res.IPs {
|
||||
if ip := net.ParseIP(s); ip != nil {
|
||||
ips = append(ips, ip)
|
||||
}
|
||||
}
|
||||
return ips, nil
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
package resolver
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-gost/core/chain"
|
||||
"github.com/go-gost/core/logger"
|
||||
"github.com/go-gost/core/resolver"
|
||||
xchain "github.com/go-gost/x/chain"
|
||||
resolver_util "github.com/go-gost/x/internal/util/resolver"
|
||||
"github.com/go-gost/x/resolver/exchanger"
|
||||
"github.com/miekg/dns"
|
||||
)
|
||||
|
||||
type NameServer struct {
|
||||
Addr string
|
||||
Chain chain.Chainer
|
||||
TTL time.Duration
|
||||
Timeout time.Duration
|
||||
ClientIP net.IP
|
||||
Prefer string
|
||||
Hostname string // for TLS handshake verification
|
||||
Async bool
|
||||
Only string
|
||||
exchanger exchanger.Exchanger
|
||||
}
|
||||
|
||||
type options struct {
|
||||
domain string
|
||||
logger logger.Logger
|
||||
}
|
||||
|
||||
type Option func(opts *options)
|
||||
|
||||
func DomainOption(domain string) Option {
|
||||
return func(opts *options) {
|
||||
opts.domain = domain
|
||||
}
|
||||
}
|
||||
|
||||
func LoggerOption(logger logger.Logger) Option {
|
||||
return func(opts *options) {
|
||||
opts.logger = logger
|
||||
}
|
||||
}
|
||||
|
||||
type localResolver struct {
|
||||
servers []NameServer
|
||||
cache *resolver_util.Cache
|
||||
options options
|
||||
}
|
||||
|
||||
func NewResolver(nameservers []NameServer, opts ...Option) (resolver.Resolver, error) {
|
||||
options := options{}
|
||||
for _, opt := range opts {
|
||||
opt(&options)
|
||||
}
|
||||
|
||||
var servers []NameServer
|
||||
for _, server := range nameservers {
|
||||
addr := strings.TrimSpace(server.Addr)
|
||||
if addr == "" {
|
||||
continue
|
||||
}
|
||||
ex, err := exchanger.NewExchanger(
|
||||
addr,
|
||||
exchanger.RouterOption(
|
||||
xchain.NewRouter(
|
||||
chain.ChainRouterOption(server.Chain),
|
||||
chain.LoggerRouterOption(options.logger),
|
||||
),
|
||||
),
|
||||
exchanger.TimeoutOption(server.Timeout),
|
||||
exchanger.LoggerOption(options.logger),
|
||||
)
|
||||
if err != nil {
|
||||
options.logger.Warnf("parse %s: %v", server, err)
|
||||
continue
|
||||
}
|
||||
|
||||
server.exchanger = ex
|
||||
|
||||
switch server.Only {
|
||||
case "ip4", "ipv4", "ip6", "ipv6":
|
||||
server.Prefer = server.Only
|
||||
default:
|
||||
server.Only = ""
|
||||
}
|
||||
if server.TTL < 0 {
|
||||
server.Async = false
|
||||
}
|
||||
servers = append(servers, server)
|
||||
}
|
||||
cache := resolver_util.NewCache().
|
||||
WithLogger(options.logger)
|
||||
|
||||
return &localResolver{
|
||||
servers: servers,
|
||||
cache: cache,
|
||||
options: options,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (r *localResolver) Resolve(ctx context.Context, network, host string, opts ...resolver.Option) (ips []net.IP, err error) {
|
||||
if ip := net.ParseIP(host); ip != nil {
|
||||
return []net.IP{ip}, nil
|
||||
}
|
||||
|
||||
if r.options.domain != "" &&
|
||||
!strings.Contains(host, ".") {
|
||||
host = host + "." + r.options.domain
|
||||
}
|
||||
|
||||
for _, server := range r.servers {
|
||||
if server.Async {
|
||||
ips, err = r.resolveAsync(ctx, &server, host)
|
||||
} else {
|
||||
ips, err = r.resolve(ctx, &server, host)
|
||||
}
|
||||
if err != nil {
|
||||
r.options.logger.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
r.options.logger.Debugf("resolve %s via %s: %v", host, server.exchanger.String(), ips)
|
||||
|
||||
if len(ips) > 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (r *localResolver) resolve(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
|
||||
if server == nil {
|
||||
return
|
||||
}
|
||||
|
||||
if server.Prefer == "ipv6" { // prefer ipv6
|
||||
if ips, err = r.resolve6(ctx, server, host); len(ips) > 0 || server.Only == "ipv6" {
|
||||
return
|
||||
}
|
||||
return r.resolve4(ctx, server, host)
|
||||
}
|
||||
|
||||
if ips, err = r.resolve4(ctx, server, host); len(ips) > 0 || server.Only == "ipv4" {
|
||||
return
|
||||
}
|
||||
return r.resolve6(ctx, server, host)
|
||||
}
|
||||
|
||||
func (r *localResolver) resolveAsync(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
|
||||
ips, ttl, ok := r.lookupCache(ctx, server, host)
|
||||
if !ok {
|
||||
return r.resolve(ctx, server, host)
|
||||
}
|
||||
|
||||
if ttl <= 0 {
|
||||
r.options.logger.Debugf("async resolve %s via %s", host, server.exchanger.String())
|
||||
go r.resolve(ctx, server, host)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (r *localResolver) lookupCache(ctx context.Context, server *NameServer, host string) (ips []net.IP, ttl time.Duration, ok bool) {
|
||||
lookup := func(t uint16, host string) (ips []net.IP, ttl time.Duration, ok bool) {
|
||||
mq := dns.Msg{}
|
||||
mq.SetQuestion(dns.Fqdn(host), t)
|
||||
mr, ttl := r.cache.Load(ctx, resolver_util.NewCacheKey(&mq.Question[0]))
|
||||
if mr == nil {
|
||||
return
|
||||
}
|
||||
|
||||
ok = true
|
||||
|
||||
for _, ans := range mr.Answer {
|
||||
if ar, _ := ans.(*dns.AAAA); ar != nil {
|
||||
ips = append(ips, ar.AAAA)
|
||||
}
|
||||
if ar, _ := ans.(*dns.A); ar != nil {
|
||||
ips = append(ips, ar.A)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
if server.Prefer == "ipv6" {
|
||||
ips, ttl, ok = lookup(dns.TypeAAAA, host)
|
||||
if len(ips) > 0 || server.Only == "ipv6" {
|
||||
return
|
||||
}
|
||||
|
||||
ips, ttl, ok = lookup(dns.TypeA, host)
|
||||
return
|
||||
}
|
||||
|
||||
ips, ttl, ok = lookup(dns.TypeA, host)
|
||||
if len(ips) > 0 || server.Only == "ipv4" {
|
||||
return
|
||||
}
|
||||
return lookup(dns.TypeAAAA, host)
|
||||
}
|
||||
|
||||
func (r *localResolver) resolve4(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
|
||||
mq := dns.Msg{}
|
||||
mq.SetQuestion(dns.Fqdn(host), dns.TypeA)
|
||||
return r.resolveIPs(ctx, server, &mq)
|
||||
}
|
||||
|
||||
func (r *localResolver) resolve6(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
|
||||
mq := dns.Msg{}
|
||||
mq.SetQuestion(dns.Fqdn(host), dns.TypeAAAA)
|
||||
return r.resolveIPs(ctx, server, &mq)
|
||||
}
|
||||
|
||||
func (r *localResolver) resolveIPs(ctx context.Context, server *NameServer, mq *dns.Msg) (ips []net.IP, err error) {
|
||||
if r.options.logger.IsLevelEnabled(logger.TraceLevel) {
|
||||
r.options.logger.Trace(mq.String())
|
||||
}
|
||||
|
||||
key := resolver_util.NewCacheKey(&mq.Question[0])
|
||||
mr, ttl := r.cache.Load(ctx, key)
|
||||
if ttl <= 0 {
|
||||
resolver_util.AddSubnetOpt(mq, server.ClientIP)
|
||||
mr, err = r.exchange(ctx, server.exchanger, mq)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
r.cache.Store(ctx, key, mr, server.TTL)
|
||||
|
||||
if r.options.logger.IsLevelEnabled(logger.TraceLevel) {
|
||||
r.options.logger.Trace(mr.String())
|
||||
}
|
||||
}
|
||||
|
||||
for _, ans := range mr.Answer {
|
||||
if ar, _ := ans.(*dns.AAAA); ar != nil {
|
||||
ips = append(ips, ar.AAAA)
|
||||
}
|
||||
if ar, _ := ans.(*dns.A); ar != nil {
|
||||
ips = append(ips, ar.A)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (r *localResolver) exchange(ctx context.Context, ex exchanger.Exchanger, mq *dns.Msg) (mr *dns.Msg, err error) {
|
||||
query, err := mq.Pack()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
reply, err := ex.Exchange(ctx, query)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
mr = &dns.Msg{}
|
||||
err = mr.Unpack(reply)
|
||||
|
||||
return
|
||||
}
|
||||
Reference in New Issue
Block a user