Go/GoLang 범위 내의 IP 주소 확인

Question

Go/GoLang에서 IP 주소가 특정 범위에 있는지 확인하는 가장 빠른 방법은 무엇입니까?

예를 들어 지정된 범위 216.14.49.184에서 216.14.49.191까지 주어진 입력 IP 주소가 해당 범위에 있는지 확인하려면 어떻게해야합니까?

Answer 1

IP 주소는 bigendian []byte 슬라이스 (예 : IP 유형)로 표시되므로 bytes.Compare을 올바르게 비교하면됩니다. https://stackoverflow.com/a/2138724/1655418

그리고 어떤 이유가있는 1ms의를 끝 : 여기 발견 C# 예제의 코드 포팅

1.2.3.4 is NOT between 216.14.49.184 and 216.14.49.191 
216.14.49.185 is between 216.14.49.184 and 216.14.49.191 
1::16 is not an IPv4 address 

Answer 2

을 생산

예 (play)

package main 

import (
    "bytes" 
    "fmt" 
    "net" 
) 

var (
    ip1 = net.ParseIP("216.14.49.184") 
    ip2 = net.ParseIP("216.14.49.191") 
) 

func check(ip string) bool { 
    trial := net.ParseIP(ip) 
    if trial.To4() == nil { 
     fmt.Printf("%v is not an IPv4 address\n", trial) 
     return false 
    } 
    if bytes.Compare(trial, ip1) >= 0 && bytes.Compare(trial, ip2) <= 0 { 
     fmt.Printf("%v is between %v and %v\n", trial, ip1, ip2) 
     return true 
    } 
    fmt.Printf("%v is NOT between %v and %v\n", trial, ip1, ip2) 
    return false 
} 

func main() { 
    check("1.2.3.4") 
    check("216.14.49.185") 
    check("1::16") 
} 

닉의 솔루션보다 빠릅니다.

내 질문은 "가장 빠른"방법이었고, 그래서 나는 광산을 게시하고 커뮤니티가 생각하는 것을 보았습니다.

package iptesting 

import (
    "fmt" 
    "testing" 
    "net" 
    "time" 
    "bytes" 
) 

func TestIPRangeTime(t *testing.T) { 
    lowerBytes := net.ParseIP("216.14.49.184").To4() 
    upperBytes := net.ParseIP("216.14.49.191").To4() 
    inputBytes := net.ParseIP("216.14.49.184").To4() 

    startTime := time.Now() 
    for i := 0; i < 27000; i++ { 
     IsInRange(inputBytes, lowerBytes, upperBytes) 
    } 
    endTime := time.Now() 

    fmt.Println("ELAPSED time port: ", endTime.Sub(startTime)) 

    lower := net.ParseIP("216.14.49.184") 
    upper := net.ParseIP("216.14.49.191") 
    trial := net.ParseIP("216.14.49.184") 

    startTime = time.Now() 
    for i := 0; i < 27000; i++ { 
     IsInRange2(trial, lower, upper) 
    } 
    endTime = time.Now() 

    fmt.Println("ELAPSED time bytescompare: ", endTime.Sub(startTime)) 
} 

func IsInRange2(trial net.IP, lower net.IP, upper net.IP) bool { 
    if bytes.Compare(trial, lower) >= 0 && bytes.Compare(trial, upper) <= 0 { 
     return true 
    } 
    return false 
} 

func IsInRange(ip []byte, lower []byte, upper []byte) bool { 
    //fmt.Printf("given ip len: %d\n", len(ip)) 
    lowerBoundary := true 
    upperBoundary := true 
    for i := 0; i < len(lower) && (lowerBoundary || upperBoundary); i++ { 
     if lowerBoundary && ip[i] < lower[i] || upperBoundary && ip[i] > upper[i] { 
      return false 
     } 

     if ip[i] == lower[i] { 
      if lowerBoundary { 
       lowerBoundary = true 
      } else { 
       lowerBoundary = false 
      } 
      //lowerBoundary &= true 
     } else { 
      lowerBoundary = false 
      //lowerBoundary &= false 
     } 

     if ip[i] == upper[i] { 
      //fmt.Printf("matched upper\n") 
      if upperBoundary { 
       upperBoundary = true 
      } else { 
       upperBoundary = false 
      } 
      //upperBoundary &= true 
     } else { 
      upperBoundary = false 
      //upperBoundary &= false 
     } 
    } 
    return true 
} 

내 결과 :

=== RUN TestIPRangeTime 
ELAPSED time port: 1.0001ms 
ELAPSED time bytescompare: 2.0001ms 
--- PASS: TestIPRangeTime (0.00 seconds) 

=== RUN TestIPRangeTime 
ELAPSED time port: 1ms 
ELAPSED time bytescompare: 2.0002ms 
--- PASS: TestIPRangeTime (0.00 seconds) 

=== RUN TestIPRangeTime 
ELAPSED time port: 1.0001ms 
ELAPSED time bytescompare: 2.0001ms 
--- PASS: TestIPRangeTime (0.00 seconds) 

