1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-22 18:17:52 -05:00
v2fly/app/dns/server.go

90 lines
2.1 KiB
Go
Raw Normal View History

2017-12-19 17:55:09 -05:00
package dns
2016-01-31 11:01:28 -05:00
//go:generate go run $GOPATH/src/v2ray.com/core/common/errors/errorgen/main.go -pkg dns -path App,DNS
2017-04-08 19:43:25 -04:00
2016-01-31 11:01:28 -05:00
import (
2017-01-13 07:41:40 -05:00
"context"
2016-05-16 02:09:28 -04:00
"sync"
2016-01-31 11:01:28 -05:00
"time"
"v2ray.com/core"
2017-01-06 09:32:36 -05:00
"v2ray.com/core/common"
"v2ray.com/core/common/net"
2018-05-27 07:02:29 -04:00
"v2ray.com/core/common/task"
2016-01-31 11:01:28 -05:00
)
2017-12-28 17:19:41 -05:00
type Server struct {
2017-11-14 18:36:14 -05:00
sync.Mutex
2016-05-22 16:30:08 -04:00
hosts map[string]net.IP
2016-05-16 02:09:28 -04:00
servers []NameServer
2018-05-27 07:02:29 -04:00
task *task.Periodic
2016-01-31 11:01:28 -05:00
}
2017-12-28 17:19:41 -05:00
func New(ctx context.Context, config *Config) (*Server, error) {
server := &Server{
2016-05-16 02:09:28 -04:00
servers: make([]NameServer, len(config.NameServers)),
2016-09-20 10:05:35 -04:00
hosts: config.GetInternalHosts(),
2016-05-16 02:09:28 -04:00
}
2018-02-21 11:05:29 -05:00
v := core.MustFromContext(ctx)
if err := v.RegisterFeature((*core.DNSClient)(nil), server); err != nil {
return nil, newError("unable to register DNSClient.").Base(err)
}
for idx, destPB := range config.NameServers {
address := destPB.Address.AsAddress()
if address.Family().IsDomain() && address.Domain() == "localhost" {
server.servers[idx] = &LocalNameServer{}
} else {
dest := destPB.AsDestination()
if dest.Network == net.Network_Unknown {
dest.Network = net.Network_UDP
}
if dest.Network == net.Network_UDP {
2018-06-26 09:04:47 -04:00
server.servers[idx] = NewClassicNameServer(dest, v.Dispatcher())
2016-05-18 11:12:04 -04:00
}
}
}
if len(config.NameServers) == 0 {
server.servers = append(server.servers, &LocalNameServer{})
}
2017-01-13 07:41:40 -05:00
return server, nil
}
2018-02-08 11:00:22 -05:00
// Start implements common.Runnable.
2017-12-28 17:19:41 -05:00
func (s *Server) Start() error {
2018-02-08 11:00:22 -05:00
return s.task.Start()
2017-02-01 15:35:40 -05:00
}
2018-04-03 05:11:54 -04:00
// Close implements common.Closable.
2018-02-08 11:00:22 -05:00
func (s *Server) Close() error {
return s.task.Close()
2017-12-28 17:19:41 -05:00
}
2017-02-01 15:35:40 -05:00
2017-12-28 17:19:41 -05:00
func (s *Server) LookupIP(domain string) ([]net.IP, error) {
2017-04-23 13:16:56 -04:00
if ip, found := s.hosts[domain]; found {
2017-12-19 17:55:09 -05:00
return []net.IP{ip}, nil
2016-05-22 16:30:08 -04:00
}
2018-06-26 09:04:47 -04:00
var lastErr error
2017-04-23 13:16:56 -04:00
for _, server := range s.servers {
2018-06-26 09:04:47 -04:00
ctx, cancel := context.WithTimeout(context.Background(), time.Second*4)
ips, err := server.QueryIP(ctx, domain)
cancel()
if err != nil {
lastErr = err
}
if len(ips) > 0 {
return ips, nil
2016-05-16 02:09:28 -04:00
}
2016-01-31 11:01:28 -05:00
}
2016-05-16 02:09:28 -04:00
2018-06-26 09:04:47 -04:00
return nil, newError("returning nil for domain ", domain).Base(lastErr)
2016-01-31 11:01:28 -05:00
}
2016-10-16 10:04:30 -04:00
func init() {
2017-12-19 17:55:09 -05:00
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
2017-12-28 17:19:41 -05:00
return New(ctx, config.(*Config))
2017-01-13 07:41:40 -05:00
}))
2016-10-16 10:04:30 -04:00
}