반응형
Python의 네트워크에 IP가 어디에 있는지 확인할 수 있습니까?
IP 주소 (예 : 192.168.0.1)가 주어지면 Python의 네트워크 (예 : 192.168.0.0/24)에 어떻게 확인하는지?
Python에 IP 주소 조작을위한 일반적인 도구가 있습니까? 호스트 조회, int에 대한 ip 주소, int에 대한 넷 마스크가있는 네트워크 주소 같은 것들? 바라건대 2.5 용 표준 Python 라이브러리에 있습니다.
기사이 에서는 추가 노력없이 및 모듈로 이를 수행 할 수 있음을 보여줍니다 . 다음과 같이 기사에 약간의 추가했습니다.socketstruct
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
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!"
사용 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 주소 를 평가 하려면 다음과 같이 넷 마스크를 미리 계산하는 것이 좋습니다.
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
python3의 경우
In [64]: ipaddress.IPv4Address('192.168.1.1') in ipaddress.IPv4Network('192.168.0.0/24')
Out[64]: False
이 코드는 Linux x86에서 나를 위해 작동합니다. 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
Dave Webb의 솔루션을 시도했지만 몇 가지 문제가 발생했습니다.
가장 근본적으로-일치 여부는 IP 주소를 마스크와 AND로 연결 한 다음 결과가 네트워크 주소와 정확히 일치하는지 확인해야합니다. IP 주소와 네트워크 주소를 AND로 처리하지 않습니다.
또한 일관성이 낭비 가정하에 Endian 동작을 무시하는 것만으로도 옥텟 경계 (/ 24, / 16)의 마스크에 작업 할 수 있음을 알았습니다. 다른 마스크 (/ 23, / 21)가 만드는 작동하도록하기 위해하기 명령에 "보다 큼"을 추가하고 바이너리 마스크를 코드를 "1"로 시작하고 모든 작업으로 (32-mask).
마지막으로 네트워크 주소가 마스크에 유효한지 확인하고있는 경우 경고 만 인쇄합니다.
결과는 다음과 가변적입니다.
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
나는 사용하는 것을 좋아하지 않을 것입니다. 이 작업에는 간단한 수학 만 필요하는 다음은 작업을 수행하는 간단한 기능입니다.
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)
사용하는 위의 솔루션보다 훨씬 빠를 사용합니다.
받아 들여진 대답이 작동하지 ... 이로 인해 화가납니다. 마스크는 역방향이며 단순한 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]
예 :
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)
Marc의 코드는 거의 있습니다. 코드의 전체 버전은 다음과 가변합니다.
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에게 감사드립니다.
"struct"는 배열에 의존하면 엔디안 및 유형 크기에 문제가있을 수 있고 필요하지 않습니다. socket.inet_aton ()도 아닙니다. Python은 점으로 구분 된 쿼드 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)
모듈 가져 오기가 필요하지 않습니다. 코드는 일치하는 데 매우 빠릅니다.
netaddr에서 가져 오기 오기 all_matching_cidrs
>>> 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 주소를 첫 번째 인수로 제공하고 cidr 목록을 두 번째 인수로 제공합니다. 적중 목록이 반환됩니다.
#이 바이트 처리에 의한 이상한 바이트없이 작동합니다.
def addressInNetwork (ip, net) :
'' '네트워크의 주소입니다' ''
# 주소를 호스트 순서로 변환 시프트가 실제로 의미가 있습니다.
ip = struct.unpack ( '> L', socket.inet_aton (ip)) [0]
netaddr, 비트 = net.split ( '/')
netaddr = struct.unpack ( '> L', socket.inet_aton (netaddr)) [0]
# 모두 1의 값으로 이동해야 함, / 32 = 0으로 이동, / 0 = 32로 이동해야 함
넷 마스크 = (0xffffffff << (32-int (비트))) & 0xffffffff
# 네트워크 주소 만 있으면 네트워크 주소를 마스킹 할 필요가 없습니다.
return (ip & netmask) == netaddr
선택한 답변에는 버그가 있습니다.
다음은 올바른 코드입니다.
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.
또한 교체 ((2L<<int(bits)-1) - 1)와 ((1L << int(bits)) - 1)후가 더 많이 보인다.
다음은 가장 큰 접두사 일치를 위해 긴 클래스입니다.
#!/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
펼쳐 감사합니다!
나는 모든 것을 작동시키기 위해 오랫동안 노력했습니다 ... 그래서 여기에서 공유하고 있습니다.
- netaddr 클래스를 사용하는 것은 바이너리 변환을 사용하는 것보다 10 배 더 느리 수준 큰 IP 목록에서 사용하는 netaddr 클래스를 사용하지 않는 것이 좋습니다.
makeMask 기능이 작동하지 않습니다! / 8, / 16, / 24 만 작동 함
예 :비트 = "21"; socket.inet_ntoa (struct.pack ( '= L', (2L << int (bits) -1) -1))
'255.255.31.0'이지만 255.255.248.0은 필수입니다.그래서 http://code.activestate.com/recipes/576483-convert-subnetmask-from-cidr-notation-to-dotdecima/ 에서 다른 함수 calcDottedNetmask (mask)를 사용했습니다 .
예 :
#!/usr/bin/python
>>> calcDottedNetmask(21)
>>> '255.255.248.0'
- 또 다른 문제는 IP가 네트워크에있는 경우 일치하는 프로세스입니다! 기본 동작은 (ipaddr & netmask)와 (network & netmask)를 비교하는 것입니다.
예 : 당분간 기능이 잘못되었습니다.
#!/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
다른 사람들에게 도움이되고 시간을 절약 할 수 있기 때문에 바랍니다!
위의 모든 것과 관련하여 socket.inet_aton ()은 네트워크 순서로 바이트를 반환 생각 올바른 압축 해제 방법은 아마도
struct.unpack('!L', ... )
이전 솔루션에는 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");
이 작업을 매우 잘 수행하는 Python에서 사용할 수있는 SubnetTree라는 API가 있습니다. 다음은 간단한 예입니다.
import SubnetTree
t = SubnetTree.SubnetTree()
t.insert("10.0.1.3/32")
print("10.0.1.3" in t)
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
False
True
False
표준 라이브러리에서는 아무것도 모르지만 PySubnetTree 는 서브넷 일치를 수행하는 Python 라이브러리입니다.
위의 다양한 출처와 내 연구에서 서브넷 및 주소 계산이 작동하는 방법입니다. 이 조각들은 질문을 해결하고 기타 관련 질문을 해결합니다.
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)
내 코드는 다음과 달라집니다.
# -*- 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')
다른 모듈을 가져 오기 오지면 다음을 사용할 수 있습니다.
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]
이 답변에서 제안 된 솔루션 중 하나를 시도했습니다. 성공하지 못한 상태에서 마침내 제안 된 코드를 수정하고 한 후 고정 함수를 작성했습니다.
나는 그것을 테스트하고 응답 리틀 엔디안 아키텍처 (egx86)에서 작동합니다. 누군가 빅 엔디안 아키텍처를 시도해보고 있습니다.
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
유용한 희망,
참고 URL : https://stackoverflow.com/questions/819355/how-can-i-check-if-an-ip-is-in-a-network-in-python
반응형
'IT' 카테고리의 다른 글
| EditText, 외부 터치에 대한 명확한 증가 (0) | 2020.09.08 |
|---|---|
| AppDelegate에서 UINavigationBar 배경색을 변경하는 방법 (0) | 2020.09.08 |
| Eclipse에서 AVD 또는 SDK 관리자를 사용할 수 없습니다. (0) | 2020.09.08 |
| Ruby on Rails : rake db : migrate 마이그레이션을 되돌리려면 어떻게해야합니까? (0) | 2020.09.08 |
| 모바일 사파리 탭과 같은 UIScrollView 수평 페이징 (0) | 2020.09.08 |