def display_type(self, display=False) -> None:
if display is True:
self._display()
elif display is False:
if self.address_type == 0:
machine_type = self.lang_dict['addr_types']['net']
elif self.address_type == 1:
machine_type = self.lang_dict['addr_types']['mac']
elif self.address_type == 2:
machine_type = self.lang_dict['addr_types']['bct']
else:
machine_type = None
temp = Utils.netr_to_literal(self.network_range)
temp['address_type'] = machine_type
print(temp)
def __display_subnets(self, advanced=False) -> None:
if not self.__activated:
return
occupied, graph, t = self.__build_graph()
literal_ip = Utils.to_literal(self.ip)
literal_netr = Utils.netr_to_literal(self.__total_network_range)
print(self.lang_dict['network'])
if advanced is True:
print(self.lang_dict['cidr_adv'].format(literal_ip, self.mask_length))
else:
print(self.lang_dict['cidr'].format(literal_ip, self.mask_length))
print("{} - {}".format(literal_netr['start'], literal_netr['end']))
if advanced is True:
print(self.lang_dict['addr_avail_advanced'].format(occupied, self.addresses))
else:
print(self.lang_dict['addr_avail'].format(self.addresses))
print('')
print(self.lang_dict['utils'].format(len(self.__subnets), t))
for i in range(len(self.__subnets)):
literal_sub_netr = self.__subnets[i].displayable_network_range
if advanced:
print(self.lang_dict['sub_addr_advanced'].format(literal_sub_netr['start'],
literal_sub_netr['end'],
2 ** self.__submasks_machine_bits[i] - 2,
self.__subnets_sizes[i]))
else:
print(self.lang_dict['sub_addr'].format(literal_sub_netr['start'],
literal_sub_netr['end'],
2 ** self.__submasks_machine_bits[i] - 2))
if advanced:
print('')
print(self.lang_dict['net_usage'])
print(graph)
def network_raw_output(self):
"""
Returns a raw output of the local network
"""
final = {'subnets': {}, 'routers': {}}
for sid in self.subnetworks:
subnet = self.subnetworks[sid]['instance']
displayable_connected_routers = subnet.routers.copy()
for i in displayable_connected_routers:
displayable_connected_routers[i] = str(
displayable_connected_routers[i])
final['subnets'][sid] = {
'id': subnet.uid,
'name': subnet.name,
'connected_routers': displayable_connected_routers,
'range': Utils.netr_to_literal(subnet.network_range),
'mask': subnet.mask_length
}
for rid in self.routers:
router = self.routers[rid]
displayable_connected_subnets = router.connected_networks.copy()
for i in displayable_connected_subnets:
displayable_connected_subnets[i] = str(
displayable_connected_subnets[i])
final['routers'][rid] = {
'id': router.uid,
'name': router.name,
'connected_subnets': displayable_connected_subnets,
'internet': router.internet
}
return final
def displayable_network_range(self):
return Utils.netr_to_literal(self.__network_range)
def display_range(self, display=False) -> None:
if display is True:
self._display()
else:
print(Utils.netr_to_literal(self.network_range))
def create_network(self, ip, mask_length, name=None):
"""
Creates a virtual subnetwork
Args:
ip: The given IP
mask_length: The network mask length of the subnetwork
name: The eventual name of the subnetwork
"""
uid = len(self.subnetworks)
# Name correspondency
if name:
result = self.is_name_existing('subnet', name)
if result:
raise NameAlreadyExists(name)
else:
name = f"<Untitled Network#ID:{uid}>"
current = self.Network(ip, mask_length, uid, name)
current_netr = Utils.netr_to_literal(current.network_range)
if self.ranges:
for sid in self.subnetworks:
subnet = self.subnetworks[sid]['instance']
subnetr = Utils.netr_to_literal(subnet.network_range)
overlap = False
if current.mask_length == subnet.mask_length:
# Masks are equal
if current_netr['start'] == subnetr['start']:
overlap = True
else:
if current.mask_length < subnet.mask_length:
# New network mask is bigger, check if the existing subnetwork is inside
big = current_netr['start'].split('.')
small = subnetr['start']
else:
# New network is smaller that existing subnetwork, check if it is inside
small = current_netr['start']
big = subnetr['start'].split('.')
if current.mask_length <= 8:
if int(big[0]) <= int(small.split('.')[0]):
overlap = True
elif 8 < current.mask_length <= 16:
if small.startswith(f"{big[0]}") and int(
big[1]) <= int(small.split('.')[1]):
overlap = True
elif 16 < current.mask_length <= 24:
if small.startswith(f"{big[0]}.{big[1]}") and int(
big[2]) <= int(small.split('.')[2]):
overlap = True
elif 24 < current.mask_length <= 32:
if int(big[3]) <= int(small.split('.')[3]):
overlap = True
if overlap:
raise OverlappingError(current_netr, subnetr)
self.subnetworks[uid] = {
'instance': current,
'range': current.network_range
}
# adding to network ranges
self.ranges.append(current.network_range)
# also adding name if defined
if name:
self.subnets_names.append(name)
return uid