ncdns/server/server.go

package server
import "github.com/hlandau/madns"
import "github.com/hlandau/degoutils/log"
import "github.com/hlandau/ncdns/backend"
import "github.com/miekg/dns"
import "os"
import "fmt"
import "os/signal"
import "syscall"

type Server struct {
  cfg ServerConfig

  engine madns.Engine

  mux *dns.ServeMux
  udpListener *dns.Server
  tcpListener *dns.Server
}

type ServerConfig struct {
  Bind string         `default:":53" usage:"Address to bind to (e.g. 0.0.0.0:53)"`
  PublicKey string    `default:"ncdns.key" usage:"Path to the DNSKEY KSK public key file"`
  PrivateKey string   `default:"ncdns.private" usage:"Path to the KSK's corresponding private key file"`
  ZonePublicKey string `default:"" usage:"Path to the DNSKEY ZSK public key file; if one is not specified, a temporary one is generated on startup and used only for the duration of that process"`
  ZonePrivateKey string `default:"" usage:"Path to the ZSK's corresponding private key file"`

  NamecoinRPCUsername string `default:"" usage:"Namecoin RPC username"`
  NamecoinRPCPassword string `default:"" usage:"Namecoin RPC password"`
  NamecoinRPCAddress  string `default:"localhost:8336" usage:"Namecoin RPC server address"`
  CacheMaxEntries     int    `default:"1000" usage:"Maximum name cache entries"`
  SelfName            string `default:"" usage:"Canonical name for this nameserver (default: autogenerated psuedo-hostname resolving to SelfIP; SelfIP is not used if this is set)"`
  SelfIP              string `default:"127.127.127.127" usage:"The canonical IP address for this service"`

  Daemonize bool `default:"false" usage:"Daemonize (doesn't fork)"`
  UID       int  `default:"0" usage:"UID to drop privileges to if run as root"`
  GID       int  `default:"0" usage:"GID to drop privileges to if run as root"`
}

func NewServer(cfg *ServerConfig) (s *Server, err error) {
  s = &Server{}
  s.cfg = *cfg

  bcfg := &backend.Config {
    RPCUsername: cfg.NamecoinRPCUsername,
    RPCPassword: cfg.NamecoinRPCPassword,
    RPCAddress: cfg.NamecoinRPCAddress,
    CacheMaxEntries: cfg.CacheMaxEntries,
    SelfName: cfg.SelfName,
    SelfIP: cfg.SelfIP,
  }

  b, err := backend.New(bcfg)
  if err != nil {
    return
  }

  ecfg := &madns.EngineConfig{
    Backend: b,
  }

  // key setup
  if cfg.PublicKey != "" {
    ksk, kskPrivate, err := s.loadKey(cfg.PublicKey, cfg.PrivateKey)
    if err != nil {
      return nil, err
    }

    ecfg.KSK = ksk
    ecfg.KSKPrivate = kskPrivate
  }

  if cfg.ZonePublicKey != "" {
    zsk, zskPrivate, err := s.loadKey(cfg.ZonePublicKey, cfg.ZonePrivateKey)
    if err != nil {
      return nil, err
    }

    ecfg.ZSK = zsk
    ecfg.ZSKPrivate = zskPrivate
  }

  if ecfg.KSK != nil && ecfg.ZSK == nil {
    return nil, fmt.Errorf("Must specify ZSK if KSK is specified")
  }

  e, err := madns.NewEngine(ecfg)
  if err != nil {
    return
  }

  s.engine = e
  return
}

func (s *Server) loadKey(fn, privateFn string) (k *dns.DNSKEY, privatek dns.PrivateKey, err error) {
  f, err := os.Open(fn)
  if err != nil {
    return
  }

  rr, err := dns.ReadRR(f, fn)
  if err != nil {
    return
  }

  k, ok := rr.(*dns.DNSKEY)
  if !ok {
    err = fmt.Errorf("Loaded record from key file, but it wasn't a DNSKEY")
    return
  }

  privatef, err := os.Open(privateFn)
  if err != nil {
    return
  }

  privatek, err = k.ReadPrivateKey(privatef, privateFn)
  log.Fatale(err)

  return
}

func (s *Server) Run() {
  s.mux = dns.NewServeMux()
  s.mux.Handle(".", s.engine)

  s.udpListener = s.runListener("udp")
  s.tcpListener = s.runListener("tcp")

  log.Info("Ready.")

  // wait
  sig := make(chan os.Signal)
  signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
  for {
    s := <-sig
    fmt.Printf("Signal %v received, stopping.", s)
    break
  }
}

func (s *Server) doRunListener(ds *dns.Server) {
  err := ds.ListenAndServe()
  log.Fatale(err)
}

func (s *Server) runListener(net string) *dns.Server {
  ds := &dns.Server {
    Addr: s.cfg.Bind,
    Net: net,
    Handler: s.mux,
  }
  go s.doRunListener(ds)
  return ds
}