ccl/internal/pkg/container/nsupdate.go

package container

import (
	"net"
	"time"

	cmd "gitea.elkins.co/Networking/ccl/internal/pkg/command"
	"github.com/miekg/dns"
)

func do_reverse(rv string, dn string, server string, tsn string, tsk string) error {
	ptr := dns.PTR{
		Hdr: dns.RR_Header{
			Name:   rv,
			Rrtype: dns.TypePTR,
			Class:  dns.ClassINET,
			Ttl:    7200,
		},
		Ptr: dn,
	}

	cli := new(dns.Client)
	if tsn != "" {
		cli.TsigSecret = map[string]string{tsn: tsk}
	}

	msg := new(dns.Msg)
	msg.SetQuestion(rv, dns.TypeSOA)
	resp, _, err := cli.Exchange(msg, server)
	if err != nil {
		return err
	}
	soa := resp.Ns[0].Header().Name

	// Update the reverse record
	msg = new(dns.Msg)
	msg.SetUpdate(soa)
	msg.Ns = append(msg.Ns, &ptr)
	if tsn != "" {
		msg.SetTsig(tsn, dns.HmacSHA256, 300, time.Now().Unix())
	}
	_, _, err = cli.Exchange(msg, server)
	if err != nil {
		return err
	}
	return nil
}

func (c *Container) NsUpdateCommands(forward_domain string, server string, tsn string, tsk string) cmd.Set {
	hostname := c.Hostname
	if c.Hostname == "" {
		hostname = c.Name
	}
	dn := dns.Fqdn(hostname + "." + forward_domain)
	cmds := []cmd.Command{}

	// TODO: also iterate over c.IPv6Addresses
	for i := range c.Networks {
		n := &c.Networks[i]
		if n.IPv6.Bool && !n.IPv6Address.IsUnspecified() {
			ad := net.ParseIP(n.IPv6Address.String())
			if ad != nil {
				f_6 := func() error {
					aaaa := dns.AAAA{
						Hdr: dns.RR_Header{
							Name:   dn,
							Rrtype: dns.TypeAAAA,
							Class:  dns.ClassINET,
							Ttl:    7200,
						},
						AAAA: ad,
					}

					rv, err := dns.ReverseAddr(aaaa.AAAA.String())
					if err != nil {
						return err
					}

					cli := new(dns.Client)
					if tsn != "" {
						cli.TsigSecret = map[string]string{tsn: tsk}
					}

					// Update the forward record
					msg := new(dns.Msg)
					msg.SetUpdate(dns.Fqdn(forward_domain))
					msg.Ns = append(msg.Ns, &aaaa)

					if tsn != "" {
						msg.SetTsig(tsn, dns.HmacSHA256, 300, time.Now().Unix())
					}
					if _, _, err = cli.Exchange(msg, server); err != nil {
						return err
					}

					if err = do_reverse(rv, dn, server, tsn, tsk); err != nil {
						return err
					}
					return nil
				}
				cmds = append(cmds, cmd.NewFunc("nsupate6", f_6))
			}
		}
		if !n.IPv4Address.IsUnspecified() {
			ad := net.ParseIP(n.IPv4Address.String())
			if ad != nil {
				f_4 := func() error {
					a := dns.A{
						Hdr: dns.RR_Header{
							Name:   dn,
							Rrtype: dns.TypeA,
							Class:  dns.ClassINET,
							Ttl:    7200,
						},
						A: ad,
					}

					rv, err := dns.ReverseAddr(a.A.String())
					if err != nil {
						return err
					}

					cli := new(dns.Client)
					if tsn != "" {
						cli.TsigSecret = map[string]string{tsn: tsk}
					}

					// Update the forward record
					msg := new(dns.Msg)
					msg.SetUpdate(dns.Fqdn(forward_domain))
					msg.Ns = append(msg.Ns, &a)
					if tsn != "" {
						msg.SetTsig(tsn, dns.HmacSHA256, 300, time.Now().Unix())
					}
					if _, _, err = cli.Exchange(msg, server); err != nil {
						return err
					}

					if err = do_reverse(rv, dn, server, tsn, tsk); err != nil {
						return err
					}
					return nil
				}
				cmds = append(cmds, cmd.NewFunc("nsupate4", f_4))
			}
		}
	}
	return c.newCommandSet("NSUPDATE", cmds)
}