// NSRecords returns NS records from etcd.
func (s *server) NSRecords(q dns.Question, name string) (records []dns.RR, extra []dns.RR, err error) {
path, star := msg.PathWithWildcard(name)
r, err := get(s.client, path, true)
if err != nil {
return nil, nil, err
}
if !r.Node.Dir { // single element
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
serv.Key = r.Node.Key
serv.Ttl = ttl
switch {
case ip == nil:
return nil, nil, fmt.Errorf("NS record must be an IP address")
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
return records, extra, nil
}
sx, err := s.loopNodes(&r.Node.Nodes, strings.Split(msg.Path(name), "/"), star, nil)
if err != nil || len(sx) == 0 {
return nil, nil, err
}
for _, serv := range sx {
ip := net.ParseIP(serv.Host)
switch {
case ip == nil:
return nil, nil, fmt.Errorf("NS record must be an IP address")
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewNS(q.Name, serv.Host))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
}
return records, extra, nil
}
func (g *Backend) decode(n *etcd.Node) (*msg.Service, error) {
serv := new(msg.Service)
if err := json.Unmarshal([]byte(n.Value), serv); err != nil {
return nil, err
}
serv.Key = n.Key
serv.Ttl = g.calculateTtl(n, serv)
if serv.Priority == 0 {
serv.Priority = int(g.config.Priority)
}
return serv, nil
}
// loopNodes recursively loops through the nodes and returns all the values. The nodes' keyname
// will be match against any wildcards when star is true.
func (g *Backend) loopNodes(ns []*etcd.Node, nameParts []string, star bool, bx map[bareService]bool) (sx []msg.Service, err error) {
if bx == nil {
bx = make(map[bareService]bool)
}
Nodes:
for _, n := range ns {
if n.Dir {
nodes, err := g.loopNodes(n.Nodes, nameParts, star, bx)
if err != nil {
return nil, err
}
sx = append(sx, nodes...)
continue
}
if star {
keyParts := strings.Split(n.Key, "/")
for i, n := range nameParts {
if i > len(keyParts)-1 {
// name is longer than key
continue Nodes
}
if n == "*" || n == "any" {
continue
}
if keyParts[i] != n {
continue Nodes
}
}
}
serv := new(msg.Service)
if err := json.Unmarshal([]byte(n.Value), serv); err != nil {
return nil, err
}
b := bareService{serv.Host, serv.Port, serv.Priority, serv.Weight, serv.Text}
if _, ok := bx[b]; ok {
continue
}
bx[b] = true
serv.Key = n.Key
serv.Ttl = g.calculateTtl(n, serv)
if serv.Priority == 0 {
serv.Priority = int(g.config.Priority)
}
sx = append(sx, *serv)
}
return sx, nil
}
func (g *Backendv3) loopNodes(kv []*mvccpb.KeyValue, nameParts []string, star bool, bx map[bareService]bool) (sx []msg.Service, err error) {
if bx == nil {
bx = make(map[bareService]bool)
}
Nodes:
for _, item := range kv {
if star {
s := string(item.Key[:])
keyParts := strings.Split(s, "/")
for i, n := range nameParts {
if i > len(keyParts)-1 {
continue Nodes
}
if n == "*" || n == "any" {
continue
}
if keyParts[i] != n {
continue Nodes
}
}
}
serv := new(msg.Service)
if err := json.Unmarshal(item.Value, serv); err != nil {
return nil, err
}
b := bareService{serv.Host,
serv.Port,
serv.Priority,
serv.Weight,
serv.Text}
bx[b] = true
serv.Key = string(item.Key)
//TODO: another call (LeaseRequest) for TTL when RPC in etcdv3 is ready
serv.Ttl = g.calculateTtl(item, serv)
if serv.Priority == 0 {
serv.Priority = int(g.config.Priority)
}
sx = append(sx, *serv)
}
return sx, nil
}
func (s *server) CNAMERecords(q dns.Question, name string) (records []dns.RR, err error) {
path, _ := msg.PathWithWildcard(name) // no wildcards here
r, err := get(s.client, path, true)
if err != nil {
return nil, err
}
if !r.Node.Dir {
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
serv.Key = r.Node.Key
serv.Ttl = ttl
if ip == nil {
records = append(records, serv.NewCNAME(q.Name, dns.Fqdn(serv.Host)))
}
}
return records, nil
}
// SRVRecords returns SRV records from etcd.
// If the Target is not an name but an IP address, an name is created .
func (s *server) SRVRecords(q dns.Question, name string, bufsize uint16, dnssec bool) (records []dns.RR, extra []dns.RR, err error) {
path, star := msg.PathWithWildcard(name)
r, err := get(s.client, path, true)
if err != nil {
return nil, nil, err
}
if !r.Node.Dir { // single element
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
if serv.Priority == 0 {
serv.Priority = int(s.config.Priority)
}
serv.Key = r.Node.Key
serv.Ttl = ttl
switch {
case ip == nil:
srv := serv.NewSRV(q.Name, uint16(100))
records = append(records, srv)
if !dns.IsSubDomain(s.config.Domain, srv.Target) {
m1, e1 := s.Lookup(srv.Target, dns.TypeA, bufsize, dnssec)
if e1 == nil {
extra = append(extra, m1.Answer...)
}
m1, e1 = s.Lookup(srv.Target, dns.TypeAAAA, bufsize, dnssec)
if e1 == nil {
// If we have seen CNAME's we *assume* that they already added.
for _, a := range m1.Answer {
if _, ok := a.(*dns.CNAME); !ok {
extra = append(extra, a)
}
}
}
}
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, uint16(100)))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, uint16(100)))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
return records, extra, nil
}
sx, err := s.loopNodes(&r.Node.Nodes, strings.Split(msg.Path(name), "/"), star, nil)
if err != nil || len(sx) == 0 {
return nil, nil, err
}
// Looping twice to get the right weight vs priority
w := make(map[int]int)
for _, serv := range sx {
weight := 100
if serv.Weight != 0 {
weight = serv.Weight
}
if _, ok := w[serv.Priority]; !ok {
w[serv.Priority] = weight
continue
}
w[serv.Priority] += weight
}
lookup := make(map[string]bool)
for _, serv := range sx {
w1 := 100.0 / float64(w[serv.Priority])
if serv.Weight == 0 {
w1 *= 100
} else {
w1 *= float64(serv.Weight)
}
weight := uint16(math.Floor(w1))
ip := net.ParseIP(serv.Host)
switch {
case ip == nil:
srv := serv.NewSRV(q.Name, weight)
records = append(records, srv)
if _, ok := lookup[srv.Target]; !ok {
if !dns.IsSubDomain(s.config.Domain, srv.Target) {
m1, e1 := s.Lookup(srv.Target, dns.TypeA, bufsize, dnssec)
if e1 == nil {
extra = append(extra, m1.Answer...)
}
m1, e1 = s.Lookup(srv.Target, dns.TypeAAAA, bufsize, dnssec)
if e1 == nil {
// If we have seen CNAME's we *assume* that they are already added.
for _, a := range m1.Answer {
if _, ok := a.(*dns.CNAME); !ok {
extra = append(extra, a)
}
}
}
}
}
lookup[srv.Target] = true
case ip.To4() != nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, weight))
extra = append(extra, serv.NewA(serv.Host, ip.To4()))
case ip.To4() == nil:
serv.Host = msg.Domain(serv.Key)
records = append(records, serv.NewSRV(q.Name, weight))
extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
}
}
return records, extra, nil
}
func (s *server) AddressRecords(q dns.Question, name string, previousRecords []dns.RR) (records []dns.RR, err error) {
path, star := msg.PathWithWildcard(name)
r, err := get(s.client, path, true)
if err != nil {
return nil, err
}
if !r.Node.Dir { // single element
serv := new(msg.Service)
if err := json.Unmarshal([]byte(r.Node.Value), serv); err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, err
}
ip := net.ParseIP(serv.Host)
ttl := s.calculateTtl(r.Node, serv)
serv.Ttl = ttl
serv.Key = r.Node.Key
switch {
case ip == nil:
// Try to resolve as CNAME if it's not an IP.
newRecord := serv.NewCNAME(q.Name, dns.Fqdn(serv.Host))
if len(previousRecords) > 7 {
s.config.log.Errorf("CNAME lookup limit of 8 exceeded for %s", newRecord)
return nil, fmt.Errorf("exceeded CNAME lookup limit")
}
if s.isDuplicateCNAME(newRecord, previousRecords) {
s.config.log.Errorf("CNAME loop detected for record %s", newRecord)
return nil, fmt.Errorf("detected CNAME loop")
}
records = append(records, newRecord)
nextRecords, err := s.AddressRecords(dns.Question{Name: dns.Fqdn(serv.Host), Qtype: q.Qtype, Qclass: q.Qclass}, strings.ToLower(dns.Fqdn(serv.Host)), append(previousRecords, newRecord))
if err != nil {
// This means we can not complete the CNAME, this is OK, but
// if we return an error this will trigger an NXDOMAIN.
// We also don't want to return the CNAME, because of the
// no other data rule. So return nothing and let NODATA
// kick in (via a hack).
return records, fmt.Errorf("incomplete CNAME chain")
}
records = append(records, nextRecords...)
case ip.To4() != nil && q.Qtype == dns.TypeA:
records = append(records, serv.NewA(q.Name, ip.To4()))
case ip.To4() == nil && q.Qtype == dns.TypeAAAA:
records = append(records, serv.NewAAAA(q.Name, ip.To16()))
}
return records, nil
}
nodes, err := s.loopNodes(&r.Node.Nodes, strings.Split(msg.Path(name), "/"), star, nil)
if err != nil {
s.config.log.Infof("failed to parse json: %s", err.Error())
return nil, err
}
for _, serv := range nodes {
ip := net.ParseIP(serv.Host)
switch {
case ip == nil:
// TODO: deduplicate with above code
// Try to resolve as CNAME if it's not an IP.
newRecord := serv.NewCNAME(q.Name, dns.Fqdn(serv.Host))
if len(previousRecords) > 7 {
s.config.log.Errorf("CNAME lookup limit of 8 exceeded for %s", newRecord)
return nil, fmt.Errorf("exceeded CNAME lookup limit")
}
if s.isDuplicateCNAME(newRecord, previousRecords) {
s.config.log.Errorf("CNAME loop detected for record %s", newRecord)
return nil, fmt.Errorf("detected CNAME loop")
}
records = append(records, newRecord)
nextRecords, err := s.AddressRecords(dns.Question{Name: dns.Fqdn(serv.Host), Qtype: q.Qtype, Qclass: q.Qclass}, strings.ToLower(dns.Fqdn(serv.Host)), append(previousRecords, newRecord))
if err != nil {
// This means we can not complete the CNAME, this is OK, but
// if we return an error this will trigger an NXDOMAIN.
// We also don't want to return the CNAME, because of the
// no other data rule. So return nothing and let NODATA
// kick in (via a hack).
return records, fmt.Errorf("incomplete CNAME chain")
}
records = append(records, nextRecords...)
case ip.To4() != nil && q.Qtype == dns.TypeA:
records = append(records, serv.NewA(q.Name, ip.To4()))
case ip.To4() == nil && q.Qtype == dns.TypeAAAA:
records = append(records, serv.NewAAAA(q.Name, ip.To16()))
}
}
if s.config.RoundRobin {
switch l := len(records); l {
case 2:
if dns.Id()%2 == 0 {
records[0], records[1] = records[1], records[0]
}
default:
// Do a minimum of l swap, maximum of 4l swaps
for j := 0; j < l*(int(dns.Id())%4+1); j++ {
q := int(dns.Id()) % l
p := int(dns.Id()) % l
if q == p {
p = (p + 1) % l
}
records[q], records[p] = records[p], records[q]
}
}
}
return records, nil
}
