복붙노트

[PYTHON] IP가 파이썬 2.x에서 네트워크에 있는지 어떻게 확인할 수 있습니까?

PYTHON

IP가 파이썬 2.x에서 네트워크에 있는지 어떻게 확인할 수 있습니까?

IP 주소 (192.168.0.1)가 주어지면 파이썬에서 네트워크 (192.168.0.0/24)에 있는지 어떻게 확인합니까?

IP 주소 조작을위한 파이썬의 일반적인 도구가 있습니까? 호스트 조회와 같은 항목, int에 대한 ipadddress, int에 대한 넷 마스크가있는 네트워크 주소 등? 다행히 표준 파이썬 라이브러리 2.5.

해결법

  1. ==============================

    1.이 기사에서는 너무 많은 노력을 기울이지 않고도 소켓 및 구조 모듈을 사용하여 작업을 수행 할 수 있음을 보여줍니다. 다음과 같이 기사에 조금 추가했습니다.

    이 기사에서는 너무 많은 노력을 기울이지 않고도 소켓 및 구조 모듈을 사용하여 작업을 수행 할 수 있음을 보여줍니다. 다음과 같이 기사에 조금 추가했습니다.

    import socket,struct

def makeMask(n):
    "return a mask of n bits as a long integer"
    return (2L<<n-1) - 1

def dottedQuadToNum(ip):
    "convert decimal dotted quad string to long integer"
    return struct.unpack('L',socket.inet_aton(ip))[0]

def networkMask(ip,bits):
    "Convert a network address to a long integer" 
    return dottedQuadToNum(ip) & makeMask(bits)

def addressInNetwork(ip,net):
   "Is an address in a network"
   return ip & net == net

address = dottedQuadToNum("192.168.1.1")
networka = networkMask("10.0.0.0",24)
networkb = networkMask("192.168.0.0",24)
print (address,networka,networkb)
print addressInNetwork(address,networka)
print addressInNetwork(address,networkb)

    이 결과는 다음과 같습니다.

    False
True

    문자열을 취하는 단일 함수를 원한다면 다음과 같이 보일 것입니다 :

    import socket,struct

def addressInNetwork(ip,net):
   "Is an address in a network"
   ipaddr = struct.unpack('L',socket.inet_aton(ip))[0]
   netaddr,bits = net.split('/')
   netmask = struct.unpack('L',socket.inet_aton(netaddr))[0] & ((2L<<int(bits)-1) - 1)
   return ipaddr & netmask == netmask
  2. ==============================

    2.netaddr을 사용하고 싶습니다.

    netaddr을 사용하고 싶습니다.

    from netaddr import CIDR, IP

if IP("192.168.0.1") in CIDR("192.168.0.0/24"):
    print "Yay!"

    arno_v가 주석에서 지적했듯이, netaddr의 새로운 버전은 다음과 같이 그것을합니다 :

    from netaddr import IPNetwork, IPAddress
if IPAddress("192.168.0.1") in IPNetwork("192.168.0.0/24"):
    print "Yay!"
  3. ==============================

    3.ipaddress 사용 (3.3 이후의 stdlib에서, 2.6 / 2.7 용 PyPi에서) :

    ipaddress 사용 (3.3 이후의 stdlib에서, 2.6 / 2.7 용 PyPi에서) :

    >>> import ipaddress
>>> ipaddress.ip_address('192.168.0.1') in ipaddress.ip_network('192.168.0.0/24')
True

    이런 식으로 많은 IP 주소를 평가하려면 netmask upfront를 계산하는 것이 좋습니다.

    n = ipaddress.ip_network('192.0.0.0/16')
netw = int(n.network_address)
mask = int(n.netmask)

    그런 다음 각 주소에 대해 다음 중 하나를 사용하여 이진 표현을 계산합니다.

    a = int(ipaddress.ip_address('192.0.43.10'))
