def isipv4(value):
"""
Return whether or not given value is an IP version 4.
If the value is an IP version 4, this function returns ``True``, otherwise ``False``.
Examples::
>>> isipv4('127.0.0.1')
True
>>> isipv4('::1')
False
:param value: string to validate IP version 4
"""
try:
ip_addr = ipaddress.IPv4Address(value)
except ipaddress.AddressValueError:
return False
return ip_addr.version == 4
python类AddressValueError()的实例源码
def isipv6(value):
"""
Return whether or not given value is an IP version 6.
If the value is an IP version 6, this function returns ``True``, otherwise ``False``.
Examples::
>>> isipv6('2001:41d0:2:a141::1')
True
>>> isipv6('127.0.0.1')
False
:param value: string to validate IP version 6
"""
try:
ip_addr = ipaddress.IPv6Address(value)
except ipaddress.AddressValueError:
return False
return ip_addr.version == 6
def _validate_cidr_format(cidr):
"""Validate CIDR IP range
:param str cidr:
:return:
:rtype: bool
"""
try:
ipaddress.ip_network(cidr, strict=False)
except (ValueError, ipaddress.AddressValueError,
ipaddress.NetmaskValueError):
return False
if '/' not in cidr:
return False
if re.search('\s', cidr):
return False
return True
def convert(self, value, param, ctx):
if value.startswith('ext:'):
ip, _, port = value[4:].partition(':')
try:
IPv4Address(ip.decode('UTF-8', 'ignore'))
except AddressValueError:
self.fail('invalid IP address: {}'.format(ip), param, ctx)
if port:
try:
port = int(port, 0)
except ValueError:
self.fail('invalid port number: {}'.format(port), param, ctx)
else:
port = None
return ip, port
return super(NATChoiceType, self).convert(value, param, ctx)
def parse_autoblock(data):
# type: (str) -> set
def _parse(item):
# Try to parse item as a single IP
try:
ipaddress.IPv4Address(item)
return {item}
except ipaddress.AddressValueError:
pass
# Try parse item as ip range: ip1-ip2
try:
first_ip, last_ip = [utils.ip2int(i) for i in item.split('-')]
return {utils.int2ip(n) for n in range(first_ip, last_ip + 1)}
except ValueError:
raise APIError(
'Exclude IP\'s are expected to be in the form of '
'10.0.0.1,10.0.0.4 or 10.1.0.10-10.1.1.54 or both '
'comma-separated')
ip_sets = (_parse(unicode(d)) for d in data.split(','))
return reduce(operator.or_, ip_sets)
def __init__(self, cmd, addr, port, name, domainname=""):
if cmd not in [0x1, 0x2]:
raise ValueError("cmd should be either command or bind")
try:
addr = ipaddress.IPv4Address(addr)
except ipaddress.AddressValueError:
raise ValueError("Invalid ipaddress format for IPv4")
if int(addr) == 1 and len(domainname) == 0:
raise ValueError("Domain name should be specified when addr is 1")
if not isinstance(name, string_func) or not isinstance(domainname, string_func):
raise ValueError("name or domainname must be a unicode string")
self.cmd = cmd
self.port = port
self.name = name
if domainname:
self.addr = ipaddress.IPv4Address(1)
else:
self.addr = addr
self.domainname = domainname
def __init__(self, cmd, atyp, addr, port):
if cmd not in REQ_COMMAND.values():
raise ValueError("Unsupported request command {}".format(cmd))
if atyp not in ADDR_TYPE.values():
raise ValueError("Unsupported address type {}".format(atyp))
if atyp == ADDR_TYPE["IPV4"]:
try:
addr = ipaddress.IPv4Address(addr)
except ipaddress.AddressValueError:
raise ValueError("Invalid ipaddress format for IPv4")
elif atyp == ADDR_TYPE["IPV6"]:
try:
addr = ipaddress.IPv6Address(addr)
except ipaddress.AddressValueError:
raise ValueError("Invalid ipaddress format for IPv6")
elif atyp == ADDR_TYPE["DOMAINNAME"] and not isinstance(addr, string_func):
raise ValueError("Domain name expect to be unicode string")
self.cmd = cmd
self.atyp = atyp
self.addr = addr
self.port = port
def __init__(self, status, atyp, addr, port):
if status not in RESP_STATUS.values():
raise ValueError("Unsupported status code {}".format(status))
if atyp not in ADDR_TYPE.values():
raise ValueError("Unsupported address type {}".format(atyp))
if atyp == ADDR_TYPE["IPV4"]:
try:
addr = ipaddress.IPv4Address(addr)
except ipaddress.AddressValueError:
raise ValueError("Invalid ipaddress format for IPv4")
elif atyp == ADDR_TYPE["IPV6"]:
try:
addr = ipaddress.IPv6Address(addr)
except ipaddress.AddressValueError:
raise ValueError("Invalid ipaddress format for IPv6")
elif atyp == ADDR_TYPE["DOMAINNAME"] and not isinstance(addr, string_func):
raise ValueError("Domain name expect to be unicode string")
self.status = status
self.atyp = atyp
self.addr = addr
self.port = port
def validate_ip_address(self, address, af=6):
if af == 4:
try:
ipaddress.IPv4Address(address)
return True
except ipaddress.AddressValueError as ex:
logging.error(ex)
elif af == 6:
try:
ipaddress.IPv6Address(address)
return True
except ipaddress.AddressValueError as ex:
logging.error(ex)
else:
raise Exception("Invalid AF: {}".format(af))
return False
def is_ipv4(string):
"""
Checks if a string is a valid ip-address (v4)
:param string: String to check
:type string: str
:return: True if an ip, false otherwise.
:rtype: bool
"""
try:
ipaddress.IPv4Address(string)
return True
except ipaddress.AddressValueError:
return False
def is_ipv6(string):
"""
Checks if a string is a valid ip-address (v6)
:param string: String to check
:type string: str
:return: True if an ipv6, false otherwise.
:rtype: bool
"""
try:
ipaddress.IPv6Address(string)
return True
except ipaddress.AddressValueError:
return False
def validate_ip(addr):
"""Pass-through function for validating an IPv4 address.
Args:
ip: (str) IP address
Returns:
unicode string with same address
Raises:
Error: if IPv4 address is not valid
"""
try:
return ipaddress.IPv4Address(unicode(addr)).compressed
except ipaddress.AddressValueError as exc:
raise Error('Invalid IPv4 address "%s"; %s' % (addr, exc))
def check_if_ipv4address(potential_address):
""" check if ipv4address
this is used in conjunction with the flexible parse function
and determines if the word is an ipaddress in a smart way """
try:
ipaddress.IPv4Interface(potential_address)
return True
except ipaddress.AddressValueError:
return False
def is_ipv6(ip_addr):
try:
ipaddress.IPv6Address(ip_addr)
return True
except ipaddress.AddressValueError:
return False
def ip_isvalid(address):
try:
ipaddress.IPv4Address(address)
return True
except ipaddress.AddressValueError:
return False
def __init__(self, address):
if not isinstance(address, basestring):
message = "Invalid type used in IP initilization: '{}'. Must use a string"
raise TypeError(message.format(type(address).__name__))
if isinstance(address, str):
address = unicode(address)
try:
super(IPv4Address, self).__init__(address)
except ipaddress.AddressValueError as e:
raise ValueError(e)
def address_builder(value):
if isinstance(value, (basestring)):
try:
value = IPv4Interface(unicode(value)).network
except AddressValueError:
message = 'Unsupported string initialization format \'{}\''
message = message.format(value)
raise ValueError(message)
elif not isinstance(value, IPv4Network):
raise_type_exception(value, (IPv4Network, ), 'build with')
return value
def unpack_ip_address_bytes(data_bytes, addr_type):
'''
Return a tuple containing the unpacked addr_type IP address string, and the
remainder of data_bytes.
addr_type must be either IPV4_ADDRESS_TYPE or IPV6_ADDRESS_TYPE.
data_bytes must be at least IPV4_ADDRESS_LEN or IPV6_ADDRESS_LEN long.
'''
addr_len = get_addr_type_len(addr_type)
assert len(data_bytes) >= addr_len
if addr_type == IPV4_ADDRESS_TYPE:
assert addr_len == IPV4_ADDRESS_LEN
(addr_bytes, remaining_bytes) = split_field(addr_len, data_bytes)
# Some ipaddress variants demand bytearray, others demand bytes
try:
addr_value = ipaddress.IPv4Address(bytearray(addr_bytes))
return (str(addr_value), remaining_bytes)
except ipaddress.AddressValueError:
pass
except UnicodeDecodeError:
pass
addr_value = ipaddress.IPv4Address(bytes(addr_bytes))
elif addr_type == IPV6_ADDRESS_TYPE:
assert addr_len == IPV6_ADDRESS_LEN
(addr_bytes, remaining_bytes) = split_field(addr_len, data_bytes)
try:
addr_value = ipaddress.IPv6Address(bytearray(addr_bytes))
return (str(addr_value), remaining_bytes)
except ipaddress.AddressValueError:
pass
except UnicodeDecodeError:
pass
addr_value = ipaddress.IPv6Address(bytes(addr_bytes))
else:
raise ValueError('Unexpected address type: {}'.format(addr_type))
return (str(addr_value), remaining_bytes)
def __next__(self):
"""Get next generated IPv6 address.
"""
current = self.value
if self.iterator >= self.count and self.count != 0:
self.value = self.start_value
self.iterator = 1
else:
ip = ipaddr.IPv6Address(self.value)
try:
hex_ip = hex(int(ip))
part_hex_lo = hex_ip[-8:]
part_hex_hi = hex_ip[0:-8]
int_hex_lo = int(part_hex_lo, 16)
int_lo = int_hex_lo + self.increment
if int_lo > int("FFFFFFFF", 16):
diff = int_lo - int("FFFFFFFF", 16)
int_lo = int("00000000", 16) + diff
if int_lo < int("00000000", 16):
diff = int_lo - int("00000000", 16)
int_lo = int("FFFFFFFF", 16) + diff
part_hex_lo = hex(int_lo)[2:]
new_ip_hex = part_hex_hi + part_hex_lo.zfill(8)
ip = ipaddr.IPv6Address(int(new_ip_hex, 16))
self.value = str(ip)
except ipaddr.AddressValueError:
self.value = self.start_value
self.iterator += 1
return current
def __init__(self, status, addr, port):
if status not in {0x5a, 0x5b, 0x5c, 0x5d}:
raise ValueError("Incorrect status code")
self.status = status
try:
self.addr = ipaddress.IPv4Address(addr)
except ipaddress.AddressValueError:
raise ValueError("Invalid ipaddress format for IPv4")
self.port = port
def __call__(self):
# Remove duplicated values
self.config['whitelist'] = list(set(self.config.get('whitelist', [])))
self.config['blacklist'] = list(set(self.config.get('blacklist', [])))
try:
[
ipaddress.ip_network(ip)
for ip in self.config['whitelist']+self.config['blacklist']
]
except (ipaddress.AddressValueError, ValueError) as err:
raise serializers.ValidationError({
'config': err
})
def get_network_object(prefix):
u = prefix.decode('utf8')
try:
return ipaddress.IPv4Network(u, strict=False)
except (ValueError, ipaddress.AddressValueError, ipaddress.NetmaskValueError):
pass
try:
return ipaddress.IPv6Network(u, strict=False)
except (ValueError, ipaddress.AddressValueError, ipaddress.NetmaskValueError):
return None
def assertAddressError(self, details, *args):
"""Ensure a clean AddressValueError"""
return self.assertCleanError(ipaddress.AddressValueError,
details, *args)
def testEmbeddedIpv4(self):
ipv4_string = '192.168.0.1'
ipv4 = ipaddress.IPv4Interface(ipv4_string)
v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
'2001:1.1.1.1:1.1.1.1')
# Issue 67: IPv6 with embedded IPv4 address not recognized.
def parse_cidr(value):
"""Process cidr ranges."""
klass = IPv4Network
if '/' not in value:
klass = ipaddress.ip_address
try:
v = klass(six.text_type(value))
except (ipaddress.AddressValueError, ValueError):
v = None
return v
def validate(self, data):
try:
if len(data.split('/')) != 2:
raise ValueError('Invalid CIDR syntax')
# need to be unicode for py27
if sys.version_info > (3,):
ipaddress.IPv4Network(data)
else:
ipaddress.IPv4Network(u'{}'.format(data))
except (ValueError, ipaddress.AddressValueError) as e:
raise ValidationError(e)
return {self.field_name: data}
def normalize_tc_value(tc_obj):
import ipaddress
try:
tc_obj.sanitize()
except ipaddress.AddressValueError as e:
logger.error(IPV6_OPTION_ERROR_MSG_FORMAT.format(e))
sys.exit(errno.EINVAL)
except ValueError as e:
logger.error("{:s}: {}".format(e.__class__.__name__, e))
sys.exit(errno.EINVAL)
def sanitize_network(network, ip_version):
"""
:return: Network string
:rtype: str
:raises ValueError: if the network string is invalid.
"""
import ipaddress
if typepy.is_null_string(network) or network.lower() == "anywhere":
return get_anywhere_network(ip_version)
try:
if ip_version == 4:
ipaddress.IPv4Address(network)
return network + "/32"
if ip_version == 6:
return ipaddress.IPv6Address(network).compressed
except ipaddress.AddressValueError:
pass
# validate network str ---
if ip_version == 4:
return ipaddress.IPv4Network(six.text_type(network)).compressed
if ip_version == 6:
return ipaddress.IPv6Network(six.text_type(network)).compressed
raise ValueError("unexpected ip version: {}".format(ip_version))
def assertAddressError(self, details, *args):
"""Ensure a clean AddressValueError"""
return self.assertCleanError(ipaddress.AddressValueError,
details, *args)
def testEmbeddedIpv4(self):
ipv4_string = '192.168.0.1'
ipv4 = ipaddress.IPv4Interface(ipv4_string)
v4compat_ipv6 = ipaddress.IPv6Interface('::%s' % ipv4_string)
self.assertEqual(int(v4compat_ipv6.ip), int(ipv4.ip))
v4mapped_ipv6 = ipaddress.IPv6Interface('::ffff:%s' % ipv4_string)
self.assertNotEqual(v4mapped_ipv6.ip, ipv4.ip)
self.assertRaises(ipaddress.AddressValueError, ipaddress.IPv6Interface,
'2001:1.1.1.1:1.1.1.1')
# Issue 67: IPv6 with embedded IPv4 address not recognized.
