Compare commits

...

5 Commits

Author SHA1 Message Date
  bloved f018377b44 Merge branch 'master' into master 3 weeks ago
  bloved d74f2a973e - BUG FIX: preserving DNS RCode in Zabov responses (SetReply(query) resets it to RcodeSuccess) 3 weeks ago
  bloved c56789e193 - BUG FIX: IP Groups: blank timetable was not allowed; timetable & cfg con now be blank or undefined 3 weeks ago
  bloved 9b4e4fbcb9 - optimization: blackholeip is parsed only once at startup 1 month ago
  bloved b9f17b3c19 - network down is ignored if the selected configuration is local responder 1 month ago
5 changed files with 73 additions and 21 deletions
Split View
  1. +30
    -11
      01.conf.go
  2. +17
    -2
      README.md
  3. +19
    -2
      dns_client.go
  4. +5
    -5
      dns_handler.go
  5. +2
    -1
      main.go

+ 30
- 11
01.conf.go View File

@ -13,10 +13,13 @@ import (
"github.com/miekg/dns"
)
var localresponderConfigName string
type stringarray []string
type urlsMap map[string]stringarray
func init() {
localresponderConfigName = "__localresponder__"
var MyConfRaw interface{}
file, err := ioutil.ReadFile("config.json")
@ -107,9 +110,14 @@ func init() {
conf.ZabovUpDNS = confRaw["upstream"].(string)
conf.ZabovSingleBL = confRaw["singlefilters"].(string)
conf.ZabovDoubleBL = confRaw["doublefilters"].(string)
conf.ZabovAddBL = confRaw["blackholeip"].(string)
conf.ZabovAddBL = net.ParseIP(confRaw["blackholeip"].(string))
conf.ZabovHostsFile = confRaw["hostsfile"].(string)
if confRaw["cache"] != nil {
conf.ZabovCache = confRaw["cache"].(bool)
} else {
conf.ZabovCache = true
}
conf.ZabovDNSArray = fileByLines(conf.ZabovUpDNS)
ZabovConfigs[name] = &conf
@ -216,8 +224,16 @@ func init() {
}
groupStruct.ips = append(groupStruct.ips, ip)
}
groupStruct.cfg = groupMap["cfg"].(string)
groupStruct.timetable = groupMap["timetable"].(string)
if groupMap["cfg"] != nil {
groupStruct.cfg = groupMap["cfg"].(string)
}
if groupMap["timetable"] != nil {
groupStruct.timetable = groupMap["timetable"].(string)
}
if len(groupStruct.cfg) == 0 && len(groupStruct.timetable) == 0 {
log.Println("ip group error: specify cfg or timetable")
os.Exit(1)
}
if len(groupStruct.cfg) > 0 {
refConfig, ok := ZabovConfigs[groupStruct.cfg]
if !ok {
@ -226,14 +242,17 @@ func init() {
} else {
refConfig.references++
}
fmt.Println("cfg:", groupStruct.cfg)
}
fmt.Println("cfg:", groupStruct.cfg)
fmt.Println("timetable:", groupStruct.timetable)
_, ok := ZabovTimetables[groupStruct.timetable]
if !ok {
log.Println("inexistent timetable:", groupStruct.timetable)
os.Exit(1)
if len(groupStruct.timetable) > 0 {
fmt.Println("timetable:", groupStruct.timetable)
_, ok := ZabovTimetables[groupStruct.timetable]
if !ok {
log.Println("inexistent timetable:", groupStruct.timetable)
os.Exit(1)
}
}
ZabovIPGroups = append(ZabovIPGroups, groupStruct)
}
}
@ -248,7 +267,7 @@ func init() {
}
//************************
// Local responser section
// Local responder section
//************************
if MyConf["localresponder"] != nil {
localresponder := MyConf["localresponder"].(map[string]interface{})
@ -258,7 +277,7 @@ func init() {
ZabovLocalResponder = localresponder["responder"].(string)
if len(ZabovLocalResponder) > 0 {
local := ZabovConfig{ZabovDNSArray: []string{ZabovLocalResponder}, references: 1}
ZabovConfigs["__localresponder__"] = &local
ZabovConfigs[localresponderConfigName] = &local
fmt.Println("ZabovLocalResponder:", ZabovLocalResponder)
}
}

+ 17
- 2
README.md View File

@ -62,7 +62,8 @@ Minimal config file should look like:
"singlefilters":"./urls-domains.txt",
"doublefilters":"./urls-hosts.txt",
"blackholeip":"127.0.0.1",
"hostsfile":"./urls-local.txt"
"hostsfile":"./urls-local.txt",
"cache":true
},
}
}
@ -84,7 +85,7 @@ configs:
- doublefilters: name of the file, for blacklists following the "doublefilter" schema.(one URL per line)
- blackholeip: IP address to return when the IP is banned. This is because you may want to avoid MX issues, mail loops on localhost, or you have a web server running on localhost
- hostsfile: path where you keep your local blacklistfile : this is in the format "singlefilter", meaning one domain per line, unlike hosts file.
- cache: if set to false disable the cache for this configuration. Boolean, defaults true
Advanced configuration includes support for multiple configurations based on IP Source and timetables:
<pre>
@ -104,6 +105,7 @@ Advanced configuration includes support for multiple configurations based on IP
},
"ipaliases":{
"pc8":"192.168.178.29",
"lg-tv":"192.168.178.10",
"localhost":"127.0.0.1"
},
"ipgroups":[
@ -111,6 +113,11 @@ Advanced configuration includes support for multiple configurations based on IP
"ips":["localhost", "::1", "192.168.178.30", "192.168.178.31", "pc8"],
"cfg":"",
"timetable":"tt_children"
},
{
"ips":["lg-tv"],
"cfg":"tv",
"timetable":""
}
],
"timetables":{
@ -146,6 +153,14 @@ Advanced configuration includes support for multiple configurations based on IP
"doublefilters":"./urls-hosts-restricted.txt",
"blackholeip":"127.0.0.1",
"hostsfile":"./urls-local.txt"
},
"tv":{
"upstream":"./dns-upstream.txt",
"singlefilters":"",
"doublefilters":"",
"blackholeip":"127.0.0.1",
"hostsfile":"",
"cache":false
}
}
}

+ 19
- 2
dns_client.go View File

@ -2,6 +2,7 @@ package main
import (
"fmt"
"log"
"time"
"math/rand"
@ -14,7 +15,9 @@ import (
//first server to answer wins
//accepts config name to select the UP DNS source list
func ForwardQuery(query *dns.Msg, config string, nocache bool) *dns.Msg {
if ZabovDebug {
log.Println("ForwardQuery: nocache", nocache)
}
go incrementStats("ForwardQueries", 1)
r := new(dns.Msg)
@ -27,8 +30,14 @@ func ForwardQuery(query *dns.Msg, config string, nocache bool) *dns.Msg {
if !nocache {
if cached := GetDomainFromCache(lfqdn); cached != nil {
go incrementStats("CacheHit", 1)
Rcode := cached.MsgHdr.Rcode
cached.SetReply(query)
cached.MsgHdr.Rcode = Rcode
cached.Authoritative = true
if ZabovDebug {
log.Println("ForwardQuery: CacheHit")
}
cached.Compress = true
return cached
}
@ -42,7 +51,8 @@ func ForwardQuery(query *dns.Msg, config string, nocache bool) *dns.Msg {
for {
// round robin with retry
if !NetworkUp {
// local responder should always be available also if no internet connection
if !NetworkUp && localresponderConfigName != config {
time.Sleep(10 * time.Second)
go incrementStats("Network Problems ", 1)
continue
@ -57,9 +67,16 @@ func ForwardQuery(query *dns.Msg, config string, nocache bool) *dns.Msg {
continue
} else {
go incrementStats(d, 1)
Rcode := in.MsgHdr.Rcode
in.SetReply(query)
in.MsgHdr.Rcode = Rcode
in.Authoritative = true
in.Compress = true
go DomainCache(lfqdn, in)
if ZabovDebug {
log.Println("ForwardQuery: OK!")
}
return in
}

+ 5
- 5
dns_handler.go View File

@ -269,7 +269,7 @@ func (mydns *handler) ServeDNS(w dns.ResponseWriter, r *dns.Msg) {
if len(ZabovLocalResponder) > 0 {
if !strings.Contains(fqdn, ".") ||
(len(ZabovLocalDomain) > 0 && strings.HasSuffix(fqdn, ZabovLocalDomain)) {
config = "__localresponder__"
config = localresponderConfigName
ret := ForwardQuery(r, config, true)
w.WriteMsg(ret)
go logQuery(remIP, fqdn, QType, config, timetable, "localresponder")
@ -282,12 +282,12 @@ func (mydns *handler) ServeDNS(w dns.ResponseWriter, r *dns.Msg) {
msg.Answer = append(msg.Answer, &dns.A{
Hdr: dns.RR_Header{Name: domain, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
A: net.ParseIP(ZabovConfig.ZabovAddBL),
A: ZabovConfig.ZabovAddBL,
})
go logQuery(remIP, fqdn, QType, config, timetable, "killed")
} else {
go logQuery(remIP, fqdn, QType, config, timetable, "forwarded")
ret := ForwardQuery(r, config, false)
ret := ForwardQuery(r, config, !ZabovConfig.ZabovCache)
w.WriteMsg(ret)
}
case dns.TypePTR:
@ -297,13 +297,13 @@ func (mydns *handler) ServeDNS(w dns.ResponseWriter, r *dns.Msg) {
if len(ZabovLocalResponder) > 0 {
// if set use local responder for reverse lookup (suffix ".in-addr.arpa.")
config = "__localresponder__"
config = localresponderConfigName
}
ret := ForwardQuery(r, config, true)
w.WriteMsg(ret)
go logQuery(remIP, msg.Question[0].Name, QType, config, timetable, "localresponder")
default:
ret := ForwardQuery(r, config, false)
ret := ForwardQuery(r, config, !ZabovConfig.ZabovCache)
w.WriteMsg(ret)
if len(ZabovDebugDBPath) > 0 {
go logQuery(remIP, msg.Question[0].Name, QType, config, timetable, "forwarded")

+ 2
- 1
main.go View File

@ -37,10 +37,11 @@ type handler struct{}
type ZabovConfig struct {
ZabovSingleBL string // json:singlefilters -> ZabovSingleBL list of urls returning a file with just names of domains
ZabovDoubleBL string // json:doublefilters -> ZabovDoubleBL list of urls returning a file with IP<space>domain
ZabovAddBL string // json:blackholeip -> ZabovAddBL is the IP we want to send all the clients to. Usually is 127.0.0.1
ZabovAddBL net.IP // json:blackholeip -> ZabovAddBL is the IP we want to send all the clients to. Usually is 127.0.0.1
ZabovHostsFile string // json:hostsfile -> ZabovHostsFile is the file we use to keep our hosts
ZabovUpDNS string // json:upstream -> ZabovUpDNS keeps the name of upstream DNSs
ZabovDNSArray []string // contains all the DNS we mention, parsed from ZabovUpDNS file
ZabovCache bool // allows to disable cache
references int // contains references to this config; if zero, config shall be removed
}

Loading…
Cancel
Save