a = struct.unpack('!I', socket.inet_pton(socket.AF_INET, '192.0.43.10'))[0]
a = struct.unpack('!I', socket.inet_aton('192.0.43.10'))[0]  # IPv4 only

    마지막으로, 다음을 간단하게 확인할 수 있습니다.

    in_network = (a & mask) == netw
  4. ==============================

    4.이 코드는 Linux x86에서 작동합니다. 나는 endianess 문제에 대해 정말로 생각해 보지 못했지만, 8 개의 다른 네트워크 문자열에 대해 테스트 된 200K 이상의 IP 주소를 사용하는 "ipaddr"모듈에 대해 테스트했으며 ipaddr의 결과는이 코드와 동일합니다.

    이 코드는 Linux x86에서 작동합니다. 나는 endianess 문제에 대해 정말로 생각해 보지 못했지만, 8 개의 다른 네트워크 문자열에 대해 테스트 된 200K 이상의 IP 주소를 사용하는 "ipaddr"모듈에 대해 테스트했으며 ipaddr의 결과는이 코드와 동일합니다.

    def addressInNetwork(ip, net):
   import socket,struct
   ipaddr = int(''.join([ '%02x' % int(x) for x in ip.split('.') ]), 16)
   netstr, bits = net.split('/')
   netaddr = int(''.join([ '%02x' % int(x) for x in netstr.split('.') ]), 16)
   mask = (0xffffffff << (32 - int(bits))) & 0xffffffff
   return (ipaddr & mask) == (netaddr & mask)

    예:

    >>> print addressInNetwork('10.9.8.7', '10.9.1.0/16')
True
>>> print addressInNetwork('10.9.8.7', '10.9.1.0/24')
False
  5. ==============================

    5.Dave Webb의 솔루션을 시도했지만 몇 가지 문제가 발생했습니다.

    Dave Webb의 솔루션을 시도했지만 몇 가지 문제가 발생했습니다.

    가장 근본적으로 - IP 주소를 마스크와 AND 연산 한 다음 네트워크 주소와 정확히 일치하는 결과를 확인하여 일치 여부를 확인해야합니다. IP 주소와 네트워크 주소를 ANDing하지 않았습니다.

    또한 일관성을 유지한다고 가정하면 엔디안 동작을 무시하는 것이 옥 테트 경계 (/ 24, / 16)의 마스크에서만 작동한다는 것을 알았습니다. 올바르게 작동하는 다른 마스크 (/ 23, / 21)를 얻으려면 struct 명령에 "greater than"을 추가하고 바이너리 마스크를 만들기위한 코드를 "1"로 시작하고 왼쪽으로 이동 (32 마스크 ).

    마지막으로 네트워크 주소가 마스크에 유효한지 간단한 체크를 추가하고 그렇지 않은 경우 경고를 출력합니다.

    결과는 다음과 같습니다.

    def addressInNetwork(ip,net):
    "Is an address in a network"
    ipaddr = struct.unpack('>L',socket.inet_aton(ip))[0]
    netaddr,bits = net.split('/')
    netmask = struct.unpack('>L',socket.inet_aton(netaddr))[0]
    ipaddr_masked = ipaddr & (4294967295<<(32-int(bits)))   # Logical AND of IP address and mask will equal the network address if it matches
    if netmask == netmask & (4294967295<<(32-int(bits))):   # Validate network address is valid for mask
            return ipaddr_masked == netmask
    else:
            print "***WARNING*** Network",netaddr,"not valid with mask /"+bits
            return ipaddr_masked == netmask
  6. ==============================

    6.나는 그들이 필요하지 않을 때 모듈을 사용하는 팬이 아니다. 이 직업은 간단한 수학 만 필요하므로 여기 간단한 일을 할 수 있습니다.

    나는 그들이 필요하지 않을 때 모듈을 사용하는 팬이 아니다. 이 직업은 간단한 수학 만 필요하므로 여기 간단한 일을 할 수 있습니다.

    def ipToInt(ip):
    o = map(int, ip.split('.'))
    res = (16777216 * o[0]) + (65536 * o[1]) + (256 * o[2]) + o[3]
    return res

def isIpInSubnet(ip, ipNetwork, maskLength):
    ipInt = ipToInt(ip)#my test ip, in int form

    maskLengthFromRight = 32 - maskLength

    ipNetworkInt = ipToInt(ipNetwork) #convert the ip network into integer form
    binString = "{0:b}".format(ipNetworkInt) #convert that into into binary (string format)

    chopAmount = 0 #find out how much of that int I need to cut off
    for i in range(maskLengthFromRight):
        if i < len(binString):
            chopAmount += int(binString[len(binString)-1-i]) * 2**i

    minVal = ipNetworkInt-chopAmount
    maxVal = minVal+2**maskLengthFromRight -1

    return minVal <= ipInt and ipInt <= maxVal

    그런 다음 그것을 사용하십시오 :

    >>> print isIpInSubnet('66.151.97.0', '66.151.97.192',24) 
