1 files changed, 192 insertions, 0 deletions

diff --git a/generate_dns_types.go b/generate_dns_types.go
new file mode 100644
index 0000000..282c630
--- /dev/null
+++ b/generate_dns_types.go
@@ -0,0 +1,192 @@
+//+build ignore
+
+package main
+
+import (
+        "fmt"
+        "go/types"
+        "log"
+        "os"
+        "text/template"
+
+        "golang.org/x/tools/go/packages"
+)
+
+type Field struct {
+        Name string
+        Type string
+}
+
+var tpl = template.Must(template.New("").Parse(`package dns
+
+// GENERATED FILE, DO NOT MODIFY
+// See generate_dns_types.go in the repo root.
+
+import (
+        "encoding/json"
+        "fmt"
+        "net"
+
+        "github.com/miekg/dns"
+
+        "code.crute.me/mcrute/go_ddns_manager/bind"
+)
+
+{{ range $name, $fields := . -}}
+type {{ $name }} struct {
+        Name string
+        Ttl int
+        {{ range $fields -}}
+        {{ .Name }} {{ .Type }}
+        {{ end -}}
+}
+
+func (r *{{ $name }}) ToDNS(zone *bind.Zone) dns.RR {
+        return &dns.{{ $name }}{
+                Hdr: makeHeader(r.Name, zone, dns.Type{{ $name }}, r.Ttl),
+                {{ range $fields -}}
+                {{ .Name }}: r.{{ .Name }},
+                {{ end }}
+        }
+}
+
+func (r *{{ $name }}) FromDNS(rr dns.RR) error {
+        rt, ok := rr.(*dns.{{ $name }})
+        if !ok {
+                return fmt.Errorf("Invalid type %T for '{{ $name }}'", rr)
+        }
+
+        r.Name = rr.Header().Name
+        r.Ttl = int(rr.Header().Ttl)
+        {{ range $fields -}}
+        r.{{ .Name }} = rt.{{ .Name }}
+        {{ end }}
+
+        return nil
+}
+
+func (r *{{ $name }}) MarshalJSON() ([]byte, error) {
+        type Alias {{ $name }}
+        return json.Marshal(&struct {
+                Type string
+                *Alias
+        }{"{{ $name }}", (*Alias)(r)})
+}
+
+func (r *{{ $name }}) UnmarshalJSON(data []byte) error {
+        type Alias {{ $name }}
+        if err := json.Unmarshal(data, &struct{
+                Type string
+                *Alias
+        }{Alias: (*Alias)(r)}); err != nil {
+                return err
+        }
+        return nil
+}
+
+var _ RR = (*{{ $name }})(nil)
+
+{{ end }}
+
+
+func FromDNS(rr dns.RR) interface{} {
+        switch v := rr.(type) {
+        {{ range $name, $fields := . -}}
+        case *dns.{{ $name }}:
+                rv := &{{ $name }}{}
+                rv.FromDNS(v)
+                return rv
+        {{ end }}
+        }
+        return nil
+}
+`))
+
+var disallowedTypes = map[string]bool{
+        "CDNSKEY":   true,
+        "CDS":       true,
+        "DLV":       true,
+        "KEY":       true,
+        "OPT":       true,
+        "SIG":       true,
+        "PrivateRR": true,
+        "RFC3597":   true,
+        "ANY":       true,
+}
+
+var allowedPackages = map[string]bool{
+        "net": true,
+}
+
+func main() {
+        conf := packages.Config{Mode: packages.NeedTypes | packages.NeedTypesInfo | packages.NeedDeps}
+        pkgs, err := packages.Load(&conf, "github.com/miekg/dns")
+        if err != nil {
+                panic(err)
+        }
+
+        scope := pkgs[0].Types.Scope()
+        localTypes := map[string][]Field{}
+
+        for _, name := range scope.Names() {
+                o := scope.Lookup(name)
+                if o == nil || !o.Exported() {
+                        continue
+                }
+
+                // Only consider structs
+                st, ok := o.Type().Underlying().(*types.Struct)
+                if !ok {
+                        continue
+                }
+
+                name := o.Name()
+
+                // Explicitly disallow some types that have complex embedded types
+                if _, skip := disallowedTypes[name]; skip {
+                        continue
+                }
+
+                // There must be a type constant for this
+                if scope.Lookup(fmt.Sprintf("Type%s", name)) == nil {
+                        continue
+                }
+
+                fields := []Field{}
+                for i := 0; i < st.NumFields(); i++ {
+                        f := st.Field(i)
+
+                        // Exclude header field
+                        if f.Name() == "Hdr" {
+                                continue
+                        }
+
+                        // Fail if there are complex types embedded
+                        if tp, ok := f.Type().(*types.Named); ok {
+                                if _, ok := allowedPackages[tp.Obj().Pkg().Path()]; !ok {
+                                        log.Fatalf("Invalid embedded complex type: %s", tp)
+                                }
+                        }
+
+                        // Also fail if there are complex types embedded in a slice
+                        if tp, ok := f.Type().(*types.Slice); ok {
+                                if ut, ok := tp.Elem().(*types.Named); ok {
+                                        if _, ok := allowedPackages[ut.Obj().Pkg().Path()]; !ok {
+                                                log.Fatalf("Invalid embedded complex type: %s", tp)
+                                        }
+                                }
+                        }
+
+                        fields = append(fields, Field{f.Name(), f.Type().String()})
+                }
+
+                localTypes[name] = fields
+        }
+
+        fp, err := os.Create("zzz_types.go")
+        if err != nil {
+                panic(err)
+        }
+        defer fp.Close()
+        tpl.Execute(fp, localTypes)
+}