=== RUN TestIPRangeTime 
ELAPSED time port: 1.0001ms 
ELAPSED time bytescompare: 2.0001ms 
--- PASS: TestIPRangeTime (0.00 seconds) 

Answer 3

어떻게 inet_pton 같은 일부 구현에 대한? 결과를 저장하기 쉽습니다.

func IP2Integer(ip *net.IP) (int64, error) { 
    ip4 := ip.To4() 
    if ip4 == nil { 
     return 0, fmt.Errorf("illegal: %v", ip) 
    } 

    bin := make([]string, len(ip4)) 
    for i, v := range ip4 { 
     bin[i] = fmt.Sprintf("%08b", v) 
    } 
    return strconv.ParseInt(strings.Join(bin, ""), 2, 64) 
} 

Answer 4

ipv4/ipv6의 제네릭 버전입니다.

ip.go :

package ip 

import (
    "bytes" 
    "net" 

    "github.com/golang/glog" 
) 

//test to determine if a given ip is between two others (inclusive) 
func IpBetween(from net.IP, to net.IP, test net.IP) bool { 
    if from == nil || to == nil || test == nil { 
     glog.Warning("An ip input is nil") // or return an error!? 
     return false 
    } 

    from16 := from.To16() 
    to16 := to.To16() 
    test16 := test.To16() 
    if from16 == nil || to16 == nil || test16 == nil { 
     glog.Warning("An ip did not convert to a 16 byte") // or return an error!? 
     return false 
    } 

    if bytes.Compare(test16, from16) >= 0 && bytes.Compare(test16, to16) <= 0 { 
     return true 
    } 
    return false 
} 

및 ip_test.go :

이

package ip 

import (
    "net" 
    "testing" 
) 

func TestIPBetween(t *testing.T) { 
    HandleIpBetween(t, "0.0.0.0", "255.255.255.255", "128.128.128.128", true) 
    HandleIpBetween(t, "0.0.0.0", "128.128.128.128", "255.255.255.255", false) 
    HandleIpBetween(t, "74.50.153.0", "74.50.153.4", "74.50.153.0", true) 
    HandleIpBetween(t, "74.50.153.0", "74.50.153.4", "74.50.153.4", true) 
    HandleIpBetween(t, "74.50.153.0", "74.50.153.4", "74.50.153.5", false) 
    HandleIpBetween(t, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "74.50.153.4", "74.50.153.2", false) 
    HandleIpBetween(t, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:8334", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", true) 
    HandleIpBetween(t, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:8334", "2001:0db8:85a3:0000:0000:8a2e:0370:7350", true) 
    HandleIpBetween(t, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:8334", "2001:0db8:85a3:0000:0000:8a2e:0370:8334", true) 
    HandleIpBetween(t, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", "2001:0db8:85a3:0000:0000:8a2e:0370:8334", "2001:0db8:85a3:0000:0000:8a2e:0370:8335", false) 
    HandleIpBetween(t, "::ffff:192.0.2.128", "::ffff:192.0.2.250", "::ffff:192.0.2.127", false) 
    HandleIpBetween(t, "::ffff:192.0.2.128", "::ffff:192.0.2.250", "::ffff:192.0.2.128", true) 
    HandleIpBetween(t, "::ffff:192.0.2.128", "::ffff:192.0.2.250", "::ffff:192.0.2.129", true) 
    HandleIpBetween(t, "::ffff:192.0.2.128", "::ffff:192.0.2.250", "::ffff:192.0.2.250", true) 
    HandleIpBetween(t, "::ffff:192.0.2.128", "::ffff:192.0.2.250", "::ffff:192.0.2.251", false) 
    HandleIpBetween(t, "::ffff:192.0.2.128", "::ffff:192.0.2.250", "192.0.2.130", true) 
    HandleIpBetween(t, "192.0.2.128", "192.0.2.250", "::ffff:192.0.2.130", true) 
    HandleIpBetween(t, "idonotparse", "192.0.2.250", "::ffff:192.0.2.130", false) 

} 

func HandleIpBetween(t *testing.T, from string, to string, test string, assert bool) { 
    res := IpBetween(net.ParseIP(from), net.ParseIP(to), net.ParseIP(test)) 
    if res != assert { 
     t.Errorf("Assertion (have: %s should be: %s) failed on range %s-%s with test %s", res, assert, from, to, test) 
    } 
} 

Answer 5

이 함수라는 net.Contains과 "그물"패키지의 다음 stdlib 이미 사용 중입니다. 이미 존재하는 코드를 다시 작성할 필요가 없습니다!

문서 here을 참조하십시오.

원하는 서브넷 경우

network := "192.168.5.0/24" 
clientips := []string{ 
    "192.168.5.1", 
    "192.168.6.0", 
} 
_, subnet, _ := net.ParseCIDR(network) 
for _, clientip := range clientips { 
    ip := net.ParseIP(clientip) 
    if subnet.Contains(ip) { 
     fmt.Println("IP in subnet", clientip) 
    } 
} 

여기에 이해가되지 않습니다 위의 코드는 google play link