True
>>> print isIpInSubnet('66.151.97.193', '66.151.97.192',29) 
True
>>> print isIpInSubnet('66.151.96.0', '66.151.97.192',24) 
False
>>> print isIpInSubnet('66.151.97.0', '66.151.97.192',29)

    즉, 위의 솔루션보다 훨씬 빠릅니다.

  7. ==============================

    7.받아 들인 대답은 작동하지 않아 ... 나를 화나게하고있다. 마스크는 역방향이며 간단한 8 비트 블록 (예 : / 24)이 아닌 비트는 작동하지 않습니다. 나는 그 해답을 적용했고, 잘 작동한다.

    받아 들인 대답은 작동하지 않아 ... 나를 화나게하고있다. 마스크는 역방향이며 간단한 8 비트 블록 (예 : / 24)이 아닌 비트는 작동하지 않습니다. 나는 그 해답을 적용했고, 잘 작동한다.

        import socket,struct

    def addressInNetwork(ip, net_n_bits):  
      ipaddr = struct.unpack('!L', socket.inet_aton(ip))[0]
      net, bits = net_n_bits.split('/')
      netaddr = struct.unpack('!L', socket.inet_aton(net))[0]
      netmask = (0xFFFFFFFF >> int(bits)) ^ 0xFFFFFFFF
      return ipaddr & netmask == netaddr

    다음은 마스킹을 시각화하는 데 도움이되는 점으로 구분 된 이진 문자열을 반환하는 함수입니다. ipcalc 출력과 비슷합니다.

        def bb(i):
     def s = '{:032b}'.format(i)
     def return s[0:8]+"."+s[8:16]+"."+s[16:24]+"."+s[24:32]

    예 :

  8. ==============================

    8.마크의 코드가 거의 정확합니다. 코드의 완전한 버전은 -

    마크의 코드가 거의 정확합니다. 코드의 완전한 버전은 -

    def addressInNetwork3(ip,net):
    '''This function allows you to check if on IP belogs to a Network'''
    ipaddr = struct.unpack('=L',socket.inet_aton(ip))[0]
    netaddr,bits = net.split('/')
    netmask = struct.unpack('=L',socket.inet_aton(calcDottedNetmask(int(bits))))[0]
    network = struct.unpack('=L',socket.inet_aton(netaddr))[0] & netmask
    return (ipaddr & netmask) == (network & netmask)

def calcDottedNetmask(mask):
    bits = 0
    for i in xrange(32-mask,32):
        bits |= (1 << i)
    return "%d.%d.%d.%d" % ((bits & 0xff000000) >> 24, (bits & 0xff0000) >> 16, (bits & 0xff00) >> 8 , (bits & 0xff))

    분명히 위와 같은 소스에서 ...

    아주 중요한 사실은 첫 번째 코드에는 작은 결함이 있다는 것입니다. IP 주소 255.255.255.255는 모든 서브넷의 유효한 IP로도 나타납니다. 이 코드를 작동 시키는데 시간이 많이 걸렸고 정답 인 Marc에게 감사의 말을 전합니다.

  9. ==============================

    9.표준 라이브러리 2.5는 아니지만 ipaddr은 이것을 매우 쉽게 만듭니다. 나는 이것이 ipaddress라는 이름으로 3.3에 있다고 믿는다.

    표준 라이브러리 2.5는 아니지만 ipaddr은 이것을 매우 쉽게 만듭니다. 나는 이것이 ipaddress라는 이름으로 3.3에 있다고 믿는다.

    import ipaddr

a = ipaddr.IPAddress('192.168.0.1')
n = ipaddr.IPNetwork('192.168.0.0/24')

#This will return True
n.Contains(a)
  10. ==============================

    10.파이썬 3

    파이썬 3

    In [64]: ipaddress.IPv4Address('192.168.1.1') in ipaddress.IPv4Network('192.168.0.0/24')
Out[64]: False
  11. ==============================

    11.

    >>> from netaddr import all_matching_cidrs
>>> all_matching_cidrs("212.11.70.34", ["192.168.0.0/24","212.11.64.0/19"] )
[IPNetwork('212.11.64.0/19')]

    이 메소드의 사용법은 다음과 같습니다.

    >>> help(all_matching_cidrs)

Help on function all_matching_cidrs in module netaddr.ip:

