我们从Python开源项目中,提取了以下41个代码示例,用于说明如何使用ipaddress.AddressValueError()。
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
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 chose_blacklist(self, ip): """ Given an IP address, figure out the ipset we have to use. If the address is an IPv4, we have to use *rig_blacklist4*. If the address is an IPv6, we have to use *rig_blacklist6*. Raises ipaddress.AddressValueError if the address is neither an IPv4 nor an IPv6. """ blacklist = 'rig_blacklist{0}' try: address = ipaddress.ip_address(ip) except ipaddress.AddressValueError: raise else: if address.version is 6: # We don't ban private IPv6: if address.is_private: msg = "We don't ban private addresses ({0} given)." \ .format(address) raise ipaddress.AddressValueError(msg) else: # Do we have an embedded IPv4 ? if address.ipv4_mapped is not None: address = address.ipv4_mapped elif address.sixtofour is not None: address = address.sixtofour blacklist = blacklist.format(address.version) return (address, blacklist)
def get_client_ip(request): ip = get_real_ip(request) if ip: try: interface = ipaddress.IPv6Interface('%s/%i' % (ip, settings.IPV6_PRIVACY_MASK)) except ipaddress.AddressValueError: interface = ipaddress.IPv4Interface('%s/%i' % (ip, settings.IPV4_PRIVACY_MASK)) return str(interface.network.network_address) else: return None
def __call__(self, value): try: import ipaddress except ImportError: from gluon.contrib import ipaddr as ipaddress try: ip = ipaddress.IPv6Address(value.decode('utf-8')) ok = True except ipaddress.AddressValueError: return (value, translate(self.error_message)) if self.subnets: # iterate through self.subnets to see if value is a member ok = False if isinstance(self.subnets, str): self.subnets = [self.subnets] for network in self.subnets: try: ipnet = ipaddress.IPv6Network(network.decode('utf-8')) except (ipaddress.NetmaskValueError, ipaddress.AddressValueError): return (value, translate('invalid subnet provided')) if ip in ipnet: ok = True if self.is_routeable: self.is_private = False self.is_link_local = False self.is_reserved = False self.is_multicast = False if not (self.is_private is None or self.is_private == ip.is_private): ok = False if not (self.is_link_local is None or self.is_link_local == ip.is_link_local): ok = False if not (self.is_reserved is None or self.is_reserved == ip.is_reserved): ok = False if not (self.is_multicast is None or self.is_multicast == ip.is_multicast): ok = False if not (self.is_6to4 is None or self.is_6to4 == ip.is_6to4): ok = False if not (self.is_teredo is None or self.is_teredo == ip.is_teredo): ok = False if ok: return (value, None) return (value, translate(self.error_message))
def __call__(self, value): try: import ipaddress except ImportError: from contrib import ipaddr as ipaddress try: ip = ipaddress.IPv6Address(value) ok = True except ipaddress.AddressValueError: return (value, translate(self.error_message)) if self.subnets: # iterate through self.subnets to see if value is a member ok = False if isinstance(self.subnets, str): self.subnets = [self.subnets] for network in self.subnets: try: ipnet = ipaddress.IPv6Network(network) except (ipaddress.NetmaskValueError, ipaddress.AddressValueError): return (value, translate('invalid subnet provided')) if ip in ipnet: ok = True if self.is_routeable: self.is_private = False self.is_link_local = False self.is_reserved = False self.is_multicast = False if not (self.is_private is None or self.is_private == ip.is_private): ok = False if not (self.is_link_local is None or self.is_link_local == ip.is_link_local): ok = False if not (self.is_reserved is None or self.is_reserved == ip.is_reserved): ok = False if not (self.is_multicast is None or self.is_multicast == ip.is_multicast): ok = False if not (self.is_6to4 is None or self.is_6to4 == ip.is_6to4): ok = False if not (self.is_teredo is None or self.is_teredo == ip.is_teredo): ok = False if ok: return (value, None) return (value, translate(self.error_message))
def post(self): """Method to create a gateway""" host = self.args['host'] name = self.args['name'] eui = self.args['eui'] enabled = self.args['enabled'] power = self.args['power'] message = {} # Check for required args required = {'host', 'name', 'eui', 'enabled', 'power'} for r in required: if self.args[r] is None: message[r] = "Missing the {} parameter.".format(r) if message: abort(400, message=message) # Ensure we have a valid address try: ipaddress.ip_address(host) except (ipaddress.AddressValueError, ValueError): message = {'error': "Invalid IP address {} ".format(host)} abort(400, message=message) # Ensure we have a valid EUI if not isinstance(eui, (int, long)): message = {'error': "Invalid gateway EUI {} ".format(eui)} abort(400, message=message) # Check this gateway does not currently exist exists = yield Gateway.exists(where=['host = ?', host]) if exists: message = {'error': "Gateway address {} ".format(host) + \ "currently exists."} abort(400, message=message) # Check the EUI does not currently exist exists = yield Gateway.exists(where=['eui = ?', eui]) if exists: message = {'error': "Gateway EUI {} ".format(eui) + \ "currently exists."} abort(400, message=message) # Create and validate gateway = Gateway(host=host, eui=eui, name=name, enabled=enabled, power=power) (valid, message) = gateway.valid() if not valid: abort(400, message=message) try: g = yield gateway.save() if g is None: abort(500, message={'error': "Error saving the gateway."}) # Add the new gateway to the server. self.server.lora.addGateway(g) location = self.restapi.api.prefix + '/gateway/' + str(host) returnValue(({}, 201, {'Location': location})) except TimeoutError: # Exception returns 500 to client log.error("REST API timeout for gateway POST request")
def __call__(self, value): try: import ipaddress except ImportError: from gluon.contrib import ipaddr as ipaddress try: ip = ipaddress.IPv6Address(value) ok = True except ipaddress.AddressValueError: return (value, translate(self.error_message)) if self.subnets: # iterate through self.subnets to see if value is a member ok = False if isinstance(self.subnets, str): self.subnets = [self.subnets] for network in self.subnets: try: ipnet = ipaddress.IPv6Network(network) except (ipaddress.NetmaskValueError, ipaddress.AddressValueError): return (value, translate('invalid subnet provided')) if ip in ipnet: ok = True if self.is_routeable: self.is_private = False self.is_link_local = False self.is_reserved = False self.is_multicast = False if not (self.is_private is None or self.is_private == ip.is_private): ok = False if not (self.is_link_local is None or self.is_link_local == ip.is_link_local): ok = False if not (self.is_reserved is None or self.is_reserved == ip.is_reserved): ok = False if not (self.is_multicast is None or self.is_multicast == ip.is_multicast): ok = False if not (self.is_6to4 is None or self.is_6to4 == ip.is_6to4): ok = False if not (self.is_teredo is None or self.is_teredo == ip.is_teredo): ok = False if ok: return (value, None) return (value, translate(self.error_message))