-
Notifications
You must be signed in to change notification settings - Fork 1
/
main.go
118 lines (98 loc) · 2.58 KB
/
main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package main
import (
"flag"
"fmt"
"os"
"sync"
"github.com/Ajnasz/dnsbl-check/dnsblprovider"
"github.com/Ajnasz/dnsbl-check/providerlist"
)
// LookupResult stores the query result with reason
type LookupResult struct {
IsBlacklisted bool
Address string
Reason string
Provider dnsblprovider.DNSBLProvider
Error error
}
func lookup(address string, provider dnsblprovider.DNSBLProvider) LookupResult {
isListed, err := provider.IsBlacklisted(address)
if err != nil {
return LookupResult{
Provider: provider,
Address: address,
Error: err,
}
}
if isListed {
desc, err := provider.GetReason(address)
return LookupResult{
Error: err,
Address: address,
IsBlacklisted: true,
Provider: provider,
Reason: desc,
}
}
return LookupResult{
Address: address,
IsBlacklisted: false,
Provider: provider,
}
}
func getBlacklists(addresses []string, providers []dnsblprovider.DNSBLProvider) chan LookupResult {
var wg sync.WaitGroup
results := make(chan LookupResult)
for _, address := range addresses {
for _, provider := range providers {
wg.Add(1)
go func(address string, provider dnsblprovider.DNSBLProvider) {
defer wg.Done()
results <- lookup(address, provider)
}(address, provider)
}
}
go func() {
wg.Wait()
close(results)
}()
return results
}
func processLookupResult(result LookupResult) {
if result.Error != nil {
fmt.Println(fmt.Sprintf("ERR\t%s\t%s\t%s", result.Address, result.Provider.GetName(), result.Error))
return
}
if result.IsBlacklisted {
var reason string
if result.Reason == "" {
reason = "unkown reason"
} else {
reason = result.Reason
}
fmt.Println(fmt.Sprintf("FAIL\t%s\t%s\t%s", result.Address, result.Provider.GetName(), reason))
} else {
fmt.Println(fmt.Sprintf("OK\t%s\t%s", result.Address, result.Provider.GetName()))
}
}
func main() {
var domainsFile = flag.String("p", "", "path to file which stores list of dnsbl checks, empty or - for stdin")
var addressesParam = flag.String("i", "", "IP Address to check, separate by comma for a list")
flag.Parse()
list, err := providerlist.GetProvidersChan(*domainsFile)
if err != nil {
fmt.Fprintln(os.Stderr, "Error reading domains")
os.Exit(1)
}
var providers []dnsblprovider.DNSBLProvider
for item := range list {
provider := dnsblprovider.GeneralProvider{
URL: item,
}
providers = append(providers, provider)
}
addresses := providerlist.GetAddresses(*addressesParam)
for result := range getBlacklists(addresses, providers) {
processLookupResult(result)
}
}