all_matching_cidrs(ip, cidrs)
    Matches an IP address or subnet against a given sequence of IP addresses and subnets.

    @param ip: a single IP address or subnet.

    @param cidrs: a sequence of IP addresses and/or subnets.

    @return: all matching IPAddress and/or IPNetwork objects from the provided
    sequence, an empty list if there was no match.

    기본적으로 첫 번째 인수로 ip 주소를 제공하고 두 번째 인수로 cidrs 목록을 제공합니다. 히트 목록이 반환됩니다.

  12. ==============================

    12.

    #This works properly without the weird byte by byte handling
def addressInNetwork(ip,net):
    '''Is an address in a network'''
    # Convert addresses to host order, so shifts actually make sense
    ip = struct.unpack('>L',socket.inet_aton(ip))[0]
    netaddr,bits = net.split('/')
    netaddr = struct.unpack('>L',socket.inet_aton(netaddr))[0]
    # Must shift left an all ones value, /32 = zero shift, /0 = 32 shift left
    netmask = (0xffffffff << (32-int(bits))) & 0xffffffff
    # There's no need to mask the network address, as long as its a proper network address
    return (ip & netmask) == netaddr
  13. ==============================

    13.선택한 대답에 버그가 있습니다.

    선택한 대답에 버그가 있습니다.

    올바른 코드는 다음과 같습니다.

    def addressInNetwork(ip, net_n_bits):
   ipaddr = struct.unpack('<L', socket.inet_aton(ip))[0]
   net, bits = net_n_bits.split('/')
   netaddr = struct.unpack('<L', socket.inet_aton(net))[0]
   netmask = ((1L << int(bits)) - 1)
   return ipaddr & netmask == netaddr & netmask

    참고 : ipaddr & netmask == netaddr & netmask 대신 ipaddr & netmask == netmask.

    또한 ((1L << int (bits)) - 1)로 ((2L << int (bits) -1) - 1)을 대체 할 수 있습니다.

  14. ==============================

    14.가장 긴 접두어 일치를 위해 쓴 클래스는 다음과 같습니다.

    가장 긴 접두어 일치를 위해 쓴 클래스는 다음과 같습니다.

    #!/usr/bin/env python

class Node:
def __init__(self):
    self.left_child = None
    self.right_child = None
    self.data = "-"

def setData(self, data): self.data = data
def setLeft(self, pointer): self.left_child = pointer
def setRight(self, pointer): self.right_child = pointer
def getData(self): return self.data
def getLeft(self): return self.left_child
def getRight(self): return self.right_child

def __str__(self):
        return "LC: %s RC: %s data: %s" % (self.left_child, self.right_child, self.data)


class LPMTrie:      

def __init__(self):
    self.nodes = [Node()]
    self.curr_node_ind = 0

def addPrefix(self, prefix):
    self.curr_node_ind = 0
    prefix_bits = ''.join([bin(int(x)+256)[3:] for x in prefix.split('/')[0].split('.')])
    prefix_length = int(prefix.split('/')[1])
    for i in xrange(0, prefix_length):
        if (prefix_bits[i] == '1'):
            if (self.nodes[self.curr_node_ind].getRight()):
                self.curr_node_ind = self.nodes[self.curr_node_ind].getRight()
            else:
                tmp = Node()
                self.nodes[self.curr_node_ind].setRight(len(self.nodes))
                tmp.setData(self.nodes[self.curr_node_ind].getData());
                self.curr_node_ind = len(self.nodes)
                self.nodes.append(tmp)
        else:
            if (self.nodes[self.curr_node_ind].getLeft()):
                self.curr_node_ind = self.nodes[self.curr_node_ind].getLeft()
            else:
                tmp = Node()
                self.nodes[self.curr_node_ind].setLeft(len(self.nodes))
                tmp.setData(self.nodes[self.curr_node_ind].getData());
                self.curr_node_ind = len(self.nodes)
                self.nodes.append(tmp)

        if i == prefix_length - 1 :
            self.nodes[self.curr_node_ind].setData(prefix)

def searchPrefix(self, ip):
    self.curr_node_ind = 0
    ip_bits = ''.join([bin(int(x)+256)[3:] for x in ip.split('.')])
    for i in xrange(0, 32):
        if (ip_bits[i] == '1'):
            if (self.nodes[self.curr_node_ind].getRight()):
                self.curr_node_ind = self.nodes[self.curr_node_ind].getRight()
            else:
                return self.nodes[self.curr_node_ind].getData()
        else:
            if (self.nodes[self.curr_node_ind].getLeft()):
                self.curr_node_ind = self.nodes[self.curr_node_ind].getLeft()
            else:
                return self.nodes[self.curr_node_ind].getData()

    return None

