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))
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
def testCheckNetmaskOk(self):
"""Legal Netmasks should be allowed."""
self.assertFalse(IPy._checkNetmask(0xffffffff, 32))
self.assertFalse(IPy._checkNetmask(0xffffff00, 32))
self.assertFalse(IPy._checkNetmask(0xffff0000, 32))
self.assertFalse(IPy._checkNetmask(0xff000000, 32))
self.assertFalse(IPy._checkNetmask(0, 32))
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 )
def testCheckNetmaskOk(self):
"""Legal Netmasks should be allowed."""
self.failIf(IPy._checkNetmask(0xFFFFFFFFL, 32))
self.failIf(IPy._checkNetmask(0xFFFFFF00L, 32))
self.failIf(IPy._checkNetmask(0xFFFF0000L, 32))
self.failIf(IPy._checkNetmask(0xFF000000L, 32))
self.failIf(IPy._checkNetmask(0, 32))
def testCount1Bits(self):
self.assertEqual(IPy._count1Bits(0), 0)
self.assertEqual(IPy._count1Bits(0xF), 4)
self.assertEqual(IPy._count1Bits(0x10), 5)
self.assertEqual(IPy._count1Bits(0xFF), 8)
self.assertEqual(IPy._count1Bits(0xFFFF), 16)
self.assertEqual(IPy._count1Bits(0xFFFFFFFFL), 32)
self.assertEqual(IPy._count1Bits(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL), 128)
def makeIpPool(self, startIP, lastIP):
'''生产 IP 地址池'''
IPver = 6 if self.IPv6 else 4
intIP = lambda ip: IPy.IP(ip).int()
ipPool = {IPy.intToIp(ip, IPver) for ip in range(intIP(startIP), intIP(lastIP)+1)}
return {ip for ip in ipPool if self.isUnIP(ip)}
def check_ip_address(address, version=None):
try:
_ip, ver = IPy.parseAddress(address)
except ValueError:
return False
if version and version == ver:
return True
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)
def IP_int_prefixlen(ipnum, prefixlen, version):
if version == 4:
width = 32
else:
width = 128
ipnum &= -(1 << (width - prefixlen))
return IP("{0}/{1}".format(IPy.intToIp(ipnum, version), prefixlen))
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)
def creatIpPool(self, startIP, stopIP):
ipPool = set()
if self.isV6:
print "this function is not develop"
else:
ipToInt = lambda ip: IPy.IP(ip).int()
ipPool = {IPy.intToIp(ip, 4) for ip in range(ipToInt(startIP), ipToInt(stopIP)+1)}
return ipPool
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
def increment_range(start_ip, counter):
"""
Increment IP address by 255 multiple times
:param start_ip: base IP to be incremented
:type start_ip: str
:param counter: how many times do you want to increment the IP by 255
:return:incremented IP
"""
incremented_ip_int = IPy.IPint(start_ip).int() + counter * 255
incremented_ip_str = IPy.intToIp(ip=incremented_ip_int, version=4)
return incremented_ip_str
def in_network(ip, network):
nw = IPy.IP(network) if isinstance(network, str) else network
return ip in nw
def __init__(self, ips=None):
if ips == None: ips = IPy.get_ips()
self.dialog = None
self.ips = ips
# -*- coding: utf-8 -*-
import IPy
import MySQLdb
import MySQLdb.cursors
import os
conn = MySQLdb.connect(
host="127.0.0.1",
user="******",
db="CloudROS",
passwd="ubuntu",
charset="utf8",
)
cur = conn.cursor()
subnet = str((IPy.IP('192.168.1.100').make_net('255.255.255.0')))
usr_ip = "192.168.100"
#获取服务对应的镜像名称
service = "teleop"
rows = cur.execute("select * from docker_image where service=%s",
service) #获取限制条件下的表的数据,返回符合条件的行数
result = cur.fetchall(
) #获取限制条件下的结果,默认返回数组,在链接函数中加上参数cursorclass = MySQLdb.cursors.DictCursor,返回字典形式
docker_image = str(result[0][1])
#usr_info插入一条空数据
cur.execute("insert into usr_info values (%s,%s,%s,%s,%s)",
(usr_ip, None, None, None, None))
conn.commit()
#usr_info更新数据
cur("update usr_info set status=%s where usr_ip=%s and service=%s", status,
usr_ip, service, docker, image)
# file = os.popen(cmd)
is_raw = options.is_raw
is_sctp = options.is_sctp
msg_freq = float(options.msg_freq)
sleep_time = float(options.sleep_time)
port = int(options.port)
if options.cnf_list:
configList(options.cnf_list)
sys.exit(0)
if len(args) != 1:
logErr(("Incorrect number of arguments. There must be only one extra "
"argument (the IP)"), TAG_NAME)
try:
ip = IPy.IP(args[0])
except Exception, e:
logErr("Invalid argument %s: %s" % (args[0], e), TAG_NAME)
sys.exit(1)
if options.type:
options.type = options.type.lower()
if options.type == "c": options.type = "client"
elif options.type == "s": options.type = "server"
if not options.config_file:
logErr("Config file not given", TAG_NAME)
server_accepted = None
if options.server_accepted and options.server_accepted != []:
server_accepted = []
def testKnownValuesv6(self):
"""printing of known IPv6 values should give known results"""
for x in self.v6values:
(question, answer) = x
result = IPy.intToIp(question, 6).lower()
self.assertEqual(answer, result, "%r, %r, %r" % (question, answer, result))
def set_address(self, addr):
try:
a = IPy.IP(addr)
except Exception, e:
raise e
def get_recordings(directory):
recordings = []
for filepath in glob.glob("%s/*.xml" % directory):
# Core Library modules
import xml.etree.ElementTree
root = xml.etree.ElementTree.parse(filepath).getroot()
root = elementtree_to_dict(root)
name = root["Name"]["text"]
if name in skip:
continue
for search, rep in replacements:
if name == search:
name = name.replace(search, rep)
if name in skip:
continue
name = strip_end(name, "_Capital")
examples = root["Examples"]["Example"]
logging.info("Name: %s", name)
symbol_recordings = []
if isinstance(examples, dict):
examples = [examples]
for example in examples:
recording = []
time = 0
if isinstance(example["strokesXml"]["Strokes"]["Stroke"], dict):
example["strokesXml"]["Strokes"]["Stroke"] = [
example["strokesXml"]["Strokes"]["Stroke"]
]
for stroke_xml in example["strokesXml"]["Strokes"]["Stroke"]:
stroke = []
if isinstance(stroke_xml["Point"], dict):
stroke_xml["Point"] = [stroke_xml["Point"]]
for point in stroke_xml["Point"]:
stroke.append({
"x": float(point["X"]),
"y": float(point["Y"]),
"time": time
})
time += 20
time += 200
recording.append(stroke)
hw = handwritten_data.HandwrittenData(json.dumps(recording),
formula_in_latex=name)
info = {}
if "text" in example["FormulaInputInfo"]["Username"]:
uname = example["FormulaInputInfo"]["Username"]["text"].strip()
info["username"] = "******" % remove_accents(str(uname))
info["username"] = info["username"].replace("+", "PLUS")
info["username"] = info["username"].replace("...", "DOTS")
info["username"] = info["username"].replace(
"\u0432\u044b\u0444", "BBEF")
info["username"] = info["username"].replace(
"\u0437\u0438\u0438", "Zeii")
else:
info["username"] = "******"
copyright_str = ("This dataset was contributed by MfrDB. You can "
"download their complete dataset at "
"[mfr.felk.cvut.cz/Database.html]"
"(http://mfr.felk.cvut.cz/Database.html)")
info["userid"] = datasets.getuserid(info["username"],
copyright_str)
# Core Library modules
import uuid
# Third party modules
import IPy
from dateutil.parser import parse
info["secret"] = str(uuid.uuid4())
info["ip"] = example["FormulaInputInfo"]["Address"]["text"]
info["ip"] = IPy.IP(info["ip"]).int()
info["accepted_formula_id"] = datasets.formula_to_dbid(name)
info["client"] = example["FormulaInputInfo"]["Client"]["text"]
info["creation_date"] = parse(
example["FormulaInputInfo"]["Time"]["text"])
info["device_type"] = example["FormulaInputInfo"]["Device"][
"text"].lower()
info["sample_id"] = example["FormulaInputInfo"]["SampleId"]["text"]
info["rec_desc"] = "{}::{}::{}::{}::{}".format( # noqa
filepath,
example["Id"],
info["sample_id"],
info["client"],
example["FormulaInputInfo"]["Address"]["text"],
)
info["description"] = ("This dataset was contributed by MfrDB. "
"You can download their complete dataset "
"at [mfr.felk.cvut.cz/Database.html]"
"(http://mfr.felk.cvut.cz/Database.html)")
symbol_recordings.append((hw, info))
recordings.append((name, symbol_recordings))
return recordings
def testKnownValuesv4p2n(self):
"""conversion of known values values should give known results"""
for x in self.known4Values:
(answer, question) = x
result = IPy._prefixlenToNetmask(question, 4)
self.assertEqual(answer, result, hex(question))
def testKnownValuesv6n2p(self):
"""conversion of known values values should give known results"""
for x in self.known6Values:
(question, answer) = x
result = IPy._netmaskToPrefixlen(question)
self.assertEqual(answer, result, hex(question))
def testKnownValues(self):
"""conversion of known values values should give known results"""
for x in self.knownValues:
(question, answer) = x
result = IPy._intToBin(question)
self.assertEqual(answer, result, str(question))
def testCount1Bits(self):
self.assertEqual(IPy._count0Bits(0), 0)
self.assertEqual(IPy._count0Bits(0xF0L), 4)
self.assertEqual(IPy._count0Bits(0xF00L), 8)
self.assertEqual(IPy._count0Bits(0xF000L), 12)
self.assertEqual(IPy._count0Bits(0xF0000L), 16)
self.assertEqual(IPy._count0Bits(0xF00000L), 20)
self.assertEqual(IPy._count0Bits(0xF000000L), 24)
self.assertEqual(IPy._count0Bits(0xF0000000L), 28)
self.assertEqual(IPy._count0Bits(0xFF000000L), 24)
self.assertEqual(IPy._count0Bits(0xFFF00000L), 20)
self.assertEqual(IPy._count0Bits(0x80000000L), 31)
self.assertEqual(IPy._count0Bits(0xF0000000000000000000000000000000L), 124)
self.assertEqual(IPy._count0Bits(0x80000000000000000000000000000000L), 127)
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))
[sg.Button('生成脚本'), sg.Button('退出')]]
# Create the Window
window = sg.Window('爱立信基站写IP_mos脚本生成程序', layout)
# Event Loop to process "events" and get the "values" of the inputs
while True:
event, values = window.read()
if event in (None, '退出'): # if user closes window or clicks cancel
break
elif event in ('生成脚本'): # if user closes window or clicks cancel
if values[0] and values[1]:
om_ip = values[0]
mask = int(values[1])
s1_ip = '.'.join(om_ip.split('.')[:-1]) + '.' + str(
int(om_ip.split('.')[-1]) - 2**(32 - mask))
s1_net = IPy.IP(s1_ip + '/' + str(mask), make_net=True)
om_net = IPy.IP(om_ip + '/' + str(mask), make_net=True)
s1_gateway = '.'.join(str(
IPy.IP.net(s1_net)).split('.')[:-1]) + '.' + str(
int(str(IPy.IP.net(s1_net)).split('.')[-1]) + 1)
om_gateway = '.'.join(str(
IPy.IP.net(om_net)).split('.')[:-1]) + '.' + str(
int(str(IPy.IP.net(om_net)).split('.')[-1]) + 1)
with open('./write_ip.mos', 'w') as f:
f.writelines('lt all' + '\n')
f.writelines(
'set InterfaceIPv4=TN_B_S1,AddressIPv4=1$ address {ip}/{mask}'
.format(ip=s1_ip, mask=mask) + '\n')
f.writelines(
'set Router=S1,RouteTableIPv4Static=1,Dst=1,NextHop=1$ address {s1_gateway}'
def testKnownValuesv6p2n(self):
"""conversion of known values values should give known results"""
for x in self.known6Values:
(answer, question) = x
result = IPy._prefixlenToNetmask(question, 6)
self.assertEqual(answer, result, "%d: %s != %s" % (question, hex(answer), result))
def __init__(self, type, dns="0.0.0.0"):
self.__type = int(type) # 1 byte
self.__len = 0x06 # 1 byte
self.__dns = int(IPy.IP(dns).strHex(), 16) #4 bytes
def ipcheck(form, field):
try:
IPy.parseAddress(field.data)
except ValueError, msg:
# msg is "single byte must be 0 <= byte < 256"
raise ValidationError(msg)
def parseconffile(self):
keyword = ''
f = open('./confmgrweb/FGT800.conf', 'r',encoding='UTF-8')
for line in f:
# 设置对象关键字
if 'config firewall address' in line.strip():
keyword = 'address'
elif 'config firewall addrgrp' in line.strip():
keyword = 'addressgroup'
elif 'config firewall service custom' in line.strip():
keyword = 'service'
elif 'config firewall service group' in line.strip():
keyword = 'servicegroup'
elif 'config firewall policy' in line.strip():
keyword = 'policy'
elif 'config' in line.strip():
keyword = ''
# 添加对象
if keyword == "address" and 'edit' in line.strip():
self.addrlist.append(
Addr(line.strip().split(' ', 1)[1].split('"', 2)[1]))
elif keyword == "addressgroup" and 'edit' in line.strip():
self.addrgrplist.append(
AddrGrp(line.strip().split(' ', 1)[1].split('"', 2)[1]))
elif keyword == "service" and 'edit' in line.strip():
self.serlist.append(
Ser(line.strip().split(' ', 1)[1].split('"', 2)[1]))
elif keyword == "servicegroup" and 'edit' in line.strip():
self.sergrplist.append(
ServGrp(line.strip().split(' ', 1)[1].split('"', 2)[1]))
elif keyword == "policy" and 'edit' in line.strip():
self.policylist.append(
Policy(line.strip().split(' ', 1)[1].split('"', 2)[0]))
# 添加对象内容
if keyword == "address" and 'set subnet' in line.strip():
ipaddr = line.strip().split(
' ', 3)[2] + '/' + line.strip().split(' ', 3)[3]
self.addrlist[len(self.addrlist) -
1].addaddresscontent(IPy.IP(ipaddr, make_net=True).strNormal(1))
elif keyword == "addressgroup" and 'set member' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.addrgrplist[len(self.addrgrplist) - 1].addaddressobject(i)
elif keyword == "service" and 'set tcp-portrange' in line.strip():
tokss = line.strip().split(' ')
for i in range(2, len(tokss)):
content = tokss[i].split(':')[0].split('-')
if content[0] == content[1]:
self.serlist[len(self.serlist) - 1].addservicecontent(content[0])
elif content[0] != '1' and content[1] != '65535':
for j in range(int(content[0]), int(content[1]) + 1):
self.serlist[len(self.serlist) - 1].addservicecontent(str(j))
elif keyword == "servicegroup" and 'set member' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.sergrplist[len(self.sergrplist) -
1].addserviceobject(i)
elif keyword == "policy":
if 'set srcintf' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.policylist[len(self.policylist) - 1].srceth = i
elif 'set dstintf' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.policylist[len(self.policylist) - 1].dsteth = i
elif 'set srcaddr' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.policylist[len(self.policylist) - 1].srcaddr.append(i)
elif 'set dstaddr' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.policylist[len(self.policylist) - 1].dstaddr.append(i)
elif 'set service' in line.strip():
tokss = line.strip().split(' ', 2)[2].split('"')
for i in tokss:
if i != '' and i != ' ':
self.policylist[len(self.policylist) - 1].service.append(i)
f.close()
self.creatpolicydetail()
self.creatpolicymiclist()
Lock.release()
return
try:
print "\n\n\nGoGo Tester Py - Ver %s\n\nDevloped by NKUCodingcat <*****@*****.**>\n\n" % Ver
log = open(root + "log.log", "w")
jobs = [
gevent.spawn(LimitCheck),
] + [
gevent.spawn(Socket_TestNext, ippool)
for i in range(int(sock_thread_num) / 2)
] + [
gevent.spawn(Socket_TestNext, ippool, False)
for i in range(int(sock_thread_num) - int(sock_thread_num) / 2)
] + [gevent.spawn(SSL_TestNext) for i in range(int(ssl_thread_num))]
gevent.joinall(jobs)
finally:
print "\n\nSearch Complete. The result will be saved at %s/res" % root
if not os.path.exists(root + "res"):
os.mkdir(root + "res")
HTMLGEN.HTMLGEN(
json.dumps([i for i in Succ if IPy.IP(i[0][1]).version() == 4]),
open(root + "res/ip_4.txt", "w")).close()
HTMLGEN.HTMLGEN(
json.dumps([i for i in Succ if IPy.IP(i[0][1]).version() == 6]),
open(root + "res/ip_6.txt", "w")).close()
log.close()
print "\n\n"
def run():
p = Pool(100) #限制並發數
while ipQueue.qsize() > 0:
p.spawn(webmap, ipQueue.get())
p.join()
if __name__ == '__main__':
ip = args.ip
output = args.ip.replace('/', '-')
if ip.find('-') >= 0:
iplist = get_ip(ip)
iplist2queue()
elif ip.find('/') >= 0:
ip = ip.split("/")
iplist = IPy.IP(ip[0]).make_net('255.255.255.0')
iplist2queue()
else:
try:
ip = domain2ip(ip)
if ip:
ip = IPy.IP(ip).make_net('255.255.255.0')
iplist = IPy.IP(ip)
iplist2queue()
except:
pass
try:
run()
except:
pass
def testMisc(self):
ip = IPy.IP('195.114.80/24')
self.assertEqual(ip.int(), 3279048704)
self.assertEqual(ip.reverseName(),'80.114.195.in-addr.arpa.')
self.assertEqual(ip.strBin(),'11000011011100100101000000000000')
self.assertEqual(str(ip.net()),'195.114.80.0')
self.assertEqual(str(ip),'195.114.80.0/24')
self.assertEqual(ip.prefixlen(),24)
self.assertEqual(ip.version(),4)
self.assertEqual(ip.len(),256)
self.assertEqual(IPy._intToBin(ip.netmask().int()),'11111111111111111111111100000000')
self.assertEqual(ip.strNetmask(),'255.255.255.0')
self.assertEqual(ip.iptype(), 'PUBLIC')
self.assertEqual(ip.broadcast().strBin(),'11000011011100100101000011111111')
self.assertEqual(str(ip.broadcast()),'195.114.80.255')
ip = IPy.IP('202.31.4/24')
self.assertEqual(str(ip.net()),'202.31.4.0')
self.assertRaises(ValueError, IPy.IP, '234.245.252.253/2')
# because we ar using integer representation we don't need a special "binadd"
ip = IPy.IP('62.33.41.9')
ip2 = IPy.IP('0.1.0.5')
self.assertEqual(str(IPy.IP(ip.int() + ip2.int())),'62.34.41.14')
#$T->ok_eq ($ip->binadd($ip2)->ip(),'62.34.41.14',$ip->error());
ip = IPy.IP('133.45.0/24')
ip2 = IPy.IP('133.45.1/24')
ip3 = IPy.IP('133.45.2/24')
self.assertEqual((ip + ip2).prefixlen(),23)
# Non-adjacent ranges
self.assertRaises(ValueError, IPy.IP.__add__, ip, ip3)
# Resulting invalid prefix
self.assertRaises(ValueError, IPy.IP.__add__, ip2, ip3)
ip2 = IPy.IP('133.44.255.255');
#$T->ok_eqnum ($ip->bincomp('gt',$ip2),1,$ip->error());
# this is something we can't do with IPy
#ip = IPy.IP('133.44.255.255-133.45.0.42');
#$T->ok_eq (($ip->find_prefixes())[3],'133.45.0.40/31',$ip->error());
ip = IPy.IP('201.33.128.0/22');
ip2 = IPy.IP('201.33.129.0/24');
#$T->ok_eqnum ($ip->overlaps($ip2),$IP_B_IN_A_OVERLAP,$ip->error());
ip = IPy.IP('dead:beef:0::/48')
self.assertEqual(str(ip.net()),'dead:beef::')
self.assertEqual(ip.int(), 295990755014133383690938178081940045824)
self.assertEqual(ip.strBin(),'11011110101011011011111011101111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')
self.assertEqual(ip.strCompressed(),'dead:beef::/48')
self.assertEqual(ip.prefixlen(), 48)
self.assertEqual(ip.version(), 6)
self.assertEqual(ip.strNetmask(),'/48')
self.assertEqual(str(ip.netmask()),'ffff:ffff:ffff::')
self.assertEqual(ip.iptype(),'RESERVED')
self.assertEqual(ip.reverseName(),'0.0.0.0.f.e.e.b.d.a.e.d.ip6.arpa.')
self.assertEqual(str(ip.broadcast()),'dead:beef:0:ffff:ffff:ffff:ffff:ffff')
ip = IPy.IP('202.31.4/24')
self.assertEqual(str(ip.net()),'202.31.4.0')
# TODO: fix this in IPy ... after rereading the RfC
# ip = IPy.IP(':1/128');
#$T->ok_eq ($ip->error(),'Invalid address :1 (starts with :)',$ip->error());
#$T->ok_eqnum ($ip->errno(),109,$ip->error());
ip = IPy.IP('ff00:0:f000::')
ip2 = IPy.IP('0:0:1000::')
self.assertEqual(IPy.IP(ip.int() + ip2.int()).strCompressed(), 'ff00:1::')
ip = IPy.IP('::e000:0/112')
ip2 = IPy.IP('::e001:0/112')
self.assertEqual(ip.__add__(ip2).prefixlen(),111)
self.assertEqual(ip.__add__(ip2).version(),6)
ip2 = IPy.IP('::dfff:ffff')
#$T->ok_eqnum ($ip->bincomp('gt',$ip2),1,$ip->error());
#ip = IPy.IP('::e000:0 - ::e002:42')
#$T->ok_eq (($ip->find_prefixes())[2],'0000:0000:0000:0000:0000:0000:e002:0040/127',$ip->error());
ip = IPy.IP('ffff::/16')
ip2 = IPy.IP('8000::/16')
def testCheckPrefixFail(self):
"""Illegal Prefixes should be catched."""
self.assertFalse(IPy._checkPrefix(0x7f000001, -1, 4))
self.assertFalse(IPy._checkPrefix(0x7f000001, 33, 4))
self.assertFalse(IPy._checkPrefix(0x7f000001, 24, 4))
self.assertFalse(IPy._checkPrefix(0x7f000001, 31, 4))
self.assertFalse(IPy._checkPrefix(0x7f000080, 24, 4))
self.assertFalse(IPy._checkPrefix(0x7f000100, 23, 4))
self.assertFalse(IPy._checkPrefix(0x7f000000, 1, 4))
self.assertFalse(IPy._checkPrefix(0x7f000000, 0, 4))
self.assertFalse(IPy._checkPrefix(0x1, -1, 6))
self.assertFalse(IPy._checkPrefix(0x1, 129, 6))
self.assertFalse(IPy._checkPrefix(0xffffffffffffffff0000000000000001, 64, 6))
self.assertFalse(IPy._checkPrefix(0xffffffffffffffff1000000000000000, 64, 6))
def testCheckPrefixOk(self):
"""Legal IP/prefix combinations should check ok."""
self.failUnless(IPy._checkPrefix(0x0, 32, 4))
self.failUnless(IPy._checkPrefix(0xFFFFFFFFL, 32, 4))
self.failUnless(IPy._checkPrefix(0x7F000001L, 32, 4))
self.failUnless(IPy._checkPrefix(0x80000000L, 1, 4))
self.failUnless(IPy._checkPrefix(0x40000000L, 2, 4))
self.failUnless(IPy._checkPrefix(0x80000000L, 3, 4))
self.failUnless(IPy._checkPrefix(0x80000000L, 4, 4))
self.failUnless(IPy._checkPrefix(0xFFFFFF00L, 24, 4))
self.failUnless(IPy._checkPrefix(0xFFFFFF00L, 24, 4))
self.failUnless(IPy._checkPrefix(0xFFFFFFF0L, 28, 4))
self.failUnless(IPy._checkPrefix(0x0, 32, 4))
self.failUnless(IPy._checkPrefix(0x0, 1, 4))
self.failUnless(IPy._checkPrefix(0x0, 0, 4))
self.failUnless(IPy._checkPrefix(0xFFFFFFFFFFFFFFFF0000000000000000L, 64, 6))
self.failUnless(IPy._checkPrefix(0x0L, 64, 6))
self.failUnless(IPy._checkPrefix(0x0L, 0, 6))
self.failUnless(IPy._checkPrefix(0x0L, 128, 6))
self.failUnless(IPy._checkPrefix(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL, 128, 6))
def IntToIPString(Int):
return str(IPy.IP(Int))
def testCheckPrefixFail(self):
"""Illegal Prefixes should be catched."""
self.failIf(IPy._checkPrefix(0x7F000001L, -1, 4))
self.failIf(IPy._checkPrefix(0x7F000001L, 33, 4))
self.failIf(IPy._checkPrefix(0x7F000001L, 24, 4))
self.failIf(IPy._checkPrefix(0x7F000001L, 31, 4))
self.failIf(IPy._checkPrefix(0x7F000080L, 24, 4))
self.failIf(IPy._checkPrefix(0x7F000100L, 23, 4))
self.failIf(IPy._checkPrefix(0x7F000000L, 1, 4))
self.failIf(IPy._checkPrefix(0x7F000000L, 0, 4))
self.failIf(IPy._checkPrefix(0x1L, -1, 6))
self.failIf(IPy._checkPrefix(0x1L, 129, 6))
self.failIf(IPy._checkPrefix(0xFFFFFFFFFFFFFFFF0000000000000001L, 64, 6))
self.failIf(IPy._checkPrefix(0xFFFFFFFFFFFFFFFF1000000000000000L, 64, 6))
def run(self):
IPy.run_macros(self.cmds)
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))
and ((sys.argv[1] == '-h') or (sys.argv[1] == '--help'))):
print(__doc__)
else:
print("ERROR: missing required argument")
print(usage)
sys.exit()
if (len(sys.argv) > 3):
print("ERROR: unexpected argument " + sys.argv[3])
print(usage)
sys.exit()
#check IPv4 address
agentIp = str(sys.argv[1])
try:
IPy.IP(agentIp)
except:
print("ERROR: you must use a valid SNMP-agent IPv4")
print(usage)
sys.exit()
#report file I/O
outFilename = str(sys.argv[2])
try:
specialCharReport = open(outFilename, 'w')
except IOError:
print("Error: %s cannot be opened for writing." % (outFilename))
sys.exit()
configFilename = 'pyschar.conf'
def testMisc(self):
ip = IPy.IP("195.114.80/24")
self.assertEqual(ip.int(), 3279048704L)
self.assertEqual(ip.reverseName(), "80.114.195.in-addr.arpa.")
self.assertEqual(ip.strBin(), "11000011011100100101000000000000")
self.assertEqual(str(ip.net()), "195.114.80.0")
self.assertEqual(str(ip), "195.114.80.0/24")
self.assertEqual(ip.prefixlen(), 24)
self.assertEqual(ip.version(), 4)
self.assertEqual(ip.len(), 256)
self.assertEqual(IPy._intToBin(ip.netmask().int()), "11111111111111111111111100000000")
self.assertEqual(ip.strNetmask(), "255.255.255.0")
self.assertEqual(ip.iptype(), "PUBLIC")
self.assertEqual(ip.broadcast().strBin(), "11000011011100100101000011111111")
self.assertEqual(str(ip.broadcast()), "195.114.80.255")
ip = IPy.IP("202.31.4/24")
self.assertEqual(str(ip.net()), "202.31.4.0")
self.failUnlessRaises(ValueError, IPy.IP, "234.245.252.253/2")
# because we ar using integer representation we don't need a special "binadd"
ip = IPy.IP("62.33.41.9")
ip2 = IPy.IP("0.1.0.5")
self.assertEqual(str(IPy.IP(ip.int() + ip2.int())), "62.34.41.14")
# $T->ok_eq ($ip->binadd($ip2)->ip(),'62.34.41.14',$ip->error());
ip = IPy.IP("133.45.0/24")
ip2 = IPy.IP("133.45.1/24")
self.assertEqual((ip + ip2).prefixlen(), 23)
ip2 = IPy.IP("133.44.255.255")
# $T->ok_eqnum ($ip->bincomp('gt',$ip2),1,$ip->error());
# this is something we can't do with IPy
# ip = IPy.IP('133.44.255.255-133.45.0.42');
# $T->ok_eq (($ip->find_prefixes())[3],'133.45.0.40/31',$ip->error());
ip = IPy.IP("201.33.128.0/22")
ip2 = IPy.IP("201.33.129.0/24")
# $T->ok_eqnum ($ip->overlaps($ip2),$IP_B_IN_A_OVERLAP,$ip->error());
ip = IPy.IP("dead:beef:0::/48")
self.assertEqual(str(ip.net()), "dead:beef::")
self.assertEqual(ip.int(), 295990755014133383690938178081940045824L)
self.assertEqual(
ip.strBin(),
"11011110101011011011111011101111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
)
self.assertEqual(ip.strCompressed(), "dead:beef::/48")
self.assertEqual(ip.prefixlen(), 48)
self.assertEqual(ip.version(), 6)
self.assertEqual(ip.strNetmask(), "/48")
self.assertEqual(str(ip.netmask()), "ffff:ffff:ffff::")
self.assertEqual(ip.iptype(), "UNASSIGNED")
self.assertEqual(ip.reverseName(), "0.0.0.0.f.e.e.b.d.a.e.d.ip6.arpa.")
self.assertEqual(str(ip.broadcast()), "dead:beef:0:ffff:ffff:ffff:ffff:ffff")
ip = IPy.IP("202.31.4/24")
self.assertEqual(str(ip.net()), "202.31.4.0")
# TODO: fix this in IPy ... after rereading the RfC
# ip = IPy.IP(':1/128');
# $T->ok_eq ($ip->error(),'Invalid address :1 (starts with :)',$ip->error());
# $T->ok_eqnum ($ip->errno(),109,$ip->error());
ip = IPy.IP("ff00:0:f000::")
ip2 = IPy.IP("0:0:1000::")
self.assertEqual(IPy.IP(ip.int() + ip2.int()).strCompressed(), "ff00:1::")
ip = IPy.IP("::e000:0/112")
ip2 = IPy.IP("::e001:0/112")
self.assertEqual(ip.__add__(ip2).prefixlen(), 111)
ip2 = IPy.IP("::dfff:ffff")
# $T->ok_eqnum ($ip->bincomp('gt',$ip2),1,$ip->error());
# ip = IPy.IP('::e000:0 - ::e002:42')
# $T->ok_eq (($ip->find_prefixes())[2],'0000:0000:0000:0000:0000:0000:e002:0040/127',$ip->error());
ip = IPy.IP("ffff::/16")
ip2 = IPy.IP("8000::/16")
def check(self, ips):
note = self.note
if ips == None:
IPy.alert('no image opened!')
return False
elif 'req_roi' in note and ips.roi == None:
IPy.alert('no Roi found!')
return False
elif not 'all' in note:
if ips.get_imgtype() == 'rgb' and not 'rgb' in note:
IPy.alert('do not surport rgb image')
return False
elif ips.get_imgtype() == '8-bit' and not '8-bit' in note:
IPy.alert('do not surport 8-bit image')
return False
elif ips.get_imgtype() == '16-bit' and not '16-bit' in note:
IPy.alert('do not surport 16-bit image')
return False
elif ips.get_imgtype() == 'float' and not 'float' in note:
IPy.alert('do not surport float image')
return False
return True
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)
def post(db):
"""
Main upload interface. Users can password-protect an entry if they so
desire. You can send an already SHA1 cyphered text to this endpoint so
your intended password does not fly insecure through the internet
"""
form = bottle.request.forms
upload = form.upload
filename = form.filename if form.filename != '-' else None
syntax = form.syntax if form.syntax != '-' else None
password = form.password
try:
parent = int(form.parent) if form.parent else None
except Exception as e:
util.log.warn('Parent value does not seem like an int: %s' % (e, ))
is_encrypted = bool(form.is_encrypted)
redirect = bool(form.redirect)
util.log.debug('Filename: {0}, Syntax: {1}'.format(
filename,
syntax,
))
default_lexer = lexers.get_lexer_for_mimetype('text/plain')
if upload:
if syntax:
util.log.debug('Guessing lexer for explicit syntax {0}'.format(
syntax, ))
try:
lexer = lexers.get_lexer_by_name(syntax)
except lexers.ClassNotFound:
lexer = default_lexer
else:
if filename:
util.log.debug('Guessing lexer for filename {0}'.format(
filename, ))
try:
lexer = lexers.guess_lexer_for_filename(filename, upload)
except lexers.ClassNotFound:
lexer = lexers.guess_lexer(upload)
else:
util.log.debug('Use default lexer')
lexer = default_lexer
util.log.debug(lexer.mimetypes)
lx = None
if lexer.name:
lx = lexer.name
else:
if lexer.aliases:
lx = lexer.aliases[0]
mime = lexer.mimetypes[0]
ip = bottle.request.remote_addr
if ip:
# Try not to store crap in the database if it's not a valid IP
try:
ip = bin(IPy.IP(ip).int())
except Exception as ex:
util.log.warn(
'Impossible to store the source IP address: {0}'.format(
ex))
ip = None
paste = model.Paste(content=upload,
mimetype=mime,
is_encrypted=is_encrypted,
password=password,
ip=ip,
filename=filename,
lexer=lx,
parent=parent)
util.log.debug(paste)
db.add(paste)
db.commit()
if redirect:
bottle.redirect('{0}/{1}'.format(
get_url(),
paste.id,
))
else:
return bottle.HTTPResponse('{0}/{1}'.format(
get_url(),
paste.id,
))
else:
return bottle.HTTPError(400, 'No paste provided')
def testVersion(self):
"""IP-version detection should work"""
self.assertEqual(IPy.IP("0.0.0.0/0").version(), 4)
self.assertEqual(IPy.IP("::1").version(), 6)
ret = os.system(cmd)
if ret:
print 'Error updating firewall %s: returned %s' % (fw, ret)
return ret
DEFAULT_BLOCK_DAYS = 30
if __name__ == '__main__':
iface = db.db("dbname=%s host=%s" % (dbname, fwdb_config.default_db_host))
data = sys.stdin.readline()
args = cjson.decode(data)
try:
addresses = [IPy.IP(a) for a in args['addresses']]
except:
print "Bad input. No donut."
raise
to_add = []
SET_NAME = args['set_name']
BLOCK_DAYS = int(args['block_days']) if args.has_key(
'block_days') else DEFAULT_BLOCK_DAYS
OWNER = args['owner']
DESCRIPTION = args['description']
os.environ['DESCRIPTION'] = DESCRIPTION
group = iface.get_hosts(name=SET_NAME, is_group=True)
if len(group) != 1:
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)
def get_ip(self): #获取待扫描地址段 for ip in IPy.IP(self.target): self.ips.append(str(ip))
def testNonZeroType(self):
self.assertEqual(bool(IPy.IP("0.0.0.0/0")), True)
def getiplist(ip_range):
start_ip = ip_range.split('-')[0]
end_ip = ip_range.split('-')[1]
ipPool = [IPy.intToIp(ip, 4) for ip in range(IPy.IP(start_ip).int(), IPy.IP(end_ip).int() + 1)]
return ipPool
def testCheckAddrPrefixlenOn(self):
self.assertEqual(len(IPy.IP('192.168.0.0/24')), 256)
self.assertRaises(ValueError, IPy.IP, '192.168.1.0/42')
self.assertRaises(ValueError, IPy.IP, '172.30.1.0/22')
def __iter__(self):
count = self.len()
for offset in xrange(0, count):
yield IPy.IP(self._min.int() + offset)
def run(self, para=None):
IPy.alert('join two tabl with special field, not implemented!')
def insert():
"""
Re-insert in the database the data provided by the module and
extracted by :meth:`get_all_information` in a sorted form.
"""
while True:
i = 0
try:
while temp_db.scard(uid_list) > 0:
infos = get_all_information()
if infos is None:
continue
uid, ip, src, timestamp = infos
if ip is None:
publisher.error('Entry without IP, invalid')
continue
if src is None:
publisher.error(ip + ' without source, invalid')
continue
if timestamp.date() < datetime.date.today() - \
datetime.timedelta(1) and not accept_old_entries:
publisher.warning('The timestamp ({ts}) of {ip} from {source} is too old.'.\
format(ts = timestamp.isoformat(), ip = ip, source = src))
continue
try:
# Check and normalize the IP
ip_bin = IPy.IP(ip)
if ip_bin.iptype() != 'PUBLIC':
publisher.warning(
str(ip_bin) + ' is not a PUBLIC IP Address')
continue
ip = ip_bin.strCompressed()
except:
publisher.error('This IP: ' + ip + ' in invalid.')
continue
iso_timestamp = timestamp.isoformat()
date = timestamp.date().isoformat()
index_day_src = '{date}{sep}{key}'.format(sep=separator,
date=date,
key=list_sources)
index_day_ips = 'temp{sep}{date}{sep}{source}{sep}{key}'.format(
sep=separator, date=date, source=src, key=list_ips)
ip_details = '{ip}{sep}{timestamp}'.format(
sep=separator, ip=ip, timestamp=iso_timestamp)
global_db.sadd(index_day_src, src)
pipeline_temp_db = temp_db.pipeline()
pipeline_temp_db.sadd(index_day_ips, ip_details)
pipeline_temp_db.sadd(temp_ris, ip)
pipeline_temp_db.sadd(temp_no_asn, index_day_ips)
pipeline_temp_db.delete(uid)
pipeline_temp_db.execute()
i += 1
if i % 100 == 0 and config_db.exists(stop_db_input):
break
if i % 10000 == 0:
publisher.info('{nb} new entries to insert'\
.format(nb = temp_db.scard(uid_list)))
except:
publisher.critical('Unable to insert, redis does not respond')
break
time.sleep(sleep_timer)
if config_db.exists(stop_db_input):
publisher.info('DatabaseInput stopped.')
break
def run(self, para=None):
IPy.alert('add ont field to the table, not implemented!')
def ip(value):
try:
return IPy.IP(value).version()
except Exception as e:
raise errors.AnsibleFilterError('ip failed: %s' % to_native(e))
def run(self, para=None):
IPy.alert('merge the same value and count frequence, not implemented!')
def testMisc(self):
ip = IPy.IP('195.114.80/24')
self.assertEqual(ip.int(), 3279048704)
self.assertEqual(ip.reverseName(), '80.114.195.in-addr.arpa.')
self.assertEqual(ip.strBin(), '11000011011100100101000000000000')
self.assertEqual(str(ip.net()), '195.114.80.0')
self.assertEqual(str(ip), '195.114.80.0/24')
self.assertEqual(ip.prefixlen(), 24)
self.assertEqual(ip.version(), 4)
self.assertEqual(ip.len(), 256)
self.assertEqual(IPy._intToBin(ip.netmask().int()),
'11111111111111111111111100000000')
self.assertEqual(ip.strNetmask(), '255.255.255.0')
self.assertEqual(ip.iptype(), 'PUBLIC')
self.assertEqual(ip.broadcast().strBin(),
'11000011011100100101000011111111')
self.assertEqual(str(ip.broadcast()), '195.114.80.255')
ip = IPy.IP('202.31.4/24')
self.assertEqual(str(ip.net()), '202.31.4.0')
self.assertRaises(ValueError, IPy.IP, '234.245.252.253/2')
# because we ar using integer representation we don't need a special "binadd"
ip = IPy.IP('62.33.41.9')
ip2 = IPy.IP('0.1.0.5')
self.assertEqual(str(IPy.IP(ip.int() + ip2.int())), '62.34.41.14')
#$T->ok_eq ($ip->binadd($ip2)->ip(),'62.34.41.14',$ip->error());
ip = IPy.IP('133.45.0/24')
ip2 = IPy.IP('133.45.1/24')
self.assertEqual((ip + ip2).prefixlen(), 23)
ip2 = IPy.IP('133.44.255.255')
#$T->ok_eqnum ($ip->bincomp('gt',$ip2),1,$ip->error());
# this is something we can't do with IPy
#ip = IPy.IP('133.44.255.255-133.45.0.42');
#$T->ok_eq (($ip->find_prefixes())[3],'133.45.0.40/31',$ip->error());
ip = IPy.IP('201.33.128.0/22')
ip2 = IPy.IP('201.33.129.0/24')
#$T->ok_eqnum ($ip->overlaps($ip2),$IP_B_IN_A_OVERLAP,$ip->error());
ip = IPy.IP('dead:beef:0::/48')
self.assertEqual(str(ip.net()), 'dead:beef::')
self.assertEqual(ip.int(), 295990755014133383690938178081940045824)
self.assertEqual(
ip.strBin(),
'11011110101011011011111011101111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
)
self.assertEqual(ip.strCompressed(), 'dead:beef::/48')
self.assertEqual(ip.prefixlen(), 48)
self.assertEqual(ip.version(), 6)
self.assertEqual(ip.strNetmask(), '/48')
self.assertEqual(str(ip.netmask()), 'ffff:ffff:ffff::')
self.assertEqual(ip.iptype(), 'UNASSIGNED')
self.assertEqual(ip.reverseName(), '0.0.0.0.f.e.e.b.d.a.e.d.ip6.int.')
self.assertEqual(str(ip.broadcast()),
'dead:beef:0:ffff:ffff:ffff:ffff:ffff')
ip = IPy.IP('202.31.4/24')
self.assertEqual(str(ip.net()), '202.31.4.0')
# TODO: fix this in IPy ... after rereading the RfC
# ip = IPy.IP(':1/128');
#$T->ok_eq ($ip->error(),'Invalid address :1 (starts with :)',$ip->error());
#$T->ok_eqnum ($ip->errno(),109,$ip->error());
ip = IPy.IP('ff00:0:f000::')
ip2 = IPy.IP('0:0:1000::')
self.assertEqual(
IPy.IP(ip.int() + ip2.int()).strCompressed(), 'ff00:1::')
ip = IPy.IP('::e000:0/112')
ip2 = IPy.IP('::e001:0/112')
self.assertEqual(ip.__add__(ip2).prefixlen(), 111)
ip2 = IPy.IP('::dfff:ffff')
#$T->ok_eqnum ($ip->bincomp('gt',$ip2),1,$ip->error());
#ip = IPy.IP('::e000:0 - ::e002:42')
#$T->ok_eq (($ip->find_prefixes())[2],'0000:0000:0000:0000:0000:0000:e002:0040/127',$ip->error());
ip = IPy.IP('ffff::/16')
ip2 = IPy.IP('8000::/16')
def testCheckPrefixOk(self):
"""Legal IP/prefix combinations should check ok."""
self.assertTrue(IPy._checkPrefix(0x0, 32, 4))
self.assertTrue(IPy._checkPrefix(0xffffffff, 32, 4))
self.assertTrue(IPy._checkPrefix(0x7f000001, 32, 4))
self.assertTrue(IPy._checkPrefix(0x80000000, 1, 4))
self.assertTrue(IPy._checkPrefix(0x40000000, 2, 4))
self.assertTrue(IPy._checkPrefix(0x80000000, 3, 4))
self.assertTrue(IPy._checkPrefix(0x80000000, 4, 4))
self.assertTrue(IPy._checkPrefix(0xffffff00, 24, 4))
self.assertTrue(IPy._checkPrefix(0xffffff00, 24, 4))
self.assertTrue(IPy._checkPrefix(0xfffffff0, 28, 4))
self.assertTrue(IPy._checkPrefix(0x0, 32, 4))
self.assertTrue(IPy._checkPrefix(0x0, 1, 4))
self.assertTrue(IPy._checkPrefix(0x0, 0, 4))
self.assertTrue(IPy._checkPrefix(0xffffffffffffffff0000000000000000, 64, 6))
self.assertTrue(IPy._checkPrefix(0x0, 64, 6))
self.assertTrue(IPy._checkPrefix(0x0, 0, 6))
self.assertTrue(IPy._checkPrefix(0x0, 128, 6))
self.assertTrue(IPy._checkPrefix(0xffffffffffffffffffffffffffffffff, 128, 6))
