func main() { var ( addr string ) flag.StringVar(&addr, "l", "[::]:53", "listen on (both tcp and udp)") flag.StringVar(&listd, "d", "./list.d", "Dir with blacklisted domain files") handler := &Handle{} Adlist = make(map[string]bool) if e := filepath.Walk(listd, visit); e != nil { panic(e) } //for _, addr := range strings.Split(listen, ",") { fmt.Printf("DNS Listen %s\n", addr) go func() { if err := dns.ListenAndServe(addr, "udp", handler); err != nil { panic(err) } }() if err := dns.ListenAndServe(addr, "tcp", handler); err != nil { panic(err) } //} }
func dnsSetup(cfg *Config) chan error { log.Println("DNSSETUP") // FIXME: Make the default TTL into a configuration parameter // FIXME: Check whether this default is being applied to unanswered queries defaultTTL := uint32(10800) // this is the default TTL = 3 hours cache := dnscache.New(dnsCacheBufferSize, cfg.DNSCacheMaxTTL(), cfg.DNSCacheMissingTTL(), func(c dnscache.Context, q dns.Question) []dns.RR { return answerQuestion(cfg, c, &q, defaultTTL, 0) }) dns.HandleFunc(".", func(w dns.ResponseWriter, req *dns.Msg) { dnsQueryServe(cfg, cache, w, req) }) cfg.db.InitDNS() exit := make(chan error, 1) go func() { exit <- dns.ListenAndServe("0.0.0.0:53", "tcp", nil) // TODO: should use cfg to define the listening ip/port }() go func() { exit <- dns.ListenAndServe("0.0.0.0:53", "udp", nil) // TODO: should use cfg to define the listening ip/port }() return exit }
func main() { parse_flags() var err error if enable_cache { // create cache dns_cache, err = lru.New(1000) if err != nil { log.Fatal(err) } } dns.HandleFunc(".", handleRoot) logger = NewLogger(logfile, debug) logger.Info("Listen on %s\n", bind_addr) go func() { /* listen tcp */ err := dns.ListenAndServe(bind_addr, "tcp", nil) if err != nil { log.Fatal(err) } }() /* listen udp */ err = dns.ListenAndServe(bind_addr, "udp", nil) if err != nil { log.Fatal(err) } }
func main() { var ( S_SERVERS string S_LISTEN string S_ACCESS string timeout int max_entries int64 expire_interval int64 ) flag.StringVar(&S_SERVERS, "proxy", "127.0.0.1:53", "we proxy requests to those servers") flag.StringVar(&S_LISTEN, "listen", "[::1]:5353,127.0.0.1:5353", "listen on (both tcp and udp), [ipv6address]:port, ipv4address:port") flag.StringVar(&S_ACCESS, "access", "0.0.0.0/0", "allow those networks, use 0.0.0.0/0 to allow everything") flag.IntVar(&timeout, "timeout", 5, "timeout") flag.Int64Var(&expire_interval, "expire_interval", 300, "delete expired entries every N seconds") flag.BoolVar(&DEBUG, "debug", false, "enable/disable debug") flag.Int64Var(&max_entries, "max_cache_entries", 2000000, "max cache entries") flag.Parse() servers := strings.Split(S_SERVERS, ",") proxyer := ServerProxy{ giant: new(sync.RWMutex), ACCESS: make([]*net.IPNet, 0), SERVERS: servers, s_len: len(servers), NOW: time.Now().UTC().Unix(), entries: 0, timeout: time.Duration(timeout) * time.Second, max_entries: max_entries} for _, mask := range strings.Split(S_ACCESS, ",") { _, cidr, err := net.ParseCIDR(mask) if err != nil { panic(err) } _D("added access for %s\n", mask) proxyer.ACCESS = append(proxyer.ACCESS, cidr) } for _, addr := range strings.Split(S_LISTEN, ",") { _D("listening @ :%s\n", addr) go func() { if err := dns.ListenAndServe(addr, "udp", proxyer); err != nil { log.Fatal(err) } }() go func() { if err := dns.ListenAndServe(addr, "tcp", proxyer); err != nil { log.Fatal(err) } }() } for { proxyer.NOW = time.Now().UTC().Unix() time.Sleep(time.Duration(1) * time.Second) } }
// Run is a blocking operation that starts the server listening on the DNS ports. func (s *server) Run() error { mux := dns.NewServeMux() mux.Handle(".", s) dnsReadyMsg := func(addr, net string) { if s.config.DNSSEC == "" { log.Printf("skydns: ready for queries on %s for %s://%s [rcache %d]", s.config.Domain, net, addr, s.config.RCache) } else { log.Printf("skydns: ready for queries on %s for %s://%s [rcache %d], signing with %s [scache %d]", s.config.Domain, net, addr, s.config.RCache, s.config.DNSSEC, s.config.SCache) } } s.group.Add(1) go func() { defer s.group.Done() if err := dns.ListenAndServe(s.config.DnsAddr, s.dnsTCPclient.Net, mux); err != nil { log.Fatalf("skydns: %s", err) } }() dnsReadyMsg(s.config.DnsAddr, s.dnsTCPclient.Net) s.group.Add(1) go func() { defer s.group.Done() if err := dns.ListenAndServe(s.config.DnsAddr, s.dnsUDPclient.Net, mux); err != nil { log.Fatalf("skydns: %s", err) } }() dnsReadyMsg(s.config.DnsAddr, s.dnsUDPclient.Net) s.group.Wait() return nil }
func main() { flag.Parse() tdns := &TrivialDnsServer{ Servers: readUpstreamServersFromConfig(), Database: readDatabaseFromConfig(), stats: make(map[string]int), } log.Printf("Starting with nameservers %v", tdns.Servers) log.Printf("Starting with database %v", tdns.Database) addr := ":53" go func() { if err := dns.ListenAndServe(addr, "udp", tdns); err != nil { log.Fatal(err) } }() go func() { if err := dns.ListenAndServe(addr, "tcp", tdns); err != nil { log.Fatal(err) } }() log.Printf("DNS server started") log.Printf("Starting web interface on %s", *webListenAddr) http.HandleFunc("/", tdns.WebIndexPage) http.HandleFunc("/save_hosts", tdns.WebSaveHosts) http.ListenAndServe(*webListenAddr, nil) }
func main() { runtime.GOMAXPROCS(runtime.NumCPU() * 4) for z, rr := range zones { rrx := rr.(*dns.SOA) // Needed to create the actual RR, and not an reference. dns.HandleFunc(z, func(w dns.ResponseWriter, r *dns.Msg) { m := new(dns.Msg) m.SetReply(r) m.Authoritative = true m.Ns = []dns.RR{rrx} w.WriteMsg(m) }) } go func() { err := dns.ListenAndServe(":8053", "tcp", nil) if err != nil { log.Fatal("Failed to set tcp listener %s\n", err.Error()) } }() go func() { err := dns.ListenAndServe(":8053", "udp", nil) if err != nil { log.Fatal("Failed to set udp listener %s\n", err.Error()) } }() sig := make(chan os.Signal) signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM) for { select { case s := <-sig: log.Fatalf("Signal (%d) received, stopping\n", s) } } }
func main() { dns.HandleFunc(".", proxyServe) failure := make(chan error, 1) go func(failure chan error) { failure <- dns.ListenAndServe(*local, "tcp", nil) }(failure) go func(failure chan error) { failure <- dns.ListenAndServe(*local, "udp", nil) }(failure) log.Printf("ready for accept connection on tcp/upd %s ...\n", *local) fmt.Println(<-failure) }
func ListenAndServeDNS(address string) error { dns.HandleFunc("dev.", localhostDNSHandler) err := dns.ListenAndServe(address, "udp", nil) if err != nil { return err } return nil }
func (d *DNS) ListenAndServe() error { udpErr := make(chan error) tcpErr := make(chan error) go func() { udpErr <- dns.ListenAndServe(d.Config.Bind, "udp", dns.HandlerFunc(d.handler)) }() go func() { tcpErr <- dns.ListenAndServe(d.Config.Bind, "tcp", dns.HandlerFunc(d.handler)) }() select { case err := <-udpErr: return err case err := <-tcpErr: return err } return nil }
func (s *Server) classicServe() { glog.Infof("DNS listening on %s", s.Addr) var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() err := dns.ListenAndServe(s.Addr, "udp", dns.HandlerFunc(s.Handler)) glog.Fatalf("Exiting UDP: %v", err) }() wg.Add(1) go func() { defer wg.Done() err := dns.ListenAndServe(s.Addr, "tcp", dns.HandlerFunc(s.Handler)) glog.Fatalf("Exiting TCP: %v", err) }() wg.Wait() }
func initDNS() { if GConf.LocalDNS.CacheSize > 0 { dnsCache, _ = lru.New(GConf.LocalDNS.CacheSize) } if len(GConf.LocalDNS.Listen) > 0 { err := dns.ListenAndServe(GConf.LocalDNS.Listen, "udp", dns.HandlerFunc(proxyDNS)) if nil != err { log.Printf("Failed to start dns server:%v", err) } } }
// TODO: make port and bind address configurable func serve(net, name, secret string) { switch name { case "": err := dns.ListenAndServe(":53", net, nil) if err != nil { fmt.Printf("Failed to setup the "+net+" server: %s\n", err.Error()) } default: server := &dns.Server{Addr: ":53", Net: net, TsigSecret: map[string]string{name: secret}} err := server.ListenAndServe() if err != nil { fmt.Printf("Failed to setup the "+net+" server: %s\n", err.Error()) } } }
func main() { keenProject := os.Getenv("KEEN_PROJECT") keenWriteKey := os.Getenv("KEEN_WRITE_KEY") githubProject := os.Getenv("GITHUB_PROJECT") githubToken := os.Getenv("GITHUB_ACCESS_TOKEN") host := os.Getenv("HOST") if host == "" { host = "0.0.0.0" } port := os.Getenv("PORT") if port == "" { port = "53" } addr := net.JoinHostPort(host, port) if keenProject == "" || keenWriteKey == "" || githubProject == "" { log.Fatal("Please set KEEN_PROJECT, KEEN_WRITE_KEY, and GITHUB_PROJECT") } keenClient := &keen.Client{WriteKey: keenWriteKey, ProjectID: keenProject} keenBatchClient := keen.NewBatchClient(keenClient, *keenFlushInterval) var authClient *http.Client if githubToken != "" { authClient = oauth2.NewClient(oauth2.NoContext, oauth2.StaticTokenSource( &oauth2.Token{AccessToken: githubToken}, )) } githubClient := github.NewClient(authClient) tracker := UsageTracker{ keenClient: keenBatchClient, githubClient: githubClient, githubProject: githubProject, } err := dns.ListenAndServe(addr, "udp", &tracker) if err != nil { log.Fatal(err) } }
func main () { var servers []string args := flag.Args () if len(args) > 0 { servers = append (servers, args...) } else { servers = DEFAULT_SERVERS } LOG.Printf ("Servers: %s", servers) proxyer := Proxy{servers} if err := dns.ListenAndServe ("127.0.0.1:53", "udp", proxyer); err != nil { LOG.Fatal (err) } }
func main() { flag.Usage = func() { flag.PrintDefaults() } flag.Parse() if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { log.Fatal(err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } cache := NewCache() dns.HandleFunc(".", func(w dns.ResponseWriter, r *dns.Msg) { serve(w, r, cache) }) // Only listen on UDP go func() { if err := dns.ListenAndServe(*listen, "udp", nil); err != nil { log.Fatalf("fks-shield: failed to setup %s %s", *listen, "udp") } }() go func() { for { // Every 10 sec run the cache cleaner time.Sleep(10 * 1e9) cache.Evict() } }() sig := make(chan os.Signal) signal.Notify(sig, os.Interrupt) forever: for { select { case <-sig: log.Printf("fks-shield: signal received, stopping") break forever } } }
func main() { launchConfig.MaybeDeploy() addr := flag.String("addr", defaultListenAddr(), "specify address for server to listen on") flag.Parse() memkv := sorted.NewMemoryKeyValue() if err := memkv.Set("6401800c.camlistore.net.", "159.203.246.79"); err != nil { panic(err) } if err := memkv.Set("camlistore.net.", "104.154.231.160"); err != nil { panic(err) } if err := memkv.Set("www.camlistore.net.", "104.154.231.160"); err != nil { panic(err) } ds := NewDNSServer(memkv) log.Printf("serving DNS on %s\n", *addr) if err := dns.ListenAndServe(*addr, "udp", ds); err != nil { log.Fatal(err) } }
// Run is a blocking operation that starts the server listening on the DNS ports. func (s *server) Run() error { mux := dns.NewServeMux() mux.Handle(".", s) dnsReadyMsg := func(addr, net string) { if s.config.DNSSEC == "" { log.Printf("skydns: ready for queries on %s for %s://%s [rcache %d]", s.config.Domain, net, addr, s.config.RCache) } else { log.Printf("skydns: ready for queries on %s for %s://%s [rcache %d], signing with %s [scache %d]", s.config.Domain, net, addr, s.config.RCache, s.config.DNSSEC, s.config.SCache) } } if s.config.Systemd { packetConns, err := activation.PacketConns(false) if err != nil { return err } listeners, err := activation.Listeners(true) if err != nil { return err } if len(packetConns) == 0 && len(listeners) == 0 { return fmt.Errorf("no UDP or TCP sockets supplied by systemd") } for _, p := range packetConns { if u, ok := p.(*net.UDPConn); ok { s.group.Add(1) go func() { defer s.group.Done() if err := dns.ActivateAndServe(nil, u, mux); err != nil { log.Fatalf("skydns: %s", err) } }() dnsReadyMsg(u.LocalAddr().String(), "udp") } } for _, l := range listeners { if t, ok := l.(*net.TCPListener); ok { s.group.Add(1) go func() { defer s.group.Done() if err := dns.ActivateAndServe(t, nil, mux); err != nil { log.Fatalf("skydns: %s", err) } }() dnsReadyMsg(t.Addr().String(), "tcp") } } } else { s.group.Add(1) go func() { defer s.group.Done() if err := dns.ListenAndServe(s.config.DnsAddr, "tcp", mux); err != nil { log.Fatalf("skydns: %s", err) } }() dnsReadyMsg(s.config.DnsAddr, "tcp") s.group.Add(1) go func() { defer s.group.Done() if err := dns.ListenAndServe(s.config.DnsAddr, "udp", mux); err != nil { log.Fatalf("skydns: %s", err) } }() dnsReadyMsg(s.config.DnsAddr, "udp") } s.group.Wait() return nil }
// Listen for DNS requests. listenSpec is a dotted-quad + port, e.g., // 127.0.0.1:53. This function blocks and only returns when the DNS service is // no longer functioning. func (ds *DNSServer) Listen(listenSpec string) error { return dns.ListenAndServe(listenSpec, "udp", ds) }
func main() { fmt.Printf("Starting ClientProxy\n") var ( S_SERVERS string S_LISTEN string S_ACCESS string timeout int max_entries int64 expire_interval int64 S_DNS_SERVERS string start_TLS bool TLS_Path string ) flag.BoolVar(&LOG, "log", false, "whether print all query") flag.StringVar(&S_SERVERS, "proxy", "24.104.150.237", "we proxy requests to those servers,input like fci.biilab.cn") //Not sure use IP or URL, default server undefined flag.StringVar(&S_LISTEN, "listen", "[::]:53", "listen on (both tcp and udp)") flag.StringVar(&S_ACCESS, "access", "127.0.0.0/8,10.0.0.0/8", "allow those networks, use 0.0.0.0/0 to allow everything") flag.IntVar(&timeout, "timeout", 5, "timeout") flag.Int64Var(&expire_interval, "expire_interval", 300, "delete expired entries every N seconds") flag.BoolVar(&DEBUG, "debug", false, "enable/disable debug") flag.Int64Var(&max_entries, "max_cache_entries", 2000000, "max cache entries") flag.StringVar(&S_DNS_SERVERS, "dns_server", "114.114.114.114:53", "DNS server for initial server lookup") flag.BoolVar(&start_TLS, "start_TLS", false, "Whether use HTTPS to increase privacy.") flag.StringVar(&TLS_Path, "certificate_path", "", "The path of certificate, use no input to let client not validate certificate") flag.Parse() servers := strings.Split(S_SERVERS, ",") dns_servers := strings.Split(S_DNS_SERVERS, ",") UDPproxyer := ClientProxy{ giant: new(sync.RWMutex), ACCESS: make([]*net.IPNet, 0), SERVERS: servers, s_len: len(servers), NOW: time.Now().UTC().Unix(), entries: 0, timeout: time.Duration(timeout) * time.Second, max_entries: max_entries, TransPro: UDPcode, DNS_SERVERS: dns_servers, start_TLS: start_TLS, TLS_Path: TLS_Path} TCPproxyer := ClientProxy{ giant: new(sync.RWMutex), ACCESS: make([]*net.IPNet, 0), SERVERS: servers, s_len: len(servers), NOW: time.Now().UTC().Unix(), entries: 0, timeout: time.Duration(timeout) * time.Second, max_entries: max_entries, TransPro: TCPcode, DNS_SERVERS: dns_servers, start_TLS: start_TLS, TLS_Path: TLS_Path} for _, mask := range strings.Split(S_ACCESS, ",") { _, cidr, err := net.ParseCIDR(mask) if err != nil { panic(err) } _D("added access for %s\n", mask) UDPproxyer.ACCESS = append(UDPproxyer.ACCESS, cidr) TCPproxyer.ACCESS = append(TCPproxyer.ACCESS, cidr) } err := UDPproxyer.getServerIP() if err != nil { _D("can not get server address, %s\n", err) return } err = TCPproxyer.getServerIP() if err != nil { _D("can not get server address, %s\n", err) return } for _, addr := range strings.Split(S_LISTEN, ",") { fmt.Printf("listening @ %s\n", addr) go func() { if err := dns.ListenAndServe(addr, "udp", UDPproxyer); err != nil { log.Fatal(err) } }() go func() { if err := dns.ListenAndServe(addr, "tcp", TCPproxyer); err != nil { log.Fatal(err) } }() } fmt.Printf("Start to work\n") for { UDPproxyer.NOW = time.Now().UTC().Unix() time.Sleep(time.Duration(1) * time.Second) } }
func serve(net string, address string) { err := dns.ListenAndServe(address, net, nil) if err != nil { log.Fatalf("Failed to setup the "+net+" server: %s\n", err.Error()) } }
func main() { var err error config, err = readConfig("config.dns") if err != nil { log.Fatal(err) } // Cleanup all running containers client := getDocker() list, err := client.ListContainers(docker.ListContainersOptions{All: true}) if err != nil { log.Fatal(err) } ConfigLoop: for _, conf := range config { created := false // See if it already exists for _, c := range list { for _, name := range c.Names { if strings.Index(name, "/"+Prefix+conf.Name) == 0 { // Inspect to get info about it container, err := client.InspectContainer(c.ID) if err != nil { // Didn't exist, so let's create it and we're done if _, ok := err.(*docker.NoSuchContainer); ok { container, err = createContainer(client, conf) if err != nil { log.Println("Error creating container at startup:", err) continue ConfigLoop } created = true continue } else { log.Println("Error inspecting container at startup:", err) continue ConfigLoop } } // Stop it if it's running if container.State.Running { err = client.StopContainer(c.ID, 1) if err != nil { log.Println("Error stopping container at startup:", err) continue ConfigLoop } } // Get information about the image the container is based on - if it's the same one outdated := false image, err := client.InspectImage(conf.Dockername) if err != nil { outdated = true } else { outdated = container.Created.Before(image.Created) } // Recreate it if it's outdated if outdated { log.Println(conf.Dockername, container.Image) // So delete removeOpts := docker.RemoveContainerOptions{ID: c.ID} err = client.RemoveContainer(removeOpts) if err != nil { log.Println("Error removing container at startup:", err) continue ConfigLoop } // And create _, err = createContainer(client, conf) if err != nil { log.Println("Error creating container at startup:", err) continue ConfigLoop } } created = true } } } if !created { _, err = createContainer(client, conf) if err != nil { log.Println("Error creating container at startup:", err) continue ConfigLoop } } } log.Println("Initialized") for _, c := range config { for _, hostname := range c.Hostnames { dns.HandleFunc(hostname, c.GenerateServeDNS(hostname)) } } go dns.ListenAndServe("localhost:"+strconv.Itoa(port), "tcp", nil) go dns.ListenAndServe("localhost:"+strconv.Itoa(port), "udp", nil) log.Printf("Server listening on port %d on TCP and UDP\n", port) sig := make(chan os.Signal) signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM) forever: for { select { case s := <-sig: log.Printf("Signal (%d) received, stopping\n", s) break forever } } }
// Run is a blocking operation that starts the server listening on the DNS ports. func (s *server) Run() error { mux := dns.NewServeMux() mux.Handle(".", s) dnsReadyMsg := func(addr, net string) { rCacheState := "disabled" if s.config.RCache > 0 { rCacheState = fmt.Sprintf("capacity: %d", s.config.RCache) } log.Infof("Ready for queries on %s://%s [cache: %s]", net, addr, rCacheState) } if s.config.Systemd { packetConns, err := activation.PacketConns(false) if err != nil { return err } listeners, err := activation.Listeners(true) if err != nil { return err } if len(packetConns) == 0 && len(listeners) == 0 { return fmt.Errorf("No UDP or TCP sockets supplied by systemd") } for _, p := range packetConns { if u, ok := p.(*net.UDPConn); ok { s.group.Add(1) go func() { defer s.group.Done() if err := dns.ActivateAndServe(nil, u, mux); err != nil { log.Fatalf("%s", err) } }() dnsReadyMsg(u.LocalAddr().String(), "udp") } } for _, l := range listeners { if t, ok := l.(*net.TCPListener); ok { s.group.Add(1) go func() { defer s.group.Done() if err := dns.ActivateAndServe(t, nil, mux); err != nil { log.Fatalf("%s", err) } }() dnsReadyMsg(t.Addr().String(), "tcp") } } } else { s.group.Add(1) go func() { defer s.group.Done() if err := dns.ListenAndServe(s.config.DnsAddr, "tcp", mux); err != nil { log.Fatalf("%s", err) } }() dnsReadyMsg(s.config.DnsAddr, "tcp") s.group.Add(1) go func() { defer s.group.Done() if err := dns.ListenAndServe(s.config.DnsAddr, "udp", mux); err != nil { log.Fatalf("%s", err) } }() dnsReadyMsg(s.config.DnsAddr, "udp") } s.group.Wait() return nil }
func main() { l := lever.New("struggledns", nil) l.Add(lever.Param{ Name: "--listen-addr", Description: "Address to listen on for dns requests. Will bind to both tcp and udp", Default: ":53", }) l.Add(lever.Param{ Name: "--fwd-to", Description: "Address (ip:port) of a dns server to attempt forward requests to. Specify multiple times to make multiple request attempts. Order specified dictates precedence should more than one server respond for a request", }) l.Add(lever.Param{ Name: "--parallel", Description: "If sent the query will be sent to all addresses in parallel", Flag: true, }) l.Add(lever.Param{ Name: "--timeout", Description: "Timeout in milliseconds for each request", Default: "300", }) l.Add(lever.Param{ Name: "--log-level", Description: "Minimum log level to show, either debug, info, warn, error, or fatal", Default: "warn", }) l.Add(lever.Param{ Name: "--allow-truncated", Description: "If we should allow truncated responses to be proxied", Flag: true, }) if version != "" { l.Add(lever.Param{ Name: "--version", Aliases: []string{"-v"}, Description: "Print version info", Flag: true, }) } l.Parse() if l.ParamFlag("--version") { fmt.Println(version) return } addr, _ := l.ParamStr("--listen-addr") dnsServers, _ := l.ParamStrs("--fwd-to") combineGroups := l.ParamFlag("--parallel") timeout, _ := l.ParamInt("--timeout") logLevel, _ := l.ParamStr("--log-level") llog.SetLevelFromString(logLevel) allowTruncated = l.ParamFlag("--allow-truncated") if combineGroups { //combine all the servers sent into one group dnsServerGroups = make([][]string, 1) var groupServers []string for i := range dnsServers { groupServers = strings.Split(dnsServers[i], ",") dnsServerGroups[0] = append(dnsServerGroups[0], groupServers...) } } else { dnsServerGroups = make([][]string, len(dnsServers)) for i := range dnsServers { dnsServerGroups[i] = strings.Split(dnsServers[i], ",") } } client = dns.Client{ //since this is UDP, the Dial/Write timeouts don't mean much //we really only care about setting the read DialTimeout: time.Millisecond * 100, WriteTimeout: time.Millisecond * 100, ReadTimeout: time.Millisecond * time.Duration(timeout), UDPSize: 4096, } handler := dns.HandlerFunc(handleRequest) go func() { llog.Info("listening on udp", llog.KV{"addr": addr}) err := dns.ListenAndServe(addr, "udp", handler) llog.Fatal("error listening on udp", llog.KV{"err": err}) }() go func() { llog.Info("listening on tcp", llog.KV{"addr": addr}) err := dns.ListenAndServe(addr, "tcp", handler) llog.Fatal("error listening on tcp", llog.KV{"err": err}) }() select {} }
func main() { launchConfig.MaybeDeploy() flag.Parse() var kv keyValue var httpsListenAddr string if metadata.OnGCE() { httpsListenAddr = ":443" dsClient, err := datastore.NewClient(context.Background(), GCEProjectID) if err != nil { log.Fatalf("Error creating datastore client for records: %v", err) } kv = cachedStore{ dsClient: dsClient, cache: lru.New(cacheSize), } } else { httpsListenAddr = ":4430" kv = memkv{skv: sorted.NewMemoryKeyValue()} } if err := kv.Set("6401800c.camlistore.net.", "159.203.246.79"); err != nil { log.Fatalf("Error adding %v:%v record: %v", "6401800c.camlistore.net.", "159.203.246.79", err) } if err := kv.Set(domain, *flagServerIP); err != nil { log.Fatalf("Error adding %v:%v record: %v", domain, *flagServerIP, err) } if err := kv.Set("www.camlistore.net.", *flagServerIP); err != nil { log.Fatalf("Error adding %v:%v record: %v", "www.camlistore.net.", *flagServerIP, err) } ds := newDNSServer(kv) cs := &gpgchallenge.Server{ OnSuccess: func(identity string, address string) error { log.Printf("Adding %v.camlistore.net. as %v", identity, address) return ds.dataSource.Set(strings.ToLower(identity+".camlistore.net."), address) }, } tcperr := make(chan error, 1) udperr := make(chan error, 1) httperr := make(chan error, 1) log.Printf("serving DNS on %s\n", *addr) go func() { tcperr <- dns.ListenAndServe(*addr, "tcp", ds) }() go func() { udperr <- dns.ListenAndServe(*addr, "udp", ds) }() if metadata.OnGCE() { // TODO(mpl): if we want to get a cert for anything // *.camlistore.net, it's a bit of a chicken and egg problem, since // we need camnetdns itself to be already running and answering DNS // queries. It's probably doable, but easier for now to just ask // one for camnetdns.camlistore.org, since that name is not // resolved by camnetdns. hostname := strings.TrimSuffix(authorityNS, ".") m := autocert.Manager{ Prompt: autocert.AcceptTOS, HostPolicy: autocert.HostWhitelist(hostname), Cache: autocert.DirCache(osutil.DefaultLetsEncryptCache()), } ln, err := tls.Listen("tcp", httpsListenAddr, &tls.Config{ Rand: rand.Reader, Time: time.Now, NextProtos: []string{http2.NextProtoTLS, "http/1.1"}, MinVersion: tls.VersionTLS12, GetCertificate: m.GetCertificate, }) if err != nil { log.Fatalf("Error listening on %v: %v", httpsListenAddr, err) } go func() { httperr <- http.Serve(ln, cs) }() } select { case err := <-tcperr: log.Fatalf("DNS over TCP error: %v", err) case err := <-udperr: log.Fatalf("DNS error: %v", err) case err := <-httperr: log.Fatalf("HTTP server error: %v", err) } }