def triePrint(self):
    n = 1
    for i in self.nodes:
        print n, ':'
        print i
        n += 1

    다음은 테스트 프로그램입니다.

    n=LPMTrie()
n.addPrefix('10.25.63.0/24')
n.addPrefix('10.25.63.0/16')
n.addPrefix('100.25.63.2/8')
n.addPrefix('100.25.0.3/16')
print n.searchPrefix('10.25.63.152')
print n.searchPrefix('100.25.63.200')
#10.25.63.0/24
#100.25.0.3/16
  15. ==============================

    15."struct"모듈을 사용하면 endian-ness 및 type 크기에 문제가 발생할 수 있으며 필요하지 않습니다. socket.inet_aton ()도 아니다. 파이썬은 dotted-quad IP 주소로 매우 잘 작동합니다 :

    "struct"모듈을 사용하면 endian-ness 및 type 크기에 문제가 발생할 수 있으며 필요하지 않습니다. socket.inet_aton ()도 아니다. 파이썬은 dotted-quad IP 주소로 매우 잘 작동합니다 :

    def ip_to_u32(ip):
  return int(''.join('%02x' % int(d) for d in ip.split('.')), 16)

    각 소켓 accept () 호출에서 허용 가능한 소스 네트워크 전체에 대해 IP 일치를 수행해야하므로 마스크 및 네트워크를 정수로 미리 계산합니다.

    SNS_SOURCES = [
  # US-EAST-1
  '207.171.167.101',
  '207.171.167.25',
  '207.171.167.26',
  '207.171.172.6',
  '54.239.98.0/24',
  '54.240.217.16/29',
  '54.240.217.8/29',
  '54.240.217.64/28',
  '54.240.217.80/29',
  '72.21.196.64/29',
  '72.21.198.64/29',
  '72.21.198.72',
  '72.21.217.0/24',
  ]

def build_masks():
  masks = [ ]
  for cidr in SNS_SOURCES:
    if '/' in cidr:
      netstr, bits = cidr.split('/')
      mask = (0xffffffff << (32 - int(bits))) & 0xffffffff
      net = ip_to_u32(netstr) & mask
    else:
      mask = 0xffffffff
      net = ip_to_u32(cidr)
    masks.append((mask, net))
  return masks

    그런 다음 해당 IP가 해당 네트워크에 속하는지 신속하게 확인할 수 있습니다.

    ip = ip_to_u32(ipstr)
for mask, net in cached_masks:
  if ip & mask == net:
    # matched!
    break
else:
  raise BadClientIP(ipstr)

    모듈 가져 오기가 필요하지 않으며 코드 일치가 매우 빠릅니다.

  16. ==============================

    16.스크립트를 가져 주셔서 감사합니다! 나는 모든 것을 작동하게 만들기 위해 꽤 오래 일했다. 그래서 나는 그것을 여기에서 공유하고있다.

    스크립트를 가져 주셔서 감사합니다! 나는 모든 것을 작동하게 만들기 위해 꽤 오래 일했다. 그래서 나는 그것을 여기에서 공유하고있다.

    
#!/usr/bin/python
>>> calcDottedNetmask(21)
>>> '255.255.248.0'

    
#!/usr/bin/python
>>> addressInNetwork('188.104.8.64','172.16.0.0/12')
>>>True which is completely WRONG!!

    그래서 내 새로운 addressInNetwork 함수는 다음과 같습니다.

    
#!/usr/bin/python
import socket,struct
def addressInNetwork(ip,net):
    '''This function allows you to check if on IP belogs to a Network'''
    ipaddr = struct.unpack('=L',socket.inet_aton(ip))[0]
    netaddr,bits = net.split('/')
    netmask = struct.unpack('=L',socket.inet_aton(calcDottedNetmask(bits)))[0]
    network = struct.unpack('=L',socket.inet_aton(netaddr))[0] & netmask
    return (ipaddr & netmask) == (network & netmask)

def calcDottedNetmask(mask):
    bits = 0
    for i in xrange(32-int(mask),32):
        bits |= (1 > 24, (bits & 0xff0000) >> 16, (bits & 0xff00) >> 8 , (bits & 0xff))

    그리고 지금, 대답은 옳습니다 !!

    
