lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2026-04-20 20:49:12 -04:00
Code Issues Releases Wiki Activity

♻️ refactor geoip match logic (#1157)

Browse Source 
cherry-pick f1902165c7
This commit is contained in:
Loyalsoldier
2021-09-10 09:31:25 +01:00
committed by Shelikhoo
parent 1919d47649
commit a86415cb43
6 changed files with 154 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
app/router/condition_geoip.go
View File

@@ -1,176 +1,87 @@
//go:build !confonly
// +build !confonly
package router
import (
"encoding/binary"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"sort"
"strconv"
"inet.af/netaddr"
"github.com/v2fly/v2ray-core/v4/common/net"
)
type ipv6 struct {
a uint64
b uint64
}
type GeoIPMatcher struct {
countryCode string
inverseMatch bool
ip4 []uint32
prefix4 []uint8
ip6 []ipv6
prefix6 []uint8
}
func normalize4(ip uint32, prefix uint8) uint32 {
return (ip >> (32 - prefix)) << (32 - prefix)
}
func normalize6(ip ipv6, prefix uint8) ipv6 {
if prefix <= 64 {
ip.a = (ip.a >> (64 - prefix)) << (64 - prefix)
ip.b = 0
} else {
ip.b = (ip.b >> (128 - prefix)) << (128 - prefix)
}
return ip
reverseMatch bool
ip4 *netaddr.IPSet
ip6 *netaddr.IPSet
}
func (m *GeoIPMatcher) Init(cidrs []*routercommon.CIDR) error {
ip4Count := 0
ip6Count := 0
var builder4, builder6 netaddr.IPSetBuilder
for _, cidr := range cidrs {
ip := cidr.Ip
ip := net.IP(cidr.GetIp())
ipStr := ip.String() + "/" + strconv.Itoa(int(cidr.GetPrefix()))
ipPrefix, err := netaddr.ParseIPPrefix(ipStr)
if err != nil {
return err
}
switch len(ip) {
case 4:
ip4Count++
case 16:
ip6Count++
default:
return newError("unexpect ip length: ", len(ip))
case net.IPv4len:
builder4.AddPrefix(ipPrefix)
case net.IPv6len:
builder6.AddPrefix(ipPrefix)
}
}
cidrList := CIDRList(cidrs)
sort.Sort(&cidrList)
m.ip4 = make([]uint32, 0, ip4Count)
m.prefix4 = make([]uint8, 0, ip4Count)
m.ip6 = make([]ipv6, 0, ip6Count)
m.prefix6 = make([]uint8, 0, ip6Count)
for _, cidr := range cidrs {
ip := cidr.Ip
prefix := uint8(cidr.Prefix)
switch len(ip) {
case 4:
m.ip4 = append(m.ip4, normalize4(binary.BigEndian.Uint32(ip), prefix))
m.prefix4 = append(m.prefix4, prefix)
case 16:
ip6 := ipv6{
a: binary.BigEndian.Uint64(ip[0:8]),
b: binary.BigEndian.Uint64(ip[8:16]),
}
ip6 = normalize6(ip6, prefix)
m.ip6 = append(m.ip6, ip6)
m.prefix6 = append(m.prefix6, prefix)
}
var err error
m.ip4, err = builder4.IPSet()
if err != nil {
return err
}
m.ip6, err = builder6.IPSet()
if err != nil {
return err
}
return nil
}
func (m *GeoIPMatcher) SetReverseMatch(isReverseMatch bool) {
m.inverseMatch = isReverseMatch
m.reverseMatch = isReverseMatch
}
func (m *GeoIPMatcher) match4(ip uint32) bool {
if len(m.ip4) == 0 {
func (m *GeoIPMatcher) match4(ip net.IP) bool {
nip, ok := netaddr.FromStdIP(ip)
if !ok {
return false
}
if ip < m.ip4[0] {
return false
}
size := uint32(len(m.ip4))
l := uint32(0)
r := size
for l < r {
x := ((l + r) >> 1)
if ip < m.ip4[x] {
r = x
continue
}
nip := normalize4(ip, m.prefix4[x])
if nip == m.ip4[x] {
return true
}
l = x + 1
}
return l > 0 && normalize4(ip, m.prefix4[l-1]) == m.ip4[l-1]
return m.ip4.Contains(nip)
}
func less6(a ipv6, b ipv6) bool {
return a.a < b.a || (a.a == b.a && a.b < b.b)
}
func (m *GeoIPMatcher) match6(ip ipv6) bool {
if len(m.ip6) == 0 {
func (m *GeoIPMatcher) match6(ip net.IP) bool {
nip, ok := netaddr.FromStdIP(ip)
if !ok {
return false
}
if less6(ip, m.ip6[0]) {
return false
}
size := uint32(len(m.ip6))
l := uint32(0)
r := size
for l < r {
x := (l + r) / 2
if less6(ip, m.ip6[x]) {
r = x
continue
}
if normalize6(ip, m.prefix6[x]) == m.ip6[x] {
return true
}
l = x + 1
}
return l > 0 && normalize6(ip, m.prefix6[l-1]) == m.ip6[l-1]
return m.ip6.Contains(nip)
}
// Match returns true if the given ip is included by the GeoIP.
func (m *GeoIPMatcher) Match(ip net.IP) bool {
isMatched := false
switch len(ip) {
case 4:
if m.inverseMatch {
return !m.match4(binary.BigEndian.Uint32(ip))
}
return m.match4(binary.BigEndian.Uint32(ip))
case 16:
if m.inverseMatch {
return !m.match6(ipv6{
a: binary.BigEndian.Uint64(ip[0:8]),
b: binary.BigEndian.Uint64(ip[8:16]),
})
}
return m.match6(ipv6{
a: binary.BigEndian.Uint64(ip[0:8]),
b: binary.BigEndian.Uint64(ip[8:16]),
})
default:
return false
case net.IPv4len:
isMatched = m.match4(ip)
case net.IPv6len:
isMatched = m.match6(ip)
}
if m.reverseMatch {
return !isMatched
}
return isMatched
}
// GeoIPMatcherContainer is a container for GeoIPMatchers. It keeps unique copies of GeoIPMatcher by country code.
@@ -181,9 +92,9 @@ type GeoIPMatcherContainer struct {
// Add adds a new GeoIP set into the container.
// If the country code of GeoIP is not empty, GeoIPMatcherContainer will try to find an existing one, instead of adding a new one.
func (c *GeoIPMatcherContainer) Add(geoip *routercommon.GeoIP) (*GeoIPMatcher, error) {
if len(geoip.CountryCode) > 0 {
if geoip.CountryCode != "" {
for _, m := range c.matchers {
if m.countryCode == geoip.CountryCode && m.inverseMatch == geoip.InverseMatch {
if m.countryCode == geoip.CountryCode && m.reverseMatch == geoip.InverseMatch {
return m, nil
}
}
@@ -191,12 +102,12 @@ func (c *GeoIPMatcherContainer) Add(geoip *routercommon.GeoIP) (*GeoIPMatcher, e
m := &GeoIPMatcher{
countryCode: geoip.CountryCode,
inverseMatch: geoip.InverseMatch,
reverseMatch: geoip.InverseMatch,
}
if err := m.Init(geoip.Cidr); err != nil {
return nil, err
}
if len(geoip.CountryCode) > 0 {
if geoip.CountryCode != "" {
c.matchers = append(c.matchers, m)
}
return m, nil