Python IPy.parseAddress方法代码示例

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def mod_change_cache(zona=None, rr=None, rtype=None, ttl=1800, data=None, action=None, username=None, del_id=None, operation=None):
    """Modify the publish queue"""
    zone_id = zones.select().where(zones.zone == zona).get()
    if rtype == "A" or rtype == "NS":
        try:
            IPy.parseAddress(data)
        except ValueError:
            return False

    if operation == "add_unpub":
        for item in [zona, rr, rtype, ttl, data, action, operation]:
            if item is None:
                return False

        if change_cache.select().where(change_cache.rr == rr,
                                       change_cache.zone_id == zone_id,
                                       change_cache.type == rtype,
                                       change_cache.data == data,
                                       change_cache.action == "add").count():
                return True
        change_cache.create(username=username,
                            rr=rr,
                            zone_id=zone_id,
                            type=rtype,
                            ttl=ttl,
                            data=data,
                            action=action)
        return True

    elif operation == "del_unpub":
        delete_query = change_cache.delete().where((change_cache.id == del_id) & (change_cache.zone_id == zone_id))
        delete_query.execute()
        return True

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def multi_ipcheck(form, field):
    error = []
    for x in field.data.split():
        try:
            IPy.parseAddress(x)
        except ValueError:
            error.append( x )

    if error:
        raise ValidationError( _('Error IP: %s') % error )

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
 def testRandomValuesv6(self):
     for i in range(testloops):
         question = ((random.randrange(0x7fffffff) + random.randrange(0x7fffffff)) +
                     ((random.randrange(0x7fffffff) + random.randrange(0x7fffffff)) << 32) +
                     ((random.randrange(0x7fffffff) + random.randrange(0x7fffffff)) << 64) +
                     ((random.randrange(0x7fffffff) + random.randrange(0x7fffffff)) << 96))
         self.assertEqual(IPy.parseAddress(IPy.intToIp(question, 6)), (question, 6), hex(question))

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def check_ip_address(address, version=None):
    try:
        _ip, ver = IPy.parseAddress(address)
    except ValueError:
        return False
    if version and version == ver:
        return True

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def ip_version_validator(value, version, message):
	try:
		ip, v = IPy.parseAddress(value)
	except ValueError:
		raise forms.ValidationError(message)
	if v != version:
		raise forms.ValidationError(message)

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
 def query(self, sql):
     print "executing sql : " + sql
     self.cur.execute(sql)
     alldata = self.cur.fetchall()
     if alldata:
         for data in alldata:
             eid = IPy.parseAddress(data[0])
             #print eid
             print data[0], data[1]
     return alldata

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def address_check(address):
    '''
    Check if the IP address is valid.

    :param str address: IP address to check
    :return: tuple of (address, version), where address is cleaned up IP address
             and version is 4 for IPv4 and 6 for IPv6
    :rtype: tuple of (str, int)
    :raises: IPCheckFailed
    '''
    try:
        address_int, version = IPy.parseAddress(address)
    except ValueError:
        raise IPCheckFailed("Invalid IP address: %s" % address)
    address = IPy.intToIp(address_int, version)
    return (address, version)

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def ipcheck(form, field):
    try:
        IPy.parseAddress(field.data)
    except ValueError, msg:
        # msg is "single byte must be 0 <= byte < 256"
        raise ValidationError(msg)

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
 def testVersionDistinction(self):
     """problems destinguishing IPv4 and IPv6"""
     (result, version) = IPy.parseAddress("0xffffffff")
     self.assertEqual(version, 4)
     (result, version) = IPy.parseAddress("0x100000000")
     self.assertEqual(version, 6)

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
 def testKnownValues(self):
     """parsing of known values should give known results"""
     for x in self.okValues:
         (question, answer) = x
         (result, version) = IPy.parseAddress(question)
         self.assertEqual(answer, result, "%r, %r, %r" % (question, answer, result))

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
 def testRandomValuesv4(self):
     for i in range(testloops):
         question = long(random.randrange(0x7FFFFFFF)) + long(random.randrange(0x7FFFFFFF))
         self.assertEqual(IPy.parseAddress(IPy.intToIp(question, 4)), (question, 4), hex(question))

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def parseIPAddress(ipstr, return_ipv4=True):
    """
    pass an string or binary IP and return IPV4
    """
    newip=[]
    isBin=False

    if ipstr == "::1":
        # localhost in IPV6
        return "127.0.0.1"

    # GDM when change username use a $DISPLAY like this "::12"
    if re.match("::([0-9]{1,9})$", ipstr):
        return ""

    # XEPHYR NAME ':20.0'
    if re.match(":([0-9]{1,9}|[0-9]{1,9}.[0-9]{1,9})$", ipstr):
        return ""

    # match x.x.x.x:0 or x.x.x.x:0.0
    if re.match(".*:([0-9]{1,9}|[0-9{1-9}].[0-9{1-9}])$", ipstr):
        #print_debug("delete display from IP\n\n")
        ipstr=ipstr.rsplit(":", 1)[0]

    # match "localhost:10"
    if re.match("[a-zA-Z].*:([0-9]{1,9})", ipstr):
        ipstr=ipstr.rsplit(":", 1)[0]
        return ipstr
    
    # match "127.0.0.1:10.0"
    if re.match(".*:([0-9{1-9}][0-9{1-9}].[0-9{1-9}])$", ipstr):
        ipstr=ipstr.rsplit(":", 1)[0]
        return ipstr

    # hostname must start with letter and contain letters numbers and '-' or '.'
    if re.match("^[a-zA-Z][a-zA-Z0-9.-]+$", ipstr):
        # ipstr is a hostname
        return ipstr

    for it in ipstr:
        eol=is_bin(binascii.hexlify(it))
        if eol:
            isBin=True
        #print_debug("%s => %s string=%s"%(it, binascii.hexlify(it), eol) )
        newip.append(binascii.hexlify(it))
    
    if ipstr == '':
        return ''
    
    if isBin:
        try:
            ip=ipaddr.IPAddress(IPy.parseAddress("0x" + "".join(newip) )[0])
        except:
            return ipstr
    else:
        try:
            ip=ipaddr.IPAddress(ipstr)
        #except Exception:
        except Exception, err:
            print_debug("      parseIPAddress() Exception, error=%s"%err)
            return ipstr

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
 def testRandomValuesv6(self):
     question = random.randrange(0xffffffffffffffffffffffffffffffff)
     self.assertEqual(IPy.parseAddress(IPy.intToIp(question, 6)), (question, 6), hex(question))

# 需要导入模块: import IPy [as 别名]
# 或者: from IPy import parseAddress [as 别名]
def compare_address(address1, address2):
    address_int1, version1 = IPy.parseAddress(address1)
    address_int2, version2 = IPy.parseAddress(address2)
    if version1 != version2:
        return False
    return address_int1 == address_int2