#!/usr/bin/python
>>> addressInNetwork('188.104.8.64','172.16.0.0/12')
False

    다른 사람들에게 도움이되기를 바랍니다. 시간을 절약하십시오!

  17. ==============================

    17.위의 모든 관련, socket.inet_aton () 네트워크 순서로 바이트를 반환합니다, 그래서 그들을 압축하는 올바른 방법은 아마도 것 같아요

    위의 모든 관련, socket.inet_aton () 네트워크 순서로 바이트를 반환합니다, 그래서 그들을 압축하는 올바른 방법은 아마도 것 같아요

    struct.unpack('!L', ... )
  18. ==============================

    18.이전 솔루션은 ip & net == net에 버그가 있습니다. 올바른 IP 조회는 ip & netmask = net입니다.

    이전 솔루션은 ip & net == net에 버그가 있습니다. 올바른 IP 조회는 ip & netmask = net입니다.

    버그 수정 코드 :

    import socket
import struct

def makeMask(n):
    "return a mask of n bits as a long integer"
    return (2L<<n-1) - 1

def dottedQuadToNum(ip):
    "convert decimal dotted quad string to long integer"
    return struct.unpack('L',socket.inet_aton(ip))[0]

def addressInNetwork(ip,net,netmask):
   "Is an address in a network"
   print "IP "+str(ip) + " NET "+str(net) + " MASK "+str(netmask)+" AND "+str(ip & netmask)
   return ip & netmask == net

def humannetcheck(ip,net):
        address=dottedQuadToNum(ip)
        netaddr=dottedQuadToNum(net.split("/")[0])
        netmask=makeMask(long(net.split("/")[1]))
        return addressInNetwork(address,netaddr,netmask)


print humannetcheck("192.168.0.1","192.168.0.0/24");
print humannetcheck("192.169.0.1","192.168.0.0/24");
  19. ==============================

    19.이 작업을 잘 수행하는 Python에서 사용할 수있는 SubnetTree라는 API가 있습니다. 이것은 간단한 예입니다.

    이 작업을 잘 수행하는 Python에서 사용할 수있는 SubnetTree라는 API가 있습니다. 이것은 간단한 예입니다.

    import SubnetTree
t = SubnetTree.SubnetTree()
t.insert("10.0.1.3/32")
print("10.0.1.3" in t)

    이것은 링크입니다.

  20. ==============================

    20.

    import socket,struct
def addressInNetwork(ip,net):
    "Is an address in a network"
    ipaddr = struct.unpack('!L',socket.inet_aton(ip))[0]
    netaddr,bits = net.split('/')
    netaddr = struct.unpack('!L',socket.inet_aton(netaddr))[0]
    netmask = ((1<<(32-int(bits))) - 1)^0xffffffff
    return ipaddr & netmask == netaddr & netmask
print addressInNetwork('10.10.10.110','10.10.10.128/25')
print addressInNetwork('10.10.10.110','10.10.10.0/25')
print addressInNetwork('10.10.10.110','10.20.10.128/25')

    $ python check-subnet.py 그릇된 참된 그릇된

  21. ==============================

    21.나는 표준 라이브러리에서 아무 것도 모른다. 그러나 PySubnetTree는 서브넷 매칭을 할 파이썬 라이브러리이다.

    나는 표준 라이브러리에서 아무 것도 모른다. 그러나 PySubnetTree는 서브넷 매칭을 할 파이썬 라이브러리이다.

  22. ==============================

    22.위의 여러 소스와 내 자신의 연구에서 서브넷과 주소 계산이 작동하는 방식입니다. 이 조각들은 질문 및 기타 관련 질문을 해결하기에 충분합니다.

    위의 여러 소스와 내 자신의 연구에서 서브넷과 주소 계산이 작동하는 방식입니다. 이 조각들은 질문 및 기타 관련 질문을 해결하기에 충분합니다.

    class iptools:
    @staticmethod
    def dottedQuadToNum(ip):
        "convert decimal dotted quad string to long integer"
        return struct.unpack('>L', socket.inet_aton(ip))[0]

    @staticmethod
    def numToDottedQuad(n):
        "convert long int to dotted quad string"
        return socket.inet_ntoa(struct.pack('>L', n))

    @staticmethod
    def makeNetmask(mask):
        bits = 0
        for i in xrange(32-int(mask), 32):
            bits |= (1 << i)
        return bits

    @staticmethod
    def ipToNetAndHost(ip, maskbits):
        "returns tuple (network, host) dotted-quad addresses given"
        " IP and mask size"
        # (by Greg Jorgensen)
        n = iptools.dottedQuadToNum(ip)
        m = iptools.makeMask(maskbits)
        net = n & m
        host = n - mask
        return iptools.numToDottedQuad(net), iptools.numToDottedQuad(host)
  23. ==============================

    23.여기 내 코드가있다.

    여기 내 코드가있다.

    # -*- coding: utf-8 -*-
