def is_address_in_network(network, address):
"""
Determine whether the provided address is within a network range.
:param network (str): CIDR presentation format. For example,
'192.168.1.0/24'.
:param address: An individual IPv4 or IPv6 address without a net
mask or subnet prefix. For example, '192.168.1.1'.
:returns boolean: Flag indicating whether address is in network.
"""
try:
network = netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
try:
address = netaddr.IPAddress(address)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Address (%s) is not in correct presentation format" %
address)
if address in network:
return True
else:
return False
python类AddrFormatError()的实例源码
def _parse_values(self, values):
""" Parses values init arg. for responses with IPs fields.
Similar parser as parent, but takes str & unicode fields and
trys converting them to IPNetwork objects.
"""
for k, v in values.items():
if k != 'custom_fields':
if isinstance(v, dict):
lookup = getattr(self.__class__, k, None)
if lookup:
v = lookup(v, api_kwargs=self.api_kwargs)
else:
v = self.default_ret(v, api_kwargs=self.api_kwargs)
if isinstance(v, six.string_types):
try:
v = netaddr.IPNetwork(v)
except netaddr.AddrFormatError:
pass
self._add_cache((k, v))
else:
self._add_cache((k, v.copy()))
setattr(self, k, v)
def is_valid_cidr(address):
"""Verify that address represents a valid CIDR address.
:param address: Value to verify
:type address: string
:returns: bool
.. versionadded:: 3.8
"""
try:
# Validate the correct CIDR Address
netaddr.IPNetwork(address)
except (TypeError, netaddr.AddrFormatError):
return False
# Prior validation partially verify /xx part
# Verify it here
ip_segment = address.split('/')
if (len(ip_segment) <= 1 or
ip_segment[1] == ''):
return False
return True
def get_ip_network(ip_str):
"""
Try to return the owner of the IP address (based on ips.py)
:param str ip_str: The IP address
:rtype: str
:return: The owner if find else None
"""
try:
ip_addr = netaddr.IPAddress(ip_str)
except (netaddr.AddrConversionError, netaddr.AddrFormatError):
return None
for brand, networks in IPS_NETWORKS.iteritems():
for net in networks:
if net.netmask.value & ip_addr.value == net.value:
return brand
return None
def test_strategy_ipv6_str_to_int_behaviour_legacy_mode():
assert ipv6.str_to_int('::127') == 295
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::0x7f')
assert ipv6.str_to_int('::0177') == 375
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::127.1')
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::0x7f.1')
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::0177.1')
assert ipv6.str_to_int('::127.0.0.1') == 2130706433
def test_strategy_inet_pton_behaviour():
# inet_pton() is a newer system call that supports both IPv4 and IPv6.
# It is a lot more strict about what it deems to be a valid IPv4 address
# and doesn't support many of the features found in inet_aton() such as
# support for non- decimal octets, partial numbers of octets, etc.
with pytest.raises(AddrFormatError):
ipv4.str_to_int('127', flags=INET_PTON)
with pytest.raises(AddrFormatError):
ipv4.str_to_int('0x7f', flags=INET_PTON)
with pytest.raises(AddrFormatError):
ipv4.str_to_int('0177', flags=INET_PTON)
with pytest.raises(AddrFormatError):
ipv4.str_to_int('127.1', flags=INET_PTON)
with pytest.raises(AddrFormatError):
ipv4.str_to_int('0x7f.1', flags=INET_PTON)
with pytest.raises(AddrFormatError):
ipv4.str_to_int('0177.1', flags=INET_PTON)
assert ipv4.str_to_int('127.0.0.1', flags=INET_PTON) == 2130706433
def test_ipaddress_inet_pton_constructor_v4():
with pytest.raises(AddrFormatError):
IPAddress('0177.01', flags=INET_PTON)
with pytest.raises(AddrFormatError):
IPAddress('0x7f.0.01', flags=INET_PTON)
with pytest.raises(AddrFormatError):
IPAddress('10', flags=INET_PTON)
with pytest.raises(AddrFormatError):
IPAddress('10.1', flags=INET_PTON)
with pytest.raises(AddrFormatError):
IPAddress('10.0.1', flags=INET_PTON)
assert IPAddress('10.0.0.1', flags=INET_PTON) == IPAddress('10.0.0.1')
def test_iprange_constructor():
iprange = IPRange('192.0.2.1', '192.0.2.254')
assert iprange == IPRange('192.0.2.1', '192.0.2.254')
assert '%s' % iprange == '192.0.2.1-192.0.2.254'
assert IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254') == IPRange('::ffff:192.0.2.1', '::ffff:192.0.2.254')
assert IPRange('192.0.2.1', '192.0.2.1') == IPRange('192.0.2.1', '192.0.2.1')
assert IPRange('208.049.164.000', '208.050.066.255', flags=ZEROFILL) == IPRange('208.49.164.0', '208.50.66.255')
with pytest.raises(AddrFormatError):
IPRange('192.0.2.2', '192.0.2.1')
with pytest.raises(AddrFormatError):
IPRange('::', '0.0.0.1')
with pytest.raises(AddrFormatError):
IPRange('0.0.0.0', '::1')
def get_ipv6_addr_by_EUI64(cidr, mac):
"""Generate a IPv6 addr by EUI-64 with CIDR and MAC
:param str cidr: a IPv6 CIDR
:param str mac: a MAC address
:return: an IPv6 Address
:rtype: netaddr.IPAddress
"""
# Check if the prefix is IPv4 address
is_ipv4 = netaddr.valid_ipv4(cidr)
if is_ipv4:
msg = "Unable to generate IP address by EUI64 for IPv4 prefix"
raise TypeError(msg)
try:
eui64 = int(netaddr.EUI(mac).eui64())
prefix = netaddr.IPNetwork(cidr)
return netaddr.IPAddress(prefix.first + eui64 ^ (1 << 57))
except (ValueError, netaddr.AddrFormatError):
raise TypeError('Bad prefix or mac format for generating IPv6 '
'address by EUI-64: %(prefix)s, %(mac)s:'
% {'prefix': cidr, 'mac': mac})
except TypeError:
raise TypeError('Bad prefix type for generate IPv6 address by '
'EUI-64: %s' % cidr)
def sendWoL(mac, broadcast=findBroadcast()):
"""Given string mac and broadcast: Turn on computer using WoL
This was taken from http://code.activestate.com/recipes/358449-wake-on-lan/. Thanks, Fadly!
"""
# Cleans and removes delimiters from MAC
try:
mac = format_mac(EUI(mac), mac_bare)
except AddrFormatError:
raise ValueError('Incorrect MAC address format')
# Pad the synchronization stream.
data = ''.join(['FFFFFFFFFFFF', mac * 20])
send_data = b''
# Split up the hex values and pack.
for i in range(0, len(data), 2):
send_data = b''.join([send_data, pack('B', int(data[i: i + 2], 16))])
# Broadcast it to the LAN.
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.sendto(send_data, (broadcast, 7))
def _validate_cidr_format(self, cidr, logger):
"""Validate that CIDR have a correct format. Example "10.10.10.10/24"
:param str cidr:
:param logging.Logger logger:
:return: True/False whether CIDR is valid or not
:rtype: bool
"""
try:
netaddr.IPNetwork(cidr)
except netaddr.AddrFormatError:
logger.info("CIDR {} is in invalid format", exc_info=1)
return False
if '/' not in cidr:
return False
return True
def _to_mac_range(val):
cidr_parts = val.split("/")
prefix = cidr_parts[0]
# FIXME(anyone): replace is slow, but this doesn't really
# get called ever. Fix maybe?
prefix = prefix.replace(':', '')
prefix = prefix.replace('-', '')
prefix_length = len(prefix)
if prefix_length < 6 or prefix_length > 12:
raise q_exc.InvalidMacAddressRange(cidr=val)
diff = 12 - len(prefix)
if len(cidr_parts) > 1:
mask = int(cidr_parts[1])
else:
mask = 48 - diff * 4
mask_size = 1 << (48 - mask)
prefix = "%s%s" % (prefix, "0" * diff)
try:
cidr = "%s/%s" % (str(netaddr.EUI(prefix)).replace("-", ":"), mask)
except netaddr.AddrFormatError:
raise q_exc.InvalidMacAddressRange(cidr=val)
prefix_int = int(prefix, base=16)
return cidr, prefix_int, prefix_int + mask_size
def fallback_ip(self):
if self._values['fallback_ip'] is None:
return None
if self._values['fallback_ip'] == 'any':
return 'any'
try:
address = IPAddress(self._values['fallback_ip'])
if address.version == 4:
return str(address.ip)
elif address.version == 6:
return str(address.ip)
return None
except AddrFormatError:
raise F5ModuleError(
'The provided fallback address is not a valid IPv4 address'
)
def address(self, value):
pattern = '^(?P<ip>[0-9A-Fa-f:.]+)%?(?P<rd>\d+)?\/(?P<nm>\d+)$'
matches = re.match(pattern, value)
if not matches:
raise F5ModuleError(
"The specified address is malformed. Please see documentation."
)
try:
ip = matches.group('ip')
self._values['ip'] = str(IPAddress(ip))
except AddrFormatError:
raise F5ModuleError(
'The provided address is not a valid IP address'
)
self._values['route_domain'] = matches.group('rd')
self._values['netmask'] = matches.group('nm')
def netmask(self):
if self.want.netmask is None:
return None
try:
address = IPNetwork(self.have.ip)
if self.want.route_domain is not None:
nipnet = "{0}%{1}/{2}".format(address.ip, self.want.route_domain, self.want.netmask)
cipnet = "{0}%{1}/{2}".format(address.ip, self.want.route_domain, self.have.netmask)
elif self.have.route_domain is not None:
nipnet = "{0}%{1}/{2}".format(address.ip, self.have.route_domain, self.want.netmask)
cipnet = "{0}%{1}/{2}".format(address.ip, self.have.route_domain, self.have.netmask)
else:
nipnet = "{0}/{1}".format(address.ip, self.want.netmask)
cipnet = "{0}/{1}".format(address.ip, self.have.netmask)
if nipnet != cipnet:
return nipnet
except AddrFormatError:
raise F5ModuleError(
'The provided address/netmask value "{0}" was invalid'.format(self.have.ip)
)
def route_domain(self):
if self.want.route_domain is None:
return None
try:
address = IPNetwork(self.have.ip)
if self.want.netmask is not None:
nipnet = "{0}%{1}/{2}".format(address.ip, self.want.route_domain, self.want.netmask)
cipnet = "{0}%{1}/{2}".format(address.ip, self.have.route_domain, self.want.netmask)
elif self.have.netmask is not None:
nipnet = "{0}%{1}/{2}".format(address.ip, self.want.route_domain, self.have.netmask)
cipnet = "{0}%{1}/{2}".format(address.ip, self.have.route_domain, self.have.netmask)
if nipnet != cipnet:
return nipnet
except AddrFormatError:
raise F5ModuleError(
'The provided address/netmask value was invalid'
)
def fallback_ip(self):
if self._values['fallback_ip'] is None:
return None
if self._values['fallback_ip'] == 'any':
return 'any'
if self._values['fallback_ip'] == 'any6':
return 'any6'
try:
address = IPAddress(self._values['fallback_ip'])
if address.version == 4:
return str(address.ip)
elif address.version == 6:
return str(address.ip)
return None
except AddrFormatError:
raise F5ModuleError(
'The provided fallback address is not a valid IPv4 address'
)
def test_strategy_ipv6_str_to_int_behaviour_legacy_mode():
assert ipv6.str_to_int('::127') == 295
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::0x7f')
assert ipv6.str_to_int('::0177') == 375
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::127.1')
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::0x7f.1')
with pytest.raises(AddrFormatError):
ipv6.str_to_int('::0177.1')
assert ipv6.str_to_int('::127.0.0.1') == 2130706433
def _validate_cidr(network):
try:
netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
def is_ipv6(address):
"""Determine whether provided address is IPv6 or not."""
try:
address = netaddr.IPAddress(address)
except netaddr.AddrFormatError:
# probably a hostname - so not an address at all!
return False
return address.version == 6
def _validate_cidr(network):
try:
netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
def is_ipv6(address):
"""Determine whether provided address is IPv6 or not."""
try:
address = netaddr.IPAddress(address)
except netaddr.AddrFormatError:
# probably a hostname - so not an address at all!
return False
return address.version == 6
def is_address_in_network(network, address):
"""
Determine whether the provided address is within a network range.
:param network (str): CIDR presentation format. For example,
'192.168.1.0/24'.
:param address: An individual IPv4 or IPv6 address without a net
mask or subnet prefix. For example, '192.168.1.1'.
:returns boolean: Flag indicating whether address is in network.
"""
try:
network = netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
try:
address = netaddr.IPAddress(address)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Address (%s) is not in correct presentation format" %
address)
if address in network:
return True
else:
return False
def is_ip(address):
"""
Returns True if address is a valid IP address.
"""
try:
# Test to see if already an IPv4/IPv6 address
address = netaddr.IPAddress(address)
return True
except (netaddr.AddrFormatError, ValueError):
return False
def _validate_cidr(network):
try:
netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
def is_address_in_network(network, address):
"""
Determine whether the provided address is within a network range.
:param network (str): CIDR presentation format. For example,
'192.168.1.0/24'.
:param address: An individual IPv4 or IPv6 address without a net
mask or subnet prefix. For example, '192.168.1.1'.
:returns boolean: Flag indicating whether address is in network.
"""
try:
network = netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
try:
address = netaddr.IPAddress(address)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Address (%s) is not in correct presentation format" %
address)
if address in network:
return True
else:
return False
def is_ip(address):
"""
Returns True if address is a valid IP address.
"""
try:
# Test to see if already an IPv4/IPv6 address
address = netaddr.IPAddress(address)
return True
except (netaddr.AddrFormatError, ValueError):
return False
def _validate_cidr(network):
try:
netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
def is_ipv6(address):
"""Determine whether provided address is IPv6 or not."""
try:
address = netaddr.IPAddress(address)
except netaddr.AddrFormatError:
# probably a hostname - so not an address at all!
return False
return address.version == 6
def is_address_in_network(network, address):
"""
Determine whether the provided address is within a network range.
:param network (str): CIDR presentation format. For example,
'192.168.1.0/24'.
:param address: An individual IPv4 or IPv6 address without a net
mask or subnet prefix. For example, '192.168.1.1'.
:returns boolean: Flag indicating whether address is in network.
"""
try:
network = netaddr.IPNetwork(network)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Network (%s) is not in CIDR presentation format" %
network)
try:
address = netaddr.IPAddress(address)
except (netaddr.core.AddrFormatError, ValueError):
raise ValueError("Address (%s) is not in correct presentation format" %
address)
if address in network:
return True
else:
return False
