def test_ipv4_unicode():
# Fully qualified
assert unicode(IPv4("192.168.0.0/24")), u"192.168.0.0/24"
# Address only
assert unicode(IPv4("192.168.0.0")), u"192.168.0.0/32"
# Netmask
assert unicode(IPv4("192.168.0.0", netmask="255.255.255.0")) == u"192.168.0.0/24"
def test_ipv4_sub():
# prefix - number returns prefix
assert repr(IPv4("192.168.0.10/32") - 9) == "<IPv4 192.168.0.1/32>"
assert repr(IPv4("192.168.1.10/32") - 265) == "<IPv4 192.168.0.1/32>"
assert repr(IPv4("0.0.0.0/32") - 1) == "<IPv4 255.255.255.255/32>"
# prefix - prefix returns distance
assert IPv4("192.168.0.10/32") - IPv4("192.168.0.1/32") == 9
def test_ipv4_hash(p1, p2):
p1 = IPv4(p1)
p2 = IPv4(p2)
s = {p1}
assert p1 in s
assert p2 not in s
ss = {p1: 1}
assert ss[p1] == 1
with pytest.raises(KeyError):
ss[p2]
def test_ipv4_hash():
p0 = IPv4("192.168.0.1")
p1 = IPv4("192.168.0.2")
s = {p0}
assert p0 in s
assert p1 not in s
ss = {p0: 1}
assert ss[p0] == 1
with pytest.raises(KeyError):
ss[p1]
def test_ipv4_range_to_prefixes():
assert [repr(x) for x in IPv4.range_to_prefixes('192.168.0.2', '192.168.0.2')] == [
"<IPv4 192.168.0.2/32>"
]
assert [repr(x) for x in IPv4.range_to_prefixes('192.168.0.2', '192.168.0.16')] == [
"<IPv4 192.168.0.2/31>", "<IPv4 192.168.0.4/30>", "<IPv4 192.168.0.8/29>",
"<IPv4 192.168.0.16/32>"
]
assert [repr(x)
for x in IPv4.range_to_prefixes('0.0.0.0', '255.255.255.255')] == ["<IPv4 0.0.0.0/0>"]
def test_ipv4_iter_cover():
assert [repr(x) for x in IPv4("192.168.0.0/24").iter_cover(23)] == []
assert [repr(x) for x in IPv4("192.168.0.0/24").iter_cover(24)] == ["<IPv4 192.168.0.0/24>"]
assert [repr(x) for x in IPv4("192.168.0.0/23").iter_cover(24)] == [
"<IPv4 192.168.0.0/24>", "<IPv4 192.168.1.0/24>"
]
assert [repr(x) for x in IPv4("192.168.0.0/22").iter_cover(24)] == [
"<IPv4 192.168.0.0/24>", "<IPv4 192.168.1.0/24>", "<IPv4 192.168.2.0/24>",
"<IPv4 192.168.3.0/24>"
]
def test_ipv4_hash(p1, p2):
p1 = IPv4(p1)
p2 = IPv4(p2)
s = {p1}
assert p1 in s
assert p2 not in s
ss = {p1: 1}
assert ss[p1] == 1
with pytest.raises(KeyError):
ss[p2] # pylint: disable=pointless-statement
def test_ipv4_comparison(p1, p2, c, eq, ne, lt, le, gt, ge):
p1 = IPv4(p1)
p2 = IPv4(p2)
assert ((p1 > p2) - (p1 < p2)) == c
assert (p1 == p2) is eq
assert (p1 != p2) is ne
assert (p1 < p2) is lt
assert (p1 > p2) is gt
assert (p1 <= p2) is le
assert (p1 >= p2) is ge
def test_ipv4_comparison(ipv4_comparison):
p1, p2, c, eq, ne, lt, le, gt, ge = ipv4_comparison
p1 = IPv4(p1)
p2 = IPv4(p2)
assert cmp(p1, p2) is c
assert (p1 == p2) is eq
assert (p1 != p2) is ne
assert (p1 < p2) is lt
assert (p1 > p2) is gt
assert (p1 <= p2) is le
assert (p1 >= p2) is ge
def test_ipv4_iter_address():
assert [repr(x) for x in IPv4("192.168.0.0").iter_address(count=5)] == [
"<IPv4 192.168.0.0/32>", "<IPv4 192.168.0.1/32>", "<IPv4 192.168.0.2/32>",
"<IPv4 192.168.0.3/32>", "<IPv4 192.168.0.4/32>"
]
assert [repr(x) for x in IPv4("192.168.0.255").iter_address(count=5)] == [
"<IPv4 192.168.0.255/32>", "<IPv4 192.168.1.0/32>", "<IPv4 192.168.1.1/32>",
"<IPv4 192.168.1.2/32>", "<IPv4 192.168.1.3/32>"
]
assert [repr(x) for x in IPv4("192.168.0.255").iter_address(until="192.168.1.3")] == [
"<IPv4 192.168.0.255/32>", "<IPv4 192.168.1.0/32>", "<IPv4 192.168.1.1/32>",
"<IPv4 192.168.1.2/32>", "<IPv4 192.168.1.3/32>"
]
def test_prefixdb_ipv4():
db = PrefixDB()
db[IPv4("192.168.0.0/24")] = 1
db[IPv4("192.168.1.0/24")] = 2
db[IPv4("192.168.2.0/24")] = 3
db[IPv4("10.0.0.0/8")] = 4
assert db[IPv4("192.168.0.0/24")] == 1
assert db[IPv4("192.168.1.0/24")] == 2
assert db[IPv4("192.168.2.0/24")] == 3
assert db[IPv4("10.0.0.0/8")] == 4
with pytest.raises(KeyError):
db[IPv4("172.16.0.0/12")]
def test_prefixdb_ipv4(p1, p2, p3, p4, p5, p6, p7, p8, p9):
db = PrefixDB()
db[IPv4(p1)] = p2
db[IPv4(p3)] = p4
db[IPv4(p5)] = p6
db[IPv4(p7)] = p8
assert db[IPv4(p1)] == p2
assert db[IPv4(p3)] == p4
assert db[IPv4(p5)] == p6
assert db[IPv4(p7)] == p8
with pytest.raises(KeyError):
db[IPv4(p9)]
def execute(self):
res = self.http.get(
"/cgi-bin/configManager.cgi?action=getConfig&name=Network")
# "getInterfaces"
r = []
if res:
res = self.profile.parse_equal_output(res)
name = res["table.Network.DefaultInterface"]
iface = {
"name": name,
"type": "physical",
"admin_status": True,
"oper_status": True,
"mtu": res["table.Network.%s.MTU" % name],
"mac": res["table.Network.%s.PhysicalAddress" % name],
}
ip_address = "%s/%s" % (
res["table.Network.%s.IPAddress" % name],
IPv4.netmask_to_len(res["table.Network.%s.SubnetMask" % name]),
)
sub = {
"name": name,
"admin_status": True,
"oper_status": True,
"mac": res["table.Network.%s.PhysicalAddress" % name],
"enabled_afi": ["IPv4"],
"ipv4_addresses": [ip_address],
}
iface["subinterfaces"] = [sub]
r += [iface]
return [{"interfaces": r}]
def forwards(self):
PrefixTable = db.mock_model(model_name="PrefixTable",
db_table="main_prefixtable", db_tablespace="", pk_field_name="id",
pk_field_type=models.AutoField)
db.add_column(
"sa_activator", "prefix_table",
models.ForeignKey(
PrefixTable,
verbose_name=_("Prefix Table"), null=True, blank=True)
)
# Migrate data
for id, name, ip, to_ip in db.execute(
"SELECT id, name, ip, to_ip FROM sa_activator"):
pt_name = "Activator::%s" % name
db.execute(
"""
INSERT INTO main_prefixtable(name)
VALUES(%s)
""", [pt_name])
pt_id, = db.execute("SELECT id FROM main_prefixtable WHERE name = %s", [pt_name])[0]
for p in IPv4.range_to_prefixes(ip, to_ip):
db.execute("""
INSERT INTO main_prefixtableprefix(table_id, afi, prefix)
VALUES(%s, '4', %s)
""", [pt_id, p.prefix])
db.execute("UPDATE sa_activator SET prefix_table_id=%s WHERE id=%s", [pt_id, id])
def execute_snmp(self):
i = [1, 2, 3, 4, 5]
interfaces = []
for ii in i:
status = self.snmp.get("1.3.6.1.4.1.35419.20.1.10%s.0" % ii)
if status == 0:
admin_status = False
oper_status = False
else:
admin_status = True
oper_status = True
iface = {
"type":
"physical",
"name":
ii,
"admin_status":
admin_status,
"oper_status":
oper_status,
"snmp_ifindex":
ii,
"subinterfaces": [{
"name": ii,
"admin_status": admin_status,
"oper_status": oper_status,
"snmp_ifindex": ii,
}],
}
interfaces += [iface]
ip = self.snmp.get("1.3.6.1.4.1.35419.1.1.3.0")
m = self.snmp.get("1.3.6.1.4.1.35419.1.1.4.0")
mask = str(IPv4.netmask_to_len(m))
ip = ip + "/" + mask
ip_list = [ip]
iface = {
"type":
"physical",
"name":
"eth0",
"admin_status":
True,
"oper_status":
True,
"mac":
self.snmp.get("1.3.6.1.4.1.35419.1.1.6.0"),
"snmp_ifindex":
10,
"subinterfaces": [{
"name": "eth0",
"admin_status": True,
"oper_status": True,
"mac": self.snmp.get("1.3.6.1.4.1.35419.1.1.6.0"),
"ipv4_addresses": ip_list,
"snmp_ifindex": 10,
"enabled_afi": ["BRIDGE", "IPv4"],
}],
}
interfaces += [iface]
return [{"interfaces": interfaces}]
def execute(self):
sw = self.scripts.get_switchport()
ports = self.scripts.get_interface_status()
mv = self.rx_mv.search(self.cli("show vlan", cached=True))
if mv:
mv = int(mv.group("mv"))
else:
mv = 1
interfaces = []
for p in ports:
ifname = p['interface']
i = {
"name":
ifname,
"type":
"physical",
"oper_status":
p['status'],
"enabled_protocols": [],
"subinterfaces": [{
"name": ifname,
"oper_status": p['status'],
# "ifindex": 1,
"enabled_afi": ['BRIDGE']
}]
}
for p1 in sw:
if p1['interface'] == ifname:
i['subinterfaces'][0]['tagged_vlans'] = p1['tagged']
if 'untagged' in p1:
i['subinterfaces'][0]['untagged_vlan'] = p1['untagged']
interfaces += [i]
match = self.rx_swi.search(self.cli("show switch"))
if match:
i = {
"name":
"System",
"type":
"SVI",
"oper_status":
True,
"admin_status":
True,
"enabled_protocols": [],
"subinterfaces": [{
"name": "System",
"oper_status": True,
"admin_status": True,
"mac": match.group("mac"),
"vlan_ids": [mv],
"enabled_afi": ['IPv4']
}]
}
addr = match.group("ip")
mask = match.group("mask")
ip_address = "%s/%s" % (addr, IPv4.netmask_to_len(mask))
i['subinterfaces'][0]["ipv4_addresses"] = [ip_address]
interfaces += [i]
return [{"interfaces": interfaces}]
def execute(self):
data = self.profile.var_data(self, "/setup_get.cgi")
ip = data["ip"].encode("UTF8")
mask = IPv4.netmask_to_len(data["mask"].encode("UTF8"))
iface = {
"name":
"Fa1",
"admin_status":
True,
"oper_status":
True,
"type":
"physical",
"description":
data["location"].encode("UTF8"),
"mac":
data["mac"].encode("UTF8"),
"subinterfaces": [{
"name": "Fa1",
"admin_status": True,
"oper_status": True,
"type": "physical",
"description": data["hostname"].encode("UTF8"),
"mac": data["mac"].encode("UTF8"),
"enabled_afi": ["IPv4"],
"ipv4_addresses": ["%s/%s" % (ip, mask)],
}],
}
return [{"interfaces": [iface]}]
def execute(self):
interfaces = []
v = self.cli("ethstat")
for match in self.rx_eth.finditer(v):
iface = {
"name": match.group("name"),
"type": "physical",
"enabled_protocols": [],
"subinterfaces": [
{"name": match.group("name"), "enabled_afi": ["BRIDGE"], "tagged_vlans": []}
],
}
interfaces += [iface]
for v in self.scripts.get_vlans():
vlan_id = v["vlan_id"]
c = self.cli("vlan %s -s" % vlan_id)
match = self.rx_vlan.search(c)
if match:
for port in match.group("ports").split(","):
for i in interfaces:
if port == i["name"]:
i["subinterfaces"][0]["tagged_vlans"] += [vlan_id]
break
else:
match = self.rx_vlan2.search(c)
for uport in match.group("uport").split(","):
for i in interfaces:
if uport and uport == i["name"]:
i["subinterfaces"][0]["untagged_vlan"] = vlan_id
for tports in match.group("tports").split(","):
for i in interfaces:
if tports == i["name"]:
i["subinterfaces"][0]["tagged_vlans"] += [vlan_id]
break
v = self.cli("ipconfig")
match = self.rx_ip.search(v)
ip_address = match.group("ip_address")
ip_subnet = match.group("ip_subnet")
ip_address = "%s/%s" % (ip_address, IPv4.netmask_to_len(ip_subnet))
iface = {
"name": "MGMT",
"type": "SVI",
"admin_status": True,
"oper_status": True,
"mac": match.group("mac"),
"enabled_protocols": [],
"subinterfaces": [
{
"name": "MGMT",
"admin_status": True,
"oper_status": True,
"mac": match.group("mac"),
"enabled_afi": ["IPv4"],
"ipv4_addresses": [ip_address],
"vlan_ids": [int(match.group("vlan_id"))],
}
],
}
interfaces += [iface]
return [{"interfaces": interfaces}]
def execute_cli(self, **kwargs):
iface = []
cmd = self.scripts.get_chassis_id()
mac = cmd[0]["first_chassis_mac"]
self.cli("4") # Enter Configuration menu
cmd = self.cli("1") # Enter Network submenu
match = self.rx_ipaddr.search(cmd)
ipaddr = match.group("ip")
match = self.rx_mask.search(cmd)
# netmask may be wrong when DHCP is used!
mask = match.group("mask")
ip = IPv4(ipaddr, mask)
iface += [{
"name":
"mgmt",
"admin_status":
True,
"oper_status":
True,
"type":
"management",
"mac":
mac,
"subinterfaces": [{
"name": "mgmt",
"enabled_afi": ["IPv4"],
"mac": mac,
"ipv4_addresses": [ip],
"admin_status": True,
"oper_status": True,
}],
}]
iface += self.get_phys_ports()
return [{"interfaces": iface}]
def execute_snmp(self, **kwargs):
cmd = self.scripts.get_chassis_id()
mac = cmd[0]["first_chassis_mac"]
ipaddr = self.snmp.get(
"1.3.6.1.4.1.32108.1.7.4.1.1.0") # PLANAR-sdo3002-MIB::currentIP
# netmask may be wrong when DHCP is used!
mask = self.snmp.get("1.3.6.1.4.1.32108.1.7.4.1.4.0"
) # PLANAR-sdo3002-MIB::staticSubnetMask
ip = IPv4(ipaddr, mask)
ifaces = [{
"name":
"mgmt",
"admin_status":
True,
"oper_status":
True,
"type":
"management",
"mac":
mac,
"subinterfaces": [{
"name": "mgmt",
"enabled_afi": ["IPv4"],
"mac": mac,
"ipv4_addresses": [ip],
"admin_status": True,
"oper_status": True,
}],
}]
ifaces += self.get_phys_ports()
return [{"interfaces": ifaces}]
def upload_axfr(data):
p = IP.prefix(prefix.prefix)
count = 0
for row in data:
row = row.strip()
if row == "" or row.startswith(";"):
continue
row = row.split()
if len(row) != 5 or row[2] != "IN" or row[3] != "PTR":
continue
if row[3] == "PTR":
# @todo: IPv6
x = row[0].split(".")
ip = "%s.%s.%s.%s" % (x[3], x[2], x[1], x[0])
fqdn = row[4]
if fqdn.endswith("."):
fqdn = fqdn[:-1]
# Leave only addresses residing into "prefix"
# To prevent uploading to not-owned blocks
if not p.contains(IPv4(ip)):
continue
a, changed = Address.objects.get_or_create(vrf=vrf, afi=afi, address=ip)
if a.fqdn != fqdn:
a.fqdn = fqdn
changed = True
if changed:
a.save()
count += 1
return count
def execute(self):
r = []
ns = {
"isapi": "http://www.isapi.org/ver20/XMLSchema",
"std-cgi": "http://www.std-cgi.com/ver20/XMLSchema",
"hikvision": "http://www.hikvision.com/ver20/XMLSchema",
}
v = self.http.get("/ISAPI/System/Network/interfaces", use_basic=True)
v = v.replace("\n", "")
if "std-cgi" in v:
ns["ns"] = ns["std-cgi"]
elif "www.hikvision.com" in v:
ns["ns"] = ns["hikvision"]
else:
ns["ns"] = ns["isapi"]
root = ElementTree.fromstring(v)
# mac = self.scripts.get_chassis_id()[0]["first_chassis_mac"]
for o in root:
o_id = o.find("{%s}id" % ns["ns"]).text
name = "eth%s" % o_id
iface = {"name": name, "type": "physical", "admin_status": True, "oper_status": True}
sub = {"name": name, "admin_status": True, "oper_status": True, "enabled_afi": []}
try:
v = self.http.get("/ISAPI/System/Network/interfaces/%s/Link" % o_id, use_basic=True)
v = v.replace("\n", "")
v = ElementTree.fromstring(v)
mac = v.find("{%s}MACAddress" % ns["ns"]).text
except HTTPError:
mac = self.scripts.get_chassis_id()[0]["first_chassis_mac"]
if mac:
sub["mac"] = mac
iface["mac"] = mac
ip = o.find("{%s}IPAddress" % ns["ns"])
# for ip in ip_addresses:
afi = ip.find("{%s}ipVersion" % ns["ns"]).text
if afi == "v4":
if "IPv4" not in sub["enabled_afi"]:
sub["enabled_afi"] += ["IPv4"]
ip_address = "%s/%s" % (
ip.find("{%s}ipAddress" % ns["ns"]).text,
IPv4.netmask_to_len(ip.find("{%s}subnetMask" % ns["ns"]).text),
)
if "ipv4_addresses" in sub:
sub["ipv4_addresses"] += [ip_address]
else:
sub["ipv4_addresses"] = [ip_address]
if afi == "v6":
if "IPv6" not in sub["enabled_afi"]:
sub["enabled_afi"] += ["IPv6"]
ip_address = IPv6(
ip.find("{%s}ipAddress" % ns["ns"]).text,
netmask=ip.find("ns:subnetMask", ns).text,
).prefix
iface["subinterfaces"] = [sub]
r += [iface]
return [{"interfaces": r}]
def get_vpn_id(ip):
try:
return vpn_db[IPv4(ip)]
except KeyError:
pass
if self.object.vrf:
return self.object.vrf.vpn_id
return GLOBAL_VRF
def wildcard(self):
"""
Returns Cisco wildcard for IPv4
:return:
"""
if self.is_ipv4:
return IPv4(self.prefix).wildcard.address
return ""
def size(self):
"""
Returns IPv4 prefix size
:return:
"""
if self.is_ipv4:
return IPv4(self.prefix).size
return None
def broadcast(self):
"""
Returns Broadcast for IPv4
:return:
"""
if self.is_ipv4:
return IPv4(self.prefix).last.address
return None
def netmask(self):
"""
returns Netmask for IPv4
:return:
"""
if self.is_ipv4:
return IPv4(self.prefix).netmask.address
return None
def convert_prefix(self, prefix):
"""
Convert ip prefix to the format accepted by router's CLI
"""
if "/" in prefix and self.requires_netmask_conversion:
prefix = IPv4(prefix)
return "%s %s" % (prefix.address, prefix.netmask.address)
return prefix
def on_interface_address(self, tokens):
ip = str(IPv4(tokens[0], netmask=tokens[1]))
si = self.get_current_subinterface()
if len(tokens) > 2 and tokens[2] == "secondary":
si.ipv4_addresses += [ip]
else:
si.ipv4_addresses = [ip] + si.ipv4_addresses
si.add_afi("IPv4")
def to_prefix(self, address, netmask):
"""
Convert address and netmask to prefix form
:param address:
:param netmask:
:return:
"""
return IPv4(address, netmask=netmask).prefix