import socket


class SubnetTest(object):
    def __init__(self, network):
        self.network, self.netmask = network.split('/')
        self._network_int = int(socket.inet_aton(self.network).encode('hex'), 16)
        self._mask = ((1L << int(self.netmask)) - 1) << (32 - int(self.netmask))
        self._net_prefix = self._network_int & self._mask

    def match(self, ip):
        '''
        判断传入的 IP 是不是本 Network 内的 IP
        '''
        ip_int = int(socket.inet_aton(ip).encode('hex'), 16)
        return (ip_int & self._mask) == self._net_prefix

st = SubnetTest('100.98.21.0/24')
print st.match('100.98.23.32')
  24. ==============================

    24.함께 갈 수있는 다른 모듈을 가져 오지 않으려면 다음을 수행하십시오.

    함께 갈 수있는 다른 모듈을 가져 오지 않으려면 다음을 수행하십시오.

    def ip_matches_network(self, network, ip):
    """
    '{:08b}'.format(254): Converts 254 in a string of its binary representation

    ip_bits[:net_mask] == net_ip_bits[:net_mask]: compare the ip bit streams

    :param network: string like '192.168.33.0/24'
    :param ip: string like '192.168.33.1'
    :return: if ip matches network
    """
    net_ip, net_mask = network.split('/')
    net_mask = int(net_mask)
    ip_bits = ''.join('{:08b}'.format(int(x)) for x in ip.split('.'))
    net_ip_bits = ''.join('{:08b}'.format(int(x)) for x in net_ip.split('.'))
    # example: net_mask=24 -> compare strings at position 0 to 23
    return ip_bits[:net_mask] == net_ip_bits[:net_mask]
  25. ==============================

    25.나는이 해답들에서 제안 된 해법들의 한 부분 집합을 시도했다. 성공하지 못하고, 마침내 제안 된 코드를 수정하고 고정 시켰고, 고정 된 함수를 썼다.

    나는이 해답들에서 제안 된 해법들의 한 부분 집합을 시도했다. 성공하지 못하고, 마침내 제안 된 코드를 수정하고 고정 시켰고, 고정 된 함수를 썼다.

    테스트를 마치고 최소한 리틀 엔디안 아키텍처 (예 : xx86)에서 작동합니다. 빅 엔디안 아키텍처를 사용하고 싶다면 의견을 보내주십시오.

    IP2Int 코드는이 게시물에서 비롯되었으며 다른 방법은이 테스트에서 이전 제안서를 완전히 수정 한 것입니다.

    코드:

    def IP2Int(ip):
    o = map(int, ip.split('.'))
    res = (16777216 * o[0]) + (65536 * o[1]) + (256 * o[2]) + o[3]
    return res


def addressInNetwork(ip, net_n_bits):
    ipaddr = IP2Int(ip)
    net, bits = net_n_bits.split('/')
    netaddr = IP2Int(net)
    bits_num = int(bits)
    netmask = ((1L << bits_num) - 1) << (32 - bits_num)
    return ipaddr & netmask == netaddr & netmask

    희망 유용한,

    26. from https://stackoverflow.com/questions/819355/how-can-i-check-if-an-ip-is-in-a-network-in-python-2-x by cc-by-sa and MIT license

'PYTHON' 카테고리의 다른 글

[PYTHON] HttpResponse를 장고로 스트리밍하는 법  (0) 2018.10.03
[PYTHON] 파이썬으로 Quicksort  (0) 2018.10.03
[PYTHON] id () 함수는 무엇을 위해 사용됩니까?  (0) 2018.10.03
[PYTHON] 파이썬에서는 YAML 매핑을 OrderedDicts로 어떻게로드 할 수 있습니까?  (0) 2018.10.03
[PYTHON] numpy 배열을 통해 함수를 매핑하는 가장 효율적인 방법  (0) 2018.10.03
,

티스토리툴바