go-gost/x
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add HTTP plugin

Browse Source
This commit is contained in:
ginuerzh
2023-09-20 22:56:43 +08:00
parent afddd2d29e
commit 1760151500
29 changed files with 1032 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
resolver/plugin.go
View File

@ -1,14 +1,20 @@
package resolver
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"github.com/go-gost/core/logger"
resolver_pkg "github.com/go-gost/core/resolver"
"github.com/go-gost/core/resolver"
"github.com/go-gost/plugin/resolver/proto"
auth_util "github.com/go-gost/x/internal/util/auth"
"github.com/go-gost/x/internal/util/plugin"
"google.golang.org/grpc"
)
@ -19,13 +25,23 @@ type grpcPluginResolver struct {
}
// NewGRPCPluginResolver creates a Resolver plugin based on gRPC.
func NewGRPCPluginResolver(name string, conn grpc.ClientConnInterface) (resolver_pkg.Resolver, error) {
func NewGRPCPluginResolver(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 := &grpcPluginResolver{
conn: conn,
log: logger.Default().WithFields(map[string]any{
"kind": "resolver",
"resolver": name,
}),
log: log,
}
if conn != nil {
p.client = proto.NewResolverClient(conn)
@ -64,3 +80,93 @@ func (p *grpcPluginResolver) Close() error {
}
return nil
}
type httpResolverRequest struct {
Network string `json:"network"`
Host string `json:"host"`
Client string `json:"client"`
}
type httpResolverResponse struct {
IPs []string `json:"ips"`
OK bool `json:"ok"`
}
type httpPluginResolver struct {
url string
client *http.Client
header http.Header
log logger.Logger
}
// NewHTTPPluginResolver creates an Resolver plugin based on HTTP.
func NewHTTPPluginResolver(name string, url string, opts ...plugin.Option) resolver.Resolver {
var options plugin.Options
for _, opt := range opts {
opt(&options)
}
return &httpPluginResolver{
url: url,
client: plugin.NewHTTPClient(&options),
header: options.Header,
log: logger.Default().WithFields(map[string]any{
"kind": "resolver",
"resolver": name,
}),
}
}
func (p *httpPluginResolver) Resolve(ctx context.Context, network, host string) (ips []net.IP, err error) {
p.log.Debugf("resolve %s/%s", host, network)
if p.client == nil {
return
}
rb := httpResolverRequest{
Network: network,
Host: host,
Client: string(auth_util.IDFromContext(ctx)),
}
v, err := json.Marshal(&rb)
if err != nil {
return
}
req, err := http.NewRequest(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 := httpResolverResponse{}
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
}

20
resolver/resolver.go
View File

@ -8,7 +8,7 @@ import (
"github.com/go-gost/core/chain"
"github.com/go-gost/core/logger"
resolverpkg "github.com/go-gost/core/resolver"
"github.com/go-gost/core/resolver"
resolver_util "github.com/go-gost/x/internal/util/resolver"
"github.com/go-gost/x/resolver/exchanger"
"github.com/miekg/dns"
@ -52,13 +52,13 @@ func LoggerOption(logger logger.Logger) Option {
}
}
type resolver struct {
type localResolver struct {
servers []NameServer
cache *resolver_util.Cache
options options
}
func NewResolver(nameservers []NameServer, opts ...Option) (resolverpkg.Resolver, error) {
func NewResolver(nameservers []NameServer, opts ...Option) (resolver.Resolver, error) {
options := options{}
for _, opt := range opts {
opt(&options)
@ -92,14 +92,14 @@ func NewResolver(nameservers []NameServer, opts ...Option) (resolverpkg.Resolver
cache := resolver_util.NewCache().
WithLogger(options.logger)
return &resolver{
return &localResolver{
servers: servers,
cache: cache,
options: options,
}, nil
}
func (r *resolver) Resolve(ctx context.Context, network, host string) (ips []net.IP, err error) {
func (r *localResolver) Resolve(ctx context.Context, network, host string) (ips []net.IP, err error) {
if ip := net.ParseIP(host); ip != nil {
return []net.IP{ip}, nil
}
@ -126,7 +126,7 @@ func (r *resolver) Resolve(ctx context.Context, network, host string) (ips []net
return
}
func (r *resolver) resolve(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
func (r *localResolver) resolve(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
if server == nil {
return
}
@ -144,19 +144,19 @@ func (r *resolver) resolve(ctx context.Context, server *NameServer, host string)
return r.resolve6(ctx, server, host)
}
func (r *resolver) resolve4(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
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 *resolver) resolve6(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
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 *resolver) resolveIPs(ctx context.Context, server *NameServer, mq *dns.Msg) (ips []net.IP, err error) {
func (r *localResolver) resolveIPs(ctx context.Context, server *NameServer, mq *dns.Msg) (ips []net.IP, err error) {
key := resolver_util.NewCacheKey(&mq.Question[0])
mr, ttl := r.cache.Load(key)
if ttl <= 0 {
@ -180,7 +180,7 @@ func (r *resolver) resolveIPs(ctx context.Context, server *NameServer, mq *dns.M
return
}
func (r *resolver) exchange(ctx context.Context, ex exchanger.Exchanger, mq *dns.Msg) (mr *dns.Msg, err error) {
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