- stats: if "SET" to zero, stat is removed

- more sanity checks
  - added localresponder: if set use specified DNS server for local domains
  - ipaliases is now used in DNS responses (works same as /etc/hosts file)
- ForwardQuery(): accept param to avoid cache

00.database.go

@@ -7,12 +7,15 @@ import (
 	"github.com/syndtr/goleveldb/leveldb"
 )
 
-//MyZabovKDB is the storage where we'll put domains to block
+//MyZabovKDB is the storage where we'll put domains to block (obsolete)
-var MyZabovKDB *leveldb.DB
+//var MyZabovKDB *leveldb.DB
 
-//MyZabovCDB is the storage where we'll put domains to cache
+//MyZabovCDB is the storage where we'll put domains to cache (global for all configs)
 var MyZabovCDB *leveldb.DB
 
+//MyZabovKDBs is the storage where we'll put domains to block (one for each config)
+var MyZabovKDBs map[string]*leveldb.DB
+
 func init() {
 
 	var err error
@@ -20,13 +23,13 @@ func init() {
 	os.RemoveAll("./db")
 
 	os.MkdirAll("./db", 0755)
-
+	/*
 		MyZabovKDB, err = leveldb.OpenFile("./db/killfile", nil)
 		if err != nil {
 			fmt.Println("Cannot create Killfile db: ", err.Error())
 		} else {
 			fmt.Println("Killfile DB created")
-	}
+		}*/
 
 	MyZabovCDB, err = leveldb.OpenFile("./db/cache", nil)
 	if err != nil {
@@ -35,4 +38,21 @@ func init() {
 		fmt.Println("Cache DB created")
 	}
 
+	MyZabovKDBs = map[string]*leveldb.DB{}
+}
+
+// ZabovCreateKDB creates Kill DBs
+func ZabovCreateKDB(conf string) {
+	var err error
+
+	dbname := "./db/killfile_" + conf
+	KDB, err := leveldb.OpenFile(dbname, nil)
+	if err != nil {
+		fmt.Println("Cannot create Killfile db: ", err.Error())
+	} else {
+		fmt.Println("Killfile DB created")
+	}
+
+	MyZabovKDBs[conf] = KDB
+
 }

01.conf.go

@@ -5,30 +5,19 @@ import (
 	"fmt"
 	"io/ioutil"
 	"log"
+	"net"
 	"os"
+	"strconv"
+	"strings"
 
 	"github.com/miekg/dns"
 )
 
+type stringarray []string
+type urlsMap map[string]stringarray
+
 func init() {
-
+	var MyConfRaw interface{}
-	//ZabovConf describes the Json we use for configuration
-	type ZabovConf struct {
-		Zabov struct {
-			Port          string `json:"port"`
-			Proto         string `json:"proto"`
-			Ipaddr        string `json:"ipaddr"`
-			Upstream      string `json:"upstream"`
-			Cachettl      int    `json:"cachettl"`
-			Killfilettl   int    `json:"killfilettl"`
-			Singlefilters string `json:"singlefilters"`
-			Doublefilters string `json:"doublefilters"`
-			Blackholeip   string `json:"blackholeip"`
-			Hostsfile     string `json:"hostsfile"`
-		} `json:"zabov"`
-	}
-
-	var MyConf ZabovConf
 
 	file, err := ioutil.ReadFile("config.json")
 
@@ -37,26 +26,42 @@ func init() {
 		os.Exit(1)
 	}
 
-	err = json.Unmarshal([]byte(file), &MyConf)
+	err = json.Unmarshal([]byte(file), &MyConfRaw)
 
 	if err != nil {
-		log.Println("Cannot marshal json: ", err.Error())
+		log.Println("Cannot unmarshal json: ", err.Error())
 		os.Exit(1)
 	}
 
 	// now we read configuration file
 	fmt.Println("Reading configuration file...")
 
-	ZabovPort := MyConf.Zabov.Port
+	MyConf := MyConfRaw.(map[string]interface{})
-	ZabovType := MyConf.Zabov.Proto
+
-	ZabovAddr := MyConf.Zabov.Ipaddr
+	zabov := MyConf["zabov"].(map[string]interface{})
-	ZabovUpDNS = MyConf.Zabov.Upstream
+
-	ZabovSingleBL = MyConf.Zabov.Singlefilters
+	ZabovPort := zabov["port"].(string)
-	ZabovDoubleBL = MyConf.Zabov.Doublefilters
+	ZabovType := zabov["proto"].(string)
-	ZabovAddBL = MyConf.Zabov.Blackholeip
+	ZabovAddr := zabov["ipaddr"].(string)
-	ZabovCacheTTL = MyConf.Zabov.Cachettl
+	ZabovCacheTTL = int(zabov["cachettl"].(float64))
-	ZabovKillTTL = MyConf.Zabov.Killfilettl
+	ZabovKillTTL = int(zabov["killfilettl"].(float64))
-	ZabovHostsFile = MyConf.Zabov.Hostsfile
+
+	if MyConf["configs"] == nil {
+		log.Println("configs not set: you shall set at least 'default' config")
+		os.Exit(1)
+	}
+
+	configs := MyConf["configs"].(map[string]interface{})
+
+	if len(configs) == 0 {
+		log.Println("you shall set at least 'default' config")
+		os.Exit(1)
+	}
+
+	if configs["default"] == nil {
+		log.Println("'default' config is required")
+		os.Exit(1)
+	}
 
 	zabovString := ZabovAddr + ":" + ZabovPort
 
@@ -64,6 +69,151 @@ func init() {
 	MyDNS.Addr = zabovString
 	MyDNS.Net = ZabovType
 
-	ZabovDNSArray = fileByLines(ZabovUpDNS)
+	ZabovConfigs = map[string]ZabovConfig{}
+	ZabovIPGroups = []ZabovIPGroup{}
+	ZabovTimetables = map[string]*ZabovTimetable{}
+	ZabovIPAliases = map[string]string{}
+
+	IPAliasesRaw := MyConf["ipaliases"].(map[string]interface{})
+
+	for alias, ip := range IPAliasesRaw {
+		fmt.Println("IP Alias:", alias, ip)
+		ZabovIPAliases[alias] = ip.(string)
+	}
+
+	for name, v := range configs {
+		fmt.Println("evaluaing config name:", name)
+		confRaw := v.(map[string]interface{})
+		var conf ZabovConfig
+		conf.ZabovUpDNS = confRaw["upstream"].(string)
+		conf.ZabovSingleBL = confRaw["singlefilters"].(string)
+		conf.ZabovDoubleBL = confRaw["doublefilters"].(string)
+		conf.ZabovAddBL = confRaw["blackholeip"].(string)
+		conf.ZabovHostsFile = confRaw["hostsfile"].(string)
+
+		conf.ZabovDNSArray = fileByLines(conf.ZabovUpDNS)
+		ZabovConfigs[name] = conf
+		ZabovCreateKDB(name)
+	}
+
+	timetables := MyConf["timetables"].(map[string]interface{})
+
+	for name, v := range timetables {
+		fmt.Println("evaluaing timetable name:", name)
+		timetableRaw := v.(map[string]interface{})
+		var timetable ZabovTimetable
+
+		timetable.cfgin = timetableRaw["cfgin"].(string)
+		timetable.cfgout = timetableRaw["cfgout"].(string)
+
+		if timetable.cfgin == "" {
+			timetable.cfgin = "default"
+		}
+		if timetable.cfgout == "" {
+			timetable.cfgout = "default"
+		}
+
+		_, ok := ZabovConfigs[timetable.cfgin]
+		if !ok {
+			log.Println("timetable: inexistent cfgin:", timetable.cfgin)
+			os.Exit(1)
+		}
+
+		_, ok = ZabovConfigs[timetable.cfgout]
+		if !ok {
+			log.Println("timetable: inexistent cfgout:", timetable.cfgout)
+			os.Exit(1)
+		}
+
+		tables := timetableRaw["tables"].([]interface{})
+
+		for i := range tables {
+			table := tables[i].(map[string]interface{})
+			var ttEntry ZabovTimetableEntry
+			ttEntry.times = []*ZabovTimeRange{}
+			for _, tRaw := range strings.Split(table["times"].(string), ";") {
+				tRawArr := strings.Split(tRaw, "-")
+				if len(tRawArr) > 1 {
+					startArr := strings.Split(tRawArr[0], ":")
+					stopArr := strings.Split(tRawArr[1], ":")
+
+					if len(startArr) > 1 && len(stopArr) > 1 {
+						hourStart, _ := strconv.Atoi(startArr[0])
+						minuteStart, _ := strconv.Atoi(startArr[1])
+						start := ZabovTime{hour: hourStart, minute: minuteStart}
+
+						hourStop, _ := strconv.Atoi(stopArr[0])
+						minuteStop, _ := strconv.Atoi(stopArr[1])
+						stop := ZabovTime{hour: hourStop, minute: minuteStop}
+						t := ZabovTimeRange{start: start, stop: stop}
+						ttEntry.times = append(ttEntry.times, &t)
+					}
+				}
+
+			}
+
+			ttEntry.days = map[string]bool{}
+			for _, day := range strings.Split(table["days"].(string), ";") {
+				ttEntry.days[day] = true
+			}
+
+			timetable.table = append(timetable.table, &ttEntry)
+		}
+		ZabovTimetables[name] = &timetable
+	}
+
+	IPGroups := MyConf["ipgroups"].([]interface{})
+
+	fmt.Println("evaluating IP Groups: ", len(IPGroups))
+	for i := range IPGroups {
+		fmt.Println("evaluating IP Group n.", i)
+		var groupStruct ZabovIPGroup
+		groupMap := IPGroups[i].(map[string]interface{})
+		IPsRaw := groupMap["ips"].([]interface{})
+		groupStruct.ips = []net.IP{}
+		for x := range IPsRaw {
+			ipRaw := IPsRaw[x].(string)
+			ip := net.ParseIP(ipRaw)
+			fmt.Println("adding IP ", ipRaw)
+
+			alias, ok := ZabovIPAliases[ipRaw]
+			if ok {
+				fmt.Println("IP alias: ", ipRaw, alias)
+				ip = net.ParseIP(alias)
+			}
+			groupStruct.ips = append(groupStruct.ips, ip)
+		}
+		groupStruct.cfg = groupMap["cfg"].(string)
+		groupStruct.timetable = groupMap["timetable"].(string)
+		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)
+		}
+		ZabovIPGroups = append(ZabovIPGroups, groupStruct)
+	}
+
+	localresponder := MyConf["localresponder"].(map[string]interface{})
+
+	if localresponder != nil {
+		if localresponder["responder"] != nil {
+			ZabovLocalResponder = localresponder["responder"].(string)
+			if len(ZabovLocalResponder) > 0 {
+				local := ZabovConfig{}
+				local.ZabovDNSArray = []string{ZabovLocalResponder}
+				ZabovConfigs["__localresponder__"] = local
+				fmt.Println("ZabovLocalResponder:", ZabovLocalResponder)
+			}
+		}
+		if localresponder["localdomain"] != nil {
+			ZabovLocalDomain = localresponder["localdomain"].(string)
+		}
+	}
+	//fmt.Println("ZabovConfigs:", ZabovConfigs)
+	//fmt.Println("ZabovTimetables:", ZabovTimetables)
+	//fmt.Println("ZabovIPAliases:", ZabovIPAliases)
+	//fmt.Println("ZabovIPGroups:", ZabovIPGroups)
 
 }

01.killfile.go

@@ -5,11 +5,10 @@ import (
 	"strings"
 )
 
-var zabovKbucket = []byte("killfile")
-
 type killfileItem struct {
 	Kdomain  string
 	Ksource  string
+	Kconfigs stringarray
 }
 
 var bChannel chan killfileItem
@@ -27,16 +26,25 @@ func bWriteThread() {
 
 	for item := range bChannel {
 
-		writeInKillfile(item.Kdomain, item.Ksource)
+		alreadyInSomeDB := false
+
+		for _, config := range item.Kconfigs {
+			if !alreadyInSomeDB {
+				alreadyInSomeDB = domainInKillfile(item.Kdomain, config)
+			}
+			writeInKillfile(item.Kdomain, item.Ksource, config)
+		}
+		if !alreadyInSomeDB {
 			incrementStats("BL domains from "+item.Ksource, 1)
 			incrementStats("TOTAL", 1)
+		}
 
 	}
 
 }
 
 //DomainKill stores a domain name inside the killfile
-func DomainKill(s, durl string) {
+func DomainKill(s, durl string, configs stringarray) {
 
 	if len(s) > 2 {
 
@@ -46,6 +54,7 @@ func DomainKill(s, durl string) {
 
 		k.Kdomain = s
 		k.Ksource = durl
+		k.Kconfigs = configs
 
 		bChannel <- k
 
@@ -53,11 +62,12 @@ func DomainKill(s, durl string) {
 
 }
 
-func writeInKillfile(key, value string) {
+func writeInKillfile(key, value string, config string) {
 
 	stK := []byte(key)
 	stV := []byte(value)
 
+	MyZabovKDB := MyZabovKDBs[config]
 	err := MyZabovKDB.Put(stK, stV, nil)
 	if err != nil {
 		fmt.Println("Cannot write to Killfile DB: ", err.Error())
@@ -65,10 +75,11 @@ func writeInKillfile(key, value string) {
 
 }
 
-func domainInKillfile(domain string) bool {
+func domainInKillfile(domain string, config string) bool {
 
 	s := strings.ToLower(domain)
 
+	MyZabovKDB := MyZabovKDBs[config]
 	has, err := MyZabovKDB.Has([]byte(s), nil)
 	if err != nil {
 		fmt.Println("Cannot read from Killfile DB: ", err.Error())

01.stats.go

@@ -81,7 +81,12 @@ func statsThread() {
 		case "INC":
 			ZabovStats[item.Payload] += item.Number
 		case "SET":
+			if item.Number == 0 {
+
+				delete(ZabovStats, item.Payload)
+			} else {
 				ZabovStats[item.Payload] = item.Number
+			}
 		case "PRI":
 			statsPrint()
 		}

adlist_hosts.go

@@ -16,9 +16,12 @@ func init() {
 }
 
 //DoubleIndexFilter puts the domains inside file
-func DoubleIndexFilter(durl string) error {
+func DoubleIndexFilter(durl string, configs stringarray) error {
 
-	fmt.Println("Retrieving HostFile from: ", durl)
+	fmt.Println("DoubleIndexFilter: Retrieving HostFile from: ", durl)
+
+	// resets malformed HostLines for url
+	setstatsvalue("Malformed HostLines "+durl, 0)
 
 	var err error
 
@@ -48,6 +51,9 @@ func DoubleIndexFilter(durl string) error {
 
 		line := scanner.Text()
 
+		if len(line) == 0 || strings.TrimSpace(line)[0] == '#' {
+			continue
+		}
 		h := strings.FieldsFunc(line, splitter)
 
 		if h == nil {
@@ -59,7 +65,8 @@ func DoubleIndexFilter(durl string) error {
 		}
 
 		if net.ParseIP(h[0]) != nil {
-			DomainKill(h[1], durl)
+
+			DomainKill(h[1], durl, configs)
 
 			// fmt.Println("MATCH: ", h[1])
 			numLines++
@@ -76,20 +83,41 @@ func DoubleIndexFilter(durl string) error {
 
 }
 
-func getDoubleFilters() {
+func getDoubleFilters(urls urlsMap) {
 
-	s := fileByLines(ZabovDoubleBL)
+	fmt.Println("getDoubleFilters: downloading all urls:", len(urls))
-
+	for url, configs := range urls {
-	for _, a := range s {
+		DoubleIndexFilter(url, configs)
-		DoubleIndexFilter(a)
 	}
+	fmt.Println("getDoubleFilters: DONE!")
 
 }
 
 func downloadDoubleThread() {
 	fmt.Println("Starting updater of DOUBLE lists, each (hours):", ZabovKillTTL)
+
+	_urls := urlsMap{}
+
 	for {
-		getDoubleFilters()
+		fmt.Println("downloadDoubleThread: collecting urls from all configs...")
+		for config := range ZabovConfigs {
+			ZabovDoubleBL := ZabovConfigs[config].ZabovDoubleBL
+			if len(ZabovDoubleBL) == 0 {
+				continue
+			}
+			s := fileByLines(ZabovDoubleBL)
+			for _, v := range s {
+				configs := _urls[v]
+				if configs == nil {
+					configs = stringarray{}
+					_urls[v] = configs
+				}
+				configs = append(configs, config)
+				_urls[v] = configs
+			}
+		}
+
+		getDoubleFilters(_urls)
 		time.Sleep(time.Duration(ZabovKillTTL) * time.Hour)
 	}
 

adlist_single.go

@@ -14,10 +14,13 @@ func init() {
 }
 
 //SingleIndexFilter puts the domains inside file
-func SingleIndexFilter(durl string) error {
+func SingleIndexFilter(durl string, configs stringarray) error {
 
 	fmt.Println("Retrieving DomainFile from: ", durl)
 
+	// resets malformed HostLines for url
+	setstatsvalue("Malformed DomainLines "+durl, 0)
+
 	var err error
 
 	// Get the data
@@ -46,6 +49,9 @@ func SingleIndexFilter(durl string) error {
 
 		line := scanner.Text()
 
+		if len(line) == 0 || strings.TrimSpace(line)[0] == '#' {
+			continue
+		}
 		h := strings.FieldsFunc(line, splitter)
 
 		if h == nil {
@@ -57,7 +63,9 @@ func SingleIndexFilter(durl string) error {
 		}
 
 		if !strings.Contains(h[0], "#") {
-			DomainKill(h[0], durl)
+
+			DomainKill(h[0], durl, configs)
+
 			// fmt.Println("MATCH: ", h[1])
 			numLines++
 		} else {
@@ -73,20 +81,42 @@ func SingleIndexFilter(durl string) error {
 
 }
 
-func getSingleFilters() {
+func getSingleFilters(urls urlsMap) {
 
-	s := fileByLines(ZabovSingleBL)
+	fmt.Println("getSingleFilters: downloading all urls:", len(urls))
-
+	for url, configs := range urls {
-	for _, a := range s {
+		SingleIndexFilter(url, configs)
-		SingleIndexFilter(a)
 	}
+	fmt.Println("getSingleFilters: DONE!")
 
 }
 
 func downloadThread() {
 	fmt.Println("Starting updater of SINGLE lists, each (hours): ", ZabovKillTTL)
+	_urls := urlsMap{}
+
 	for {
-		getSingleFilters()
+		fmt.Println("downloadThread: collecting urls from all configs...")
+		for config := range ZabovConfigs {
+			ZabovSingleBL := ZabovConfigs[config].ZabovSingleBL
+
+			if len(ZabovSingleBL) == 0 {
+				continue
+			}
+
+			s := fileByLines(ZabovSingleBL)
+			for _, v := range s {
+				configs := _urls[v]
+				if configs == nil {
+					configs = stringarray{}
+					_urls[v] = configs
+				}
+				configs = append(configs, config)
+				_urls[v] = configs
+			}
+		}
+
+		getSingleFilters(_urls)
 		time.Sleep(time.Duration(ZabovKillTTL) * time.Hour)
 	}
 

config.json

@@ -1,15 +1,55 @@
 {
-    "zabov": {  
+    "zabov":{
         "port":"53", 
         "proto":"udp", 
         "ipaddr":"0.0.0.0",
-        "upstream":"./dns-upstream.txt"  ,
         "cachettl": 1,
-        "killfilettl": 12,
+        "killfilettl": 12
-        "singlefilters":"./urls-domains.txt" ,
+    },
+    "localresponder":{
+        "responder":"192.168.178.1:53",
+        "localdomain":"fritz.box"
+    },
+    "ipaliases":{
+        "pc8":"192.168.178.29",
+        "localhost":"127.0.0.1"
+    },
+    "ipgroups":[
+        {
+            "ips":["localhost", "::1", "192.168.178.30", "192.168.178.31", "pc8"],
+            "cfg":"",
+            "timetable":"tt_children"
+        }
+    ],
+    "timetables":{
+        "tt_children":{
+            "tables":[{"times":"00:00-05:00;8:30-12:30;18:30-22:59", "days":"Mo;Tu;We;Th;Fr;Sa;Su"}],
+            "cfgin":"children_restricted",
+            "cfgout":"children"
+        }
+    },
+    "configs":{
+        "default":{
+            "upstream":"./dns-upstream.txt",
+            "singlefilters":"./urls-domains.txt",
+            "doublefilters":"./urls-hosts.txt", 
+            "blackholeip":"127.0.0.1",
+            "hostsfile":"./urls-local.txt"
+        },
+        "children":{
+            "upstream":"./dns-upstream.txt",
+            "singlefilters":"./urls-domains.txt",
+            "doublefilters":"./urls-hosts.txt", 
+            "blackholeip":"127.0.0.1",
+            "hostsfile":"./urls-local.txt"
+        },
+        "children_restricted":{
+            "upstream":"./dns-upstream.txt",
+            "singlefilters":"./urls-domains.txt",
             "doublefilters":"./urls-hosts.txt", 
             "blackholeip":"127.0.0.1",
             "hostsfile":"./urls-local.txt"
         }
+    }
 
 }

dns_client.go

@@ -12,7 +12,8 @@ import (
 
 //ForwardQuery forwards the query to the upstream server
 //first server to answer wins
-func ForwardQuery(query *dns.Msg) *dns.Msg {
+//accepts config name to select the UP DNS source list
+func ForwardQuery(query *dns.Msg, config string, nocache bool) *dns.Msg {
 
 	go incrementStats("ForwardQueries", 1)
 
@@ -23,6 +24,7 @@ func ForwardQuery(query *dns.Msg) *dns.Msg {
 	fqdn := strings.TrimRight(query.Question[0].Name, ".")
 
 	lfqdn := fmt.Sprintf("%d", query.Question[0].Qtype) + "." + fqdn
+	if !nocache {
 		if cached := GetDomainFromCache(lfqdn); cached != nil {
 			go incrementStats("CacheHit", 1)
 			cached.SetReply(query)
@@ -30,6 +32,7 @@ func ForwardQuery(query *dns.Msg) *dns.Msg {
 			return cached
 
 		}
+	}
 
 	c := new(dns.Client)
 
@@ -45,7 +48,7 @@ func ForwardQuery(query *dns.Msg) *dns.Msg {
 			continue
 		}
 
-		d := oneTimeDNS()
+		d := oneTimeDNS(config)
 
 		in, _, err := c.Exchange(query, d)
 		if err != nil {
@@ -78,11 +81,11 @@ func init() {
 
 }
 
-func oneTimeDNS() (dns string) {
+func oneTimeDNS(config string) (dns string) {
 
 	rand.Seed(time.Now().Unix())
 
-	upl := ZabovDNSArray
+	upl := ZabovConfigs[config].ZabovDNSArray
 
 	if len(upl) < 1 {
 		fmt.Println("No DNS defined, using default 127.0.0.53:53. Hope it works!")

dns_handler.go

@@ -1,44 +1,124 @@
 package main
 
 import (
+	"fmt"
 	"net"
 	"strings"
+	"time"
 
 	"github.com/miekg/dns"
 )
 
+var weekdays []string
+
+func init() {
+	weekdays = []string{"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
+}
+
+func getCurTime() (time.Time, error) {
+	return time.Parse("15:04", time.Now().Format("15:04"))
+}
+
+func confFromTimeTable(timetable string) string {
+	tt := ZabovTimetables[timetable]
+	if tt == nil {
+		fmt.Println("confFromTimeTable: return default")
+		return "default"
+	}
+	for _, ttentry := range tt.table {
+		now := time.Now()
+		nowHour := now.Hour()
+		nowMinute := now.Minute()
+		weekday := weekdays[now.Weekday()]
+		if ttentry.days == nil || len(ttentry.days) == 0 || ttentry.days[weekday] || ttentry.days[strings.ToLower(weekday)] {
+			for _, t := range ttentry.times {
+
+				if (nowHour > t.start.hour || (nowHour == t.start.hour && nowMinute >= t.start.minute)) &&
+					(nowHour < t.stop.hour || (nowHour == t.stop.hour && nowMinute <= t.stop.minute)) {
+					go incrementStats("TIMETABLE IN: "+timetable, 1)
+					fmt.Println("confFromTimeTable: return IN", tt.cfgin)
+					return tt.cfgin
+				}
+			}
+		}
+	}
+	go incrementStats("TIMETABLE OUT: "+timetable, 1)
+	fmt.Println("confFromTimeTable: return OUT", tt.cfgout)
+	return tt.cfgout
+}
+
+func confFromIP(clientIP net.IP) string {
+
+	for _, ipgroup := range ZabovIPGroups {
+		for _, ip := range ipgroup.ips {
+			if clientIP.Equal(ip) {
+				if len(ipgroup.timetable) > 0 {
+					return confFromTimeTable(ipgroup.timetable)
+				}
+				fmt.Println("confFromIP: ipgroup.cfg")
+				return ipgroup.cfg
+			}
+		}
+	}
+	fmt.Println("confFromIP: return default")
+	return "default"
+}
 func (mydns *handler) ServeDNS(w dns.ResponseWriter, r *dns.Msg) {
 	go incrementStats("TotalQueries", 1)
 
 	remIP, _, e := net.SplitHostPort(w.RemoteAddr().String())
 	if e != nil {
+		go incrementStats("CLIENT ERROR: "+remIP, 1)
+	} else {
 		go incrementStats("CLIENT: "+remIP, 1)
 	}
 
 	msg := dns.Msg{}
 	msg.SetReply(r)
 
+	config := confFromIP(net.ParseIP(remIP))
+
+	ZabovConfig := ZabovConfigs[config]
 	switch r.Question[0].Qtype {
 	case dns.TypeA:
 		msg.Authoritative = true
 		domain := msg.Question[0].Name
 		fqdn := strings.TrimRight(domain, ".")
 
-		if domainInKillfile(fqdn) {
+		if len(ZabovIPAliases[fqdn]) > 0 {
+			config = "__aliases__"
+			msg.Answer = append(msg.Answer, &dns.A{
+				Hdr: dns.RR_Header{Name: domain, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
+				A:   net.ParseIP(ZabovIPAliases[fqdn]),
+			})
+			break
+		}
+		if len(ZabovLocalResponder) > 0 {
+			if !strings.Contains(fqdn, ".") ||
+				(len(ZabovLocalDomain) > 0 && strings.HasSuffix(fqdn, ZabovLocalDomain)) {
+				config = "__localresponder__"
+				ret := ForwardQuery(r, config, true)
+				w.WriteMsg(ret)
+				break
+			}
+
+		}
+		if domainInKillfile(fqdn, config) {
 			go incrementStats("Killed", 1)
 
 			msg.Answer = append(msg.Answer, &dns.A{
 				Hdr: dns.RR_Header{Name: domain, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
-				A:   net.ParseIP(ZabovAddBL),
+				A:   net.ParseIP(ZabovConfig.ZabovAddBL),
 			})
 		} else {
-			ret := ForwardQuery(r)
+			ret := ForwardQuery(r, config, false)
 			w.WriteMsg(ret)
 		}
 	default:
-		ret := ForwardQuery(r)
+		ret := ForwardQuery(r, config, false)
 		w.WriteMsg(ret)
 	}
+	go incrementStats("CONFIG: "+config, 1)
 	w.WriteMsg(&msg)
 
 }

hostfile.go

@@ -9,12 +9,29 @@ import (
 func init() {
 
 	fmt.Println("Ingesting local hosts file")
-	ingestLocalBlacklist()
+	ingestLocalBlacklists()
 
 }
 
-func ingestLocalBlacklist() {
+func ingestLocalBlacklists() {
 
+	fmt.Println("ingestLocalBlacklist: collecting urls from all configs...")
+	_files := urlsMap{}
+	for config := range ZabovConfigs {
+		ZabovHostsFile := ZabovConfigs[config].ZabovHostsFile
+		if len(ZabovHostsFile) == 0 {
+			continue
+		}
+		configs := _files[ZabovHostsFile]
+		if configs == nil {
+			configs = stringarray{}
+			_files[ZabovHostsFile] = configs
+		}
+		configs = append(configs, config)
+		_files[ZabovHostsFile] = configs
+	}
+
+	for ZabovHostsFile, configs := range _files {
 		file, err := os.Open(ZabovHostsFile)
 		if err != nil {
 			fmt.Println(err.Error())
@@ -24,7 +41,7 @@ func ingestLocalBlacklist() {
 		scanner := bufio.NewScanner(file)
 		for scanner.Scan() {
 			d := scanner.Text()
-		DomainKill(d, ZabovHostsFile)
+			DomainKill(d, ZabovHostsFile, configs)
 			incrementStats("Blacklist", 1)
 
 		}
@@ -32,6 +49,7 @@ func ingestLocalBlacklist() {
 		if err := scanner.Err(); err != nil {
 			fmt.Println(err.Error())
 		}
+	}
 
 }
 

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"log"
+	"net"
 
 	"github.com/miekg/dns"
 )
@@ -9,32 +10,74 @@ import (
 //MyDNS is my dns server
 var MyDNS *dns.Server
 
-//ZabovUpDNS keeps the name of upstream DNSs
+//ZabovCacheTTL is the amount of hours we cache records of DNS (global)
-var ZabovUpDNS string
-
-//ZabovSingleBL list of urls returning a file with just names of domains
-var ZabovSingleBL string
-
-//ZabovDoubleBL list of urls returning a file with  IP<space>domain
-var ZabovDoubleBL string
-
-//ZabovAddBL is the IP we want to send all the clients to. Usually is 127.0.0.1
-var ZabovAddBL string
-
-//ZabovCacheTTL is the amount of hours we cache records of DNS
 var ZabovCacheTTL int
 
-//ZabovKillTTL is the amount of hours we cache the killfile
+//ZabovKillTTL is the amount of hours we cache the killfile (global)
 var ZabovKillTTL int
 
-//ZabovHostsFile is the file we use to keep our hosts
+//ZabovLocalResponder is the default DNS server for loca domains
-var ZabovHostsFile string
+var ZabovLocalResponder string
 
-//ZabovDNSArray is the array containing all the DNS we mention
+//ZabovLocalDomain is the default local domain
-var ZabovDNSArray []string
+var ZabovLocalDomain string
 
 type handler struct{}
 
+// ZabovConfig contains all Zabov configs
+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
+	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
+}
+
+// ZabovConfigs contains all Zabov configs
+var ZabovConfigs map[string]ZabovConfig
+
+// ZabovIPGroup contains Zabov groups of IPs
+type ZabovIPGroup struct {
+	ips       []net.IP // IPs in this group
+	cfg       string   // config name to be used if there is no timetable
+	timetable string   // timetable name to be used for this group; timetable SHALL reference to config name to use
+}
+
+// ZabovIPGroups contains an array of all Zabov groups of IP rules
+var ZabovIPGroups []ZabovIPGroup
+
+// ZabovTime contains Zabov single time
+type ZabovTime struct {
+	hour   int
+	minute int
+}
+
+// ZabovTimeRange contains Zabov single time range
+type ZabovTimeRange struct {
+	start ZabovTime
+	stop  ZabovTime
+}
+
+// ZabovTimetableEntry contains Zabov single time table entry
+type ZabovTimetableEntry struct {
+	times []*ZabovTimeRange
+	days  map[string]bool
+}
+
+// ZabovTimetable contains a Zabov time table
+type ZabovTimetable struct {
+	table  []*ZabovTimetableEntry
+	cfgin  string // configuration name to be used if "inside" timetable
+	cfgout string // configuration name to be used if "outiside" timetable
+}
+
+// ZabovTimetables contains all Zabov time tables, by name
+var ZabovTimetables map[string]*ZabovTimetable
+
+// ZabovIPAliases contains an array of all Zabov IP aliases
+var ZabovIPAliases map[string]string
+
 func main() {
 
 	MyDNS.Handler = &handler{}