iplist/iplist_test.go

   1 package iplist
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "fmt"
   7         "net"
   8         "strings"
   9         "testing"
  10
  11         "github.com/anacrolix/missinggo"
  12         "github.com/bradfitz/iter"
  13         "github.com/stretchr/testify/assert"
  14         "github.com/stretchr/testify/require"
  15 )
  16
  17 var (
  18         // Note the shared description "eff". The overlapping ranges at 1.2.8.2
  19         // will cause problems. Don't overlap your ranges.
  20         sample = `
  21 # List distributed by iblocklist.com
  22
  23 a:1.2.4.0-1.2.4.255
  24 b:1.2.8.0-1.2.8.255
  25 eff:1.2.8.2-1.2.8.2
  26 something:more detail:86.59.95.195-86.59.95.195
  27 eff:127.0.0.0-127.0.0.1`
  28         packedSample []byte
  29 )
  30
  31 func init() {
  32         var buf bytes.Buffer
  33         list, err := NewFromReader(strings.NewReader(sample))
  34         if err != nil {
  35                 panic(err)
  36         }
  37         err = list.WritePacked(&buf)
  38         if err != nil {
  39                 panic(err)
  40         }
  41         packedSample = buf.Bytes()
  42 }
  43
  44 func TestIPv4RangeLen(t *testing.T) {
  45         ranges, _ := sampleRanges(t)
  46         for i := range iter.N(3) {
  47                 if len(ranges[i].First) != 4 {
  48                         t.FailNow()
  49                 }
  50                 if len(ranges[i].Last) != 4 {
  51                         t.FailNow()
  52                 }
  53         }
  54 }
  55
  56 func sampleRanges(tb testing.TB) (ranges []Range, err error) {
  57         scanner := bufio.NewScanner(strings.NewReader(sample))
  58         for scanner.Scan() {
  59                 r, ok, err := ParseBlocklistP2PLine(scanner.Bytes())
  60                 if err != nil {
  61                         tb.Fatal(err)
  62                 }
  63                 if ok {
  64                         ranges = append(ranges, r)
  65                 }
  66         }
  67         err = scanner.Err()
  68         return
  69 }
  70
  71 func BenchmarkParseP2pBlocklist(b *testing.B) {
  72         for i := 0; i < b.N; i++ {
  73                 sampleRanges(b)
  74         }
  75 }
  76
  77 func connRemoteAddrIP(network, laddr string, dialHost string) net.IP {
  78         l, err := net.Listen(network, laddr)
  79         if err != nil {
  80                 panic(err)
  81         }
  82         go func() {
  83                 c, err := net.Dial(network, net.JoinHostPort(dialHost, fmt.Sprintf("%d", missinggo.AddrPort(l.Addr()))))
  84                 if err != nil {
  85                         panic(err)
  86                 }
  87                 defer c.Close()
  88         }()
  89         c, err := l.Accept()
  90         if err != nil {
  91                 panic(err)
  92         }
  93         defer c.Close()
  94         ret := missinggo.AddrIP(c.RemoteAddr())
  95         return ret
  96 }
  97
  98 func TestBadIP(t *testing.T) {
  99         for _, iplist := range []Ranger{
 100                 New(nil),
 101                 NewFromPacked([]byte("\x00\x00\x00\x00\x00\x00\x00\x00")),
 102         } {
 103                 assert.Nil(t, iplist.Lookup(net.IP(make([]byte, 4))), "%v", iplist)
 104                 assert.Nil(t, iplist.Lookup(net.IP(make([]byte, 16))))
 105                 assert.Equal(t, iplist.Lookup(nil).Description, "bad IP")
 106                 assert.NotNil(t, iplist.Lookup(net.IP(make([]byte, 5))))
 107         }
 108 }
 109
 110 func testLookuperSimple(t *testing.T, iplist Ranger) {
 111         for _, _case := range []struct {
 112                 IP   string
 113                 Hit  bool
 114                 Desc string
 115         }{
 116                 {"1.2.3.255", false, ""},
 117                 {"1.2.8.0", true, "b"},
 118                 {"1.2.4.255", true, "a"},
 119                 // Try to roll over to the next octet on the parse. Note the final
 120                 // octet is overbounds. In the next case.
 121                 {"1.2.7.256", true, "bad IP"},
 122                 {"1.2.8.1", true, "b"},
 123                 {"1.2.8.2", true, "eff"},
 124         } {
 125                 ip := net.ParseIP(_case.IP)
 126                 r := iplist.Lookup(ip)
 127                 if !_case.Hit {
 128                         if r != nil {
 129                                 t.Fatalf("got hit when none was expected: %s", ip)
 130                         }
 131                         continue
 132                 }
 133                 if r == nil {
 134                         t.Fatalf("expected hit for %q", _case.IP)
 135                 }
 136                 assert.Equal(t, _case.Desc, r.Description, "%T", iplist)
 137         }
 138 }
 139
 140 func TestSimple(t *testing.T) {
 141         ranges, err := sampleRanges(t)
 142         require.NoError(t, err)
 143         require.Len(t, ranges, 5)
 144         iplist := New(ranges)
 145         testLookuperSimple(t, iplist)
 146         packed := NewFromPacked(packedSample)
 147         testLookuperSimple(t, packed)
 148 }