class IdsController():
def __init__(self):
self.interfaceController = InterfaceController()
self.interfaceParser = InterfaceParser()
self.bridgeController = BridgeController()
self.idsCoreController = IdsCoreController()
self.idsCoreParser = IdsCoreParser()
self.idsParser = IdsParser()
self.transparent_intefaces = []
def set_configuration(self, json_configuration):
json_interfaces = self.idsParser.parse_interfaces(json_configuration)
for json_iface in json_interfaces:
self.configure_interface(json_iface)
assert len(self.transparent_intefaces
) == 2, "Error: transparent interfaces have to be 2"
logging.debug(
"Found " + str(len(self.transparent_intefaces)) +
" transparent interfaces, now create a bridge between them")
bridge = Bridge("br0", self.transparent_intefaces[0].name,
self.transparent_intefaces[1].name)
logging.debug("Bridge to create: " + bridge.__str__())
self.create_bridge(bridge)
# Configure IDS
if 'config-ids:ids' in json_configuration:
logging.debug("Found and Ids Configuration, try to set it...")
ids_configuration = self.idsParser.parse_ids_configuration(
json_configuration)
self.set_ids_configuration(ids_configuration)
logging.debug("Found and Ids Configuration, try to set it...done!")
logging.debug("Starting snort as a daemon...")
self.idsCoreController.start_ids()
logging.debug("Starting snort as a daemon...done!")
def get_full_status(self):
pass
# Interfaces
def get_interfaces_status(self):
conf_interfaces = {}
conf_interfaces["ifEntry"] = self.get_interfaces()
return conf_interfaces
# Interfaces/ifEntry
def get_interfaces(self):
interfaces = self.interfaceController.get_interfaces()
interfaces_dict = []
for interface in interfaces:
interfaces_dict.append(
self.interfaceParser.get_interface_dict(interface))
return interfaces_dict
def get_interface(self, name):
interface = self.interfaceController.get_interface_by_name(name)
if interface is None:
raise ValueError("could not find interface: " + name)
interface_dict = self.interfaceParser.get_interface_dict(interface)
return interface_dict
def configure_interface(self, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type == "transparent":
self.transparent_intefaces.append(interface)
logging.debug("Found a transparent interface: " +
interface.__str__())
return
else:
iface_found = self.interfaceController.get_interface_by_name(
interface.name)
if iface_found is not None:
if iface_found.__eq__(interface):
return
self.interfaceController.configure_interface(interface)
logging.debug("Configured interface: " + interface.__str__())
def update_interface(self, name, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
if self.interfaceController.interface_exists(name):
self.interfaceController.configure_interface(interface)
logging.debug("Updated interface: " + interface.__str__())
else:
raise ValueError("could not find interface: " + name)
def reset_interface(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
self.interfaceController.reset_interface(name)
def update_interface_ipv4Configuration(self, ifname,
json_ipv4Configuration):
ipv4Configuration = self.interfaceParser.parse_ipv4_configuration(
json_ipv4Configuration)
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration(
ifname, ipv4Configuration)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_address(self, ifname, address):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_address(
ifname, address)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_netmask(self, ifname, netmask):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_netmask(
ifname, netmask)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_default_gw(self, ifname,
default_gw):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_default_gw(
ifname, default_gw)
else:
raise ValueError("could not find interface: " + ifname)
def get_interface_ipv4Configuration(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
ipv4_configuration_dict = self.interfaceParser.get_interface_ipv4Configuration(
interface.ipv4_configuration)
return ipv4_configuration_dict
def get_interface_ipv4Configuration_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.address
def get_interface_ipv4Configuration_netmask(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.netmask
def get_interface_ipv4Configuration_default_gw(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.default_gw
def get_interface_ipv4Configuration_mac_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.mac_address
# Bridge
def create_bridge(self, bridge):
br_found = self.interfaceController.get_interface_by_name(bridge.name)
if br_found is None:
self.bridgeController.create_bridge(bridge)
logging.debug("Bridge created")
else:
logging.debug("Bridge already existent")
# Ids
def set_ids_configuration(self, json_ids_configuration):
idsConfiguration = self.idsCoreParser.parse_ids_configuration(
json_ids_configuration)
self.idsCoreController.set_configuration(idsConfiguration)
def add_attackToMonitor(self, attack):
try:
self.idsCoreController.add_attackToMonitor(attack)
except ValueError as ve:
raise ve
class NatController():
def __init__(self):
self.natParser = NatParser()
self.interfaceController = InterfaceController()
self.interfaceParser = InterfaceParser()
self.natCoreController = NatCoreController()
self.natCoreParser = NatCoreParser()
self.natTableController = NatTableController()
self.natTableParser = NatTableParser()
self.arpTableController = ArpTableController()
self.arpTableParser = ArpTableParser()
self.floatingIpController = FloatingIpController()
self.floatingIpParser = FloatingIpParser()
def set_configuration(self, json_configuration):
json_interfaces = self.natParser.parse_interfaces(json_configuration)
for json_iface in json_interfaces:
self.configure_interface(json_iface)
conf_nat = self.natParser.parse_nat_configuration(json_configuration)
public_interface_id = self.natCoreParser.parse_public_interface(conf_nat)
self.set_ip_forward(public_interface_id)
private_interface_id = self.natCoreParser.parse_private_interface(conf_nat)
if 'nat-table' in conf_nat:
json_nat_table = self.natTableParser.parse_nat_table(conf_nat)
json_nat_sessions = self.natTableParser.parse_nat_sessions(json_nat_table)
for json_nat_session in json_nat_sessions:
self.add_nat_session(json_nat_session)
if 'arp-table' in conf_nat:
json_arp_table = self.arpTableParser.parse_arp_table(conf_nat)
json_arp_entries = self.arpTableParser.parse_arp_entries(json_arp_table)
for json_arp_entry in json_arp_entries:
self.add_arp_entry(json_arp_entry)
if 'floatingIP' in conf_nat:
json_floating_ip_list = self.floatingIpParser.parse_floating_ip_list(conf_nat)
for curr_json_floating_ip in json_floating_ip_list:
self.add_floating_ip(curr_json_floating_ip)
pass
def get_full_status(self):
status = {}
status["config-nat:interfaces"] = self.get_interfaces_status()
status["config-nat:nat"] = self.get_nat_status()
return status
# Interfaces
def get_interfaces_status(self):
conf_interfaces = {}
conf_interfaces["ifEntry"] = self.get_interfaces()
return conf_interfaces
# Interfaces/ifEntry
def get_interfaces(self):
interfaces = self.interfaceController.get_interfaces()
interfaces_dict = []
for interface in interfaces:
interfaces_dict.append(self.interfaceParser.get_interface_dict(interface))
return interfaces_dict
def get_interface(self, name):
interface = self.interfaceController.get_interface_by_name(name)
if interface is None:
raise ValueError("could not find interface: " + name)
interface_dict = self.interfaceParser.get_interface_dict(interface)
interface_dict = self.interfaceParser.get_interface_dict(interface)
return interface_dict
def configure_interface(self, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
iface_found = self.interfaceController.get_interface_by_name(interface.name)
if iface_found is not None:
if iface_found.__eq__(interface):
return
self.interfaceController.configure_interface(interface)
logging.debug("Configured interface: " + interface.__str__())
def update_interface(self, name, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
if self.interfaceController.interface_exists(name):
self.interfaceController.configure_interface(interface)
logging.debug("Updated interface: " + interface.__str__())
else:
raise ValueError("could not find interface: " + name)
def reset_interface(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
self.interfaceController.reset_interface(name)
def update_interface_ipv4Configuration(self, ifname, json_ipv4Configuration):
ipv4Configuration = self.interfaceParser.parse_ipv4_configuration(json_ipv4Configuration)
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration(ifname, ipv4Configuration)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_address(self, ifname, address):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_address(ifname, address)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_netmask(self, ifname, netmask):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_netmask(ifname, netmask)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_default_gw(self, ifname, default_gw):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_default_gw(ifname, default_gw)
else:
raise ValueError("could not find interface: " + ifname)
def get_interface_ipv4Configuration(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
ipv4_configuration_dict = self.interfaceParser.get_interface_ipv4Configuration(interface.ipv4_configuration)
return ipv4_configuration_dict
def get_interface_ipv4Configuration_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.address
def get_interface_ipv4Configuration_netmask(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.netmask
def get_interface_ipv4Configuration_default_gw(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.default_gw
def get_interface_ipv4Configuration_mac_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.mac_address
# Nat
def get_nat_status(self):
nat = {}
nat['private-interface'] = self.get_private_interface_id()
nat['public-interface'] = self.get_public_interface_id()
nat['nat-table'] = self.get_nat_table()
nat['arp-table'] = self.get_arp_table()
nat['floatingIP'] = self.get_all_floating_ip()
return nat
# Nat/Wan-interface
def set_ip_forward(self, public_interface_id):
current_public_iface_name = self.natCoreController.get_public_interface_name()
if current_public_iface_name is None:
public_iface = self.interfaceController.get_interface_by_id(public_interface_id)
self.natCoreController.set_ip_forward(public_iface.name)
logging.debug("Nat set on wan interface: " + public_iface.name)
def unset_ip_forward(self, public_interface_id):
current_public_iface_name = self.natCoreController.get_public_interface_name()
if current_public_iface_name is not None:
public_iface = self.interfaceController.get_interface_by_id(public_interface_id)
self.natCoreController.unset_ip_forward(public_iface.name)
logging.debug("Nat unset")
def get_public_interface_id(self):
public_iface_name = self.natCoreController.get_public_interface_name()
public_iface = self.interfaceController.get_interface_by_name(public_iface_name)
return public_iface.id
def get_private_interface_id(self):
public_iface_name = self.natCoreController.get_public_interface_name()
interfaces = self.interfaceController.get_interfaces()
for interface in interfaces:
if interface.management == False:
if interface.name != public_iface_name:
return interface.id
# Nat/nat-table
def get_nat_table(self):
nat_table = {}
nat_table['nat-session'] = self.get_nat_session()
return nat_table
def get_nat_session(self):
nat_table = self.natTableController.get_nat_table()
nat_table_dict = []
for nat_session in nat_table:
nat_table_dict.append(self.natTableParser.get_nat_session_dict(nat_session))
return nat_table_dict
def add_nat_session(self, json_nat_session):
# not supported
nat_session = self.natTableParser.parse_nat_session(json_nat_session)
self.natTableController.add_nat_session(nat_session)
#logging.debug("Added nat_session: " + nat_session.__str__())
# Nat/arp-table
def get_arp_table(self):
arp_table = {}
arp_table['arp-entry'] = self.get_arp_entry()
return arp_table
def get_arp_entry(self):
arp_table = self.arpTableController.get_arp_table()
arp_table_dict = []
for arp_entry in arp_table:
arp_table_dict.append(self.arpTableParser.get_arp_entry_dict(arp_entry))
return arp_table_dict
def add_arp_entry(self, json_arp_entry):
arp_entry = self.arpTableParser.parse_arp_entry(json_arp_entry)
self.arpTableController.add_arp_entry(arp_entry.ip_address, arp_entry.mac_address)
logging.debug("Added arp_entry: " + arp_entry.__str__())
def delete_arp_entry(self, ip_address):
if self.arpTableController.arp_entry_exists(ip_address):
self.arpTableController.delete_arp_entry(ip_address)
logging.debug("Removed arp_entry with ip_address: " + ip_address)
else:
raise ValueError("There is no entry in arp table with ip_address: " + ip_address)
def get_arp_table_mac_address(self, ip_address):
return self.arpTableController.get_mac_address(ip_address)
def update_arp_table_mac_address(self, ip_address, mac_address):
if self.arpTableController.arp_entry_exists(ip_address):
self.arpTableController.add_arp_entry(ip_address, mac_address)
logging.debug("Updated arp_entry, ip_address: " + ip_address + " mac_address: " + mac_address)
else:
raise ValueError("There is no entry in arp table with ip_address: " + ip_address)
# Nat/StaticBindings
def add_floating_ip(self, json_floating_ip):
floating_ip = self.floatingIpParser.parse_floating_ip(json_floating_ip)
floating_ip_list = self.floatingIpController.get_all_floating_ip()
for curr_floating_ip in floating_ip_list:
if curr_floating_ip.__eq__(floating_ip):
return
wan_interface = self.natCoreController.get_public_interface_name()
self.floatingIpController.configure_floating_ip(floating_ip, wan_interface)
logging.debug("floating_ip set: private address " + floating_ip.private_address + " => public address" + floating_ip.public_address)
def update_floating_ip(self, public_address, json_floating_ip):
pass
def update_floating_ip_private_address(self, public_address, private_address):
pass
def update_floating_ip_public_address(self, public_address, private_address):
pass
def delete_floating_ip(self, public_address):
if self.floatingIpController.floating_ip_exists(public_address):
self.floatingIpController.delete_floating_ip(public_address)
else:
raise ValueError("could not find a floating_ip with public address " + public_address)
def get_all_floating_ip(self):
floating_ip_list = self.floatingIpController.get_all_floating_ip()
floating_ip_dict = []
for floating_ip in floating_ip_list:
floating_ip_dict.append(self.floatingIpParser.get_floating_ip_dict(floating_ip))
return floating_ip_dict
def get_floating_ip(self, public_address):
floating_ip = self.floatingIpController.get_floating_ip(public_address)
if floating_ip is None:
raise ValueError("could not find a floating_ip with public address " + public_address)
floating_ip_dict = self.floatingIpParser.get_floating_ip_dict(floating_ip)
return floating_ip_dict
def get_floating_ip_private_address(self, public_address):
floating_ip_list = self.floatingIpController.get_all_floating_ip()
for floating_ip in floating_ip_list:
if floating_ip.public_address == public_address:
return floating_ip.private_address
raise ValueError("could not find a floating_ip with public address " + public_address)
def get_floating_ip_public_address(self, public_address):
floating_ip_list = self.floatingIpController.get_all_floating_ip()
for floating_ip in floating_ip_list:
if floating_ip.public_address == public_address:
return floating_ip.public_address
raise ValueError("could not find a floating_ip with public address " + public_address)
class DhcpController():
def __init__(self):
self.interfaceController = InterfaceController()
self.interfaceParser = InterfaceParser()
self.dhcpServerController = DhcpServerController()
self.dhcpServerParser = DhcpServerParser()
self.dhcpClientController = DhcpClientController()
self.dhcpClientParser = DhcpClientParser()
self.dhcpParser = DhcpParser()
def set_configuration(self, json_configuration):
json_interfaces = self.dhcpParser.parse_interfaces(json_configuration)
for json_iface in json_interfaces:
self.configure_interface(json_iface)
conf_dhcp_server = self.dhcpParser.parse_dhcp_server(
json_configuration)
self.configure_dhcp_server(conf_dhcp_server)
def get_full_status(self):
status = {}
status["config-firewall:interfaces"] = self.get_interfaces_status()
status["config-dhcp-server:server"] = self.get_dhcp_server_status()
status["config-dhcp-server:clients"] = self.get_clients()
return status
# Interfaces
def get_interfaces_status(self):
conf_interfaces = {}
conf_interfaces["ifEntry"] = self.get_interfaces()
return conf_interfaces
# Interfaces/ifEntry
def get_interfaces(self):
interfaces = self.interfaceController.get_interfaces()
interfaces_dict = []
for interface in interfaces:
interfaces_dict.append(
self.interfaceParser.get_interface_dict(interface))
return interfaces_dict
def get_interface(self, name):
interface = self.interfaceController.get_interface_by_name(name)
if interface is None:
raise ValueError("could not find interface: " + name)
interface_dict = self.interfaceParser.get_interface_dict(interface)
return interface_dict
def configure_interface(self, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
iface_found = self.interfaceController.get_interface_by_name(
interface.name)
if iface_found is not None:
if iface_found.__eq__(interface):
return
self.interfaceController.configure_interface(interface)
logging.debug("Configured interface: " + interface.__str__())
def update_interface(self, name, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
if self.interfaceController.interface_exists(name):
self.interfaceController.configure_interface(interface)
logging.debug("Updated interface: " + interface.__str__())
else:
raise ValueError("could not find interface: " + name)
def reset_interface(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
self.interfaceController.reset_interface(name)
def get_interface_ipv4Configuration(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
ipv4_configuration_dict = self.interfaceParser.get_interface_ipv4Configuration(
interface.ipv4_configuration)
return ipv4_configuration_dict
def get_interface_ipv4Configuration_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.address
def get_interface_ipv4Configuration_netmask(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.netmask
def get_interface_ipv4Configuration_default_gw(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.default_gw
def get_interface_ipv4Configuration_mac_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.mac_address
def update_interface_ipv4Configuration(self, ifname,
json_ipv4Configuration):
ipv4Configuration = self.interfaceParser.parse_ipv4_configuration(
json_ipv4Configuration)
print(ipv4Configuration)
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration(
ifname, ipv4Configuration)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_address(self, ifname, address):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_address(
ifname, address)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_netmask(self, ifname, netmask):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_netmask(
ifname, netmask)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_default_gw(self, ifname,
default_gw):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_default_gw(
ifname, default_gw)
else:
raise ValueError("could not find interface: " + ifname)
# Dhcp
def get_dhcp_status(self):
conf_dhcp = {}
conf_dhcp['server'] = self.get_dhcp_server_configuration()
conf_dhcp['clients'] = self.get_clients()
return conf_dhcp
# Dhcp Server
def get_dhcp_server_status(self):
return self.get_dhcp_server_configuration()
# Dhcp Server/Configuration
def configure_dhcp_server(self, json_dhcp_server_params):
dhcp_server_configuration = self.dhcpServerParser.parse_dhcp_server_configuration(
json_dhcp_server_params)
logging.debug(dhcp_server_configuration.__str__())
logging.debug("Configure dhcp server parameters...")
if self.dhcpServerController.configuration_exists():
current_dhcp_server_configuration = self.dhcpServerController.get_dhcp_server_configuration(
)
if dhcp_server_configuration.__eq__(
current_dhcp_server_configuration):
logging.debug(
"Configure dhcp server parameters...done! (configuration is equal to the previous one)"
)
return
self.dhcpServerController.configure_dhcp_server(
dhcp_server_configuration)
logging.debug("Configure dhcp server parameters...done!")
def add_section(self, json_section):
section = self.dhcpServerParser.parse_section(json_section)
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.add_section(section)
else:
raise ValueError("could not find a dhcp server configuration")
def update_default_lease_time(self, default_lease_time):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_default_lease_time(
default_lease_time)
else:
raise ValueError("could not find a dhcp server configuration")
def update_max_lease_time(self, max_lease_time):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_max_lease_time(max_lease_time)
else:
raise ValueError("could not find a dhcp server configuration")
def update_subnet(self, subnet):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_subnet(subnet)
else:
raise ValueError("could not find a dhcp server configuration")
def update_subnet_mask(self, subnet_mask):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_subnet_mask(subnet_mask)
else:
raise ValueError("could not find a dhcp server configuration")
def update_router(self, router):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_router(router)
else:
raise ValueError("could not find a dhcp server configuration")
def update_dns_primary_server(self, dns_primary_server):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_dns_primary_server(
dns_primary_server)
else:
raise ValueError("could not find a dhcp server configuration")
def update_dns_secondary_server(self, dns_secondary_server):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_dns_secondary_server(
dns_secondary_server)
else:
raise ValueError("could not find a dhcp server configuration")
def update_dns_domain_name(self, dns_domain_name):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_domain_name(dns_domain_name)
else:
raise ValueError("could not find a dhcp server configuration")
def update_section(self, section_start_ip, json_section):
section = self.dhcpServerParser.parse_section(json_section)
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.update_section(section_start_ip, section)
else:
raise ValueError("could not find a dhcp server configuration")
def update_section_start_ip(self, section_start_ip, start_ip):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.add_section_start_ip(
section_start_ip, start_ip)
else:
raise ValueError("could not find a dhcp server configuration")
def update_section_end_ip(self, section_start_ip, end_ip):
if self.dhcpServerController.configuration_exists():
self.dhcpServerController.add_section_end_ip(
section_start_ip, end_ip)
else:
raise ValueError("could not find a dhcp server configuration")
def get_dhcp_server_configuration(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
dhcp_server_configuration = self.dhcpServerController.get_dhcp_server_configuration(
)
return self.dhcpServerParser.get_dhcp_server_configuration_dict(
dhcp_server_configuration)
def get_dhcp_server_configuration_default_lease_time(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
default_lease_time = self.dhcpServerController.get_dhcp_server_configuration_default_lease_time(
)
return default_lease_time
def get_dhcp_server_configuration_max_lease_time(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
max_lease_time = self.dhcpServerController.get_dhcp_server_configuration_max_lease_time(
)
return max_lease_time
def get_dhcp_server_configuration_subnet(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
subnet = self.dhcpServerController.get_dhcp_server_configuration_subnet(
)
return subnet
def get_dhcp_server_configuration_subnet_mask(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
subnet_mask = self.dhcpServerController.get_dhcp_server_configuration_subnet_mask(
)
return subnet_mask
def get_dhcp_server_configuration_router(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
router = self.dhcpServerController.get_dhcp_server_configuration_router(
)
return router
def get_dhcp_server_configuration_dns_primary_server(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
dns_primary_server = self.dhcpServerController.get_dhcp_server_configuration_dns_primary_server(
)
return dns_primary_server
def get_dhcp_server_configuration_dns_secondary_server(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
dns_secondary_server = self.dhcpServerController.get_dhcp_server_configuration_dns_secondary_server(
)
return dns_secondary_server
def get_dhcp_server_configuration_dns_domain_name(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
dns_domain_name = self.dhcpServerController.get_dhcp_server_configuration_dns_domain_name(
)
return dns_domain_name
def get_dhcp_server_configuration_sections(self):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
sections = self.dhcpServerController.get_dhcp_server_configuration_sections(
)
sections_dict = []
for section in sections:
section_dict = self.dhcpServerParser.get_dhcp_server_configuration_section_dict(
section)
sections_dict.append(section_dict)
return sections_dict
def get_dhcp_server_configuration_section(self, section_start_ip):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
section = self.dhcpServerController.get_dhcp_server_configuration_section(
section_start_ip)
if section is not None:
return self.dhcpServerParser.parse_section(section)
else:
raise ValueError("could not find section with start_ip: " +
section_start_ip)
def get_dhcp_server_configuration_section_start_ip(self, section_start_ip):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
start_ip = self.dhcpServerController.get_dhcp_server_configuration_section_start_ip(
section_start_ip)
if start_ip is not None:
return start_ip
else:
raise ValueError("could not find section with start_ip: " +
section_start_ip)
def get_dhcp_server_configuration_section_end_ip(self, section_start_ip):
if not self.dhcpServerController.configuration_exists():
raise ValueError("could not find a dhcp server configuration")
end_ip = self.dhcpServerController.get_dhcp_server_configuration_section_end_ip(
section_start_ip)
if end_ip is not None:
return end_ip
else:
raise ValueError("could not find section with start_ip: " +
section_start_ip)
# Dhcp Client
def get_clients(self):
clients = self.dhcpClientController.get_clients()
clients_dict = []
for client in clients:
clients_dict.append(self.dhcpClientParser.get_client_dict(client))
return clients_dict
def get_client(self, mac_address):
if not self.dhcpClientController.client_exists(mac_address):
raise ValueError("could not find client: " + mac_address)
client = self.dhcpClientController.get_client(mac_address)
client_dict = self.dhcpClientParser.get_client_dict(client)
return client_dict
def get_client_ip_address(self, mac_address):
if not self.dhcpClientController.client_exists(mac_address):
raise ValueError("could not find client: " + mac_address)
client_ip_address = self.dhcpClientController.get_client_ip_address(
mac_address)
return client_ip_address
def get_client_hostname(self, mac_address):
if not self.dhcpClientController.client_exists(mac_address):
raise ValueError("could not find client: " + mac_address)
client_hostname = self.dhcpClientController.get_client_hostname(
mac_address)
return client_hostname
def get_client_valid_until(self, mac_address):
if not self.dhcpClientController.client_exists(mac_address):
raise ValueError("could not find client: " + mac_address)
client_valid_until = self.dhcpClientController.get_client_valid_until(
mac_address)
return client_valid_until
class IperfController():
def __init__(self):
self.iperfParser = IperfParser()
self.interfaceController = InterfaceController()
self.interfaceParser = InterfaceParser()
self.iperfCoreController = IperfCoreController()
self.iperfCoreParser = IperfCoreParser()
def set_configuration(self, json_configuration):
json_interfaces = self.iperfParser.parse_interfaces(json_configuration)
for json_iface in json_interfaces:
self.configure_interface(json_iface)
json_conf_iperf = self.iperfParser.parse_iperf_configuration(json_configuration)
if 'server' in json_conf_iperf:
json_server_params = self.iperfCoreParser.parse_server(json_conf_iperf)
self.start_iperf_server(json_server_params)
if 'client' in json_conf_iperf:
json_client_params = self.iperfCoreParser.parse_client(json_conf_iperf)
self.start_iperf_client(json_client_params)
# Interfaces
def get_interfaces_status(self):
conf_interfaces = {}
conf_interfaces["ifEntry"] = self.get_interfaces()
return conf_interfaces
# Interfaces/ifEntry
def get_interfaces(self):
interfaces = self.interfaceController.get_interfaces()
interfaces_dict = []
for interface in interfaces:
interfaces_dict.append(self.interfaceParser.get_interface_dict(interface))
return interfaces_dict
def get_interface(self, name):
interface = self.interfaceController.get_interface_by_name(name)
if interface is None:
raise ValueError("could not find interface: " + name)
interface_dict = self.interfaceParser.get_interface_dict(interface)
return interface_dict
def configure_interface(self, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
iface_found = self.interfaceController.get_interface_by_name(interface.name)
if iface_found is not None:
if iface_found.__eq__(interface):
return
self.interfaceController.configure_interface(interface)
logging.debug("Configured interface: " + interface.__str__())
def update_interface(self, name, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
if self.interfaceController.interface_exists(name):
self.interfaceController.configure_interface(interface)
logging.debug("Updated interface: " + interface.__str__())
else:
raise ValueError("could not find interface: " + name)
def reset_interface(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
self.interfaceController.reset_interface(name)
def get_interface_ipv4Configuration(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
ipv4_configuration_dict = self.interfaceParser.get_interface_ipv4Configuration(interface.ipv4_configuration)
return ipv4_configuration_dict
def get_interface_ipv4Configuration_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.address
def get_interface_ipv4Configuration_netmask(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.netmask
def get_interface_ipv4Configuration_default_gw(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.default_gw
def get_interface_ipv4Configuration_mac_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.mac_address
def update_interface_ipv4Configuration(self, ifname, json_ipv4Configuration):
ipv4Configuration = self.interfaceParser.parse_ipv4_configuration(json_ipv4Configuration)
print(ipv4Configuration)
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration(ifname, ipv4Configuration)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_address(self, ifname, address):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_address(ifname, address)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_netmask(self, ifname, netmask):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_netmask(ifname, netmask)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_default_gw(self, ifname, default_gw):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_default_gw(ifname, default_gw)
else:
raise ValueError("could not find interface: " + ifname)
# Iperf
def start_iperf_client(self, json_iperf_client):
iperf_client = self.iperfCoreParser.parse_client_configuration(json_iperf_client)
return self.iperfCoreController.start_iperf_client(iperf_client)
def start_iperf_server(self, json_iperf_server):
iperf_server = self.iperfCoreParser.parse_server_configuration(json_iperf_server)
return self.iperfCoreController.start_iperf_server(iperf_server)
class FirewallController():
def __init__(self):
self.interfaceController = InterfaceController()
self.interfaceParser = InterfaceParser()
self.bridgeController = BridgeController()
self.policyController = PolicyController()
self.policyParser = PolicyParser()
self.blacklistController = BlacklistController()
self.blacklistParser = BlacklistParser()
self.whitelistController = WhitelistController()
self.whitelistParser = WhitelistParser()
self.firewallParser = FirewallParser()
self.transparent_intefaces = []
self.wan_interface = None
def set_configuration(self, json_configuration):
json_interfaces = self.firewallParser.parse_interfaces(
json_configuration)
for json_iface in json_interfaces:
self.configure_interface(json_iface)
conf_firewall = self.firewallParser.parse_firewall_configuration(
json_configuration)
self.set_wan_interface(conf_firewall)
assert len(self.transparent_intefaces
) == 2, "Error: transparent interfaces have to be 2"
logging.debug(
"Found " + str(len(self.transparent_intefaces)) +
" transparent interfaces, now create a bridge between them")
to_lan_interface = None
to_wan_interface = None
for tr_iface in self.transparent_intefaces:
if tr_iface.name == self.wan_interface:
to_wan_interface = tr_iface
else:
to_lan_interface = tr_iface
logging.debug("to_wan_interface : " + to_wan_interface.__str__())
logging.debug("to_lan_interface : " + to_lan_interface.__str__())
bridge = Bridge("br0", to_lan_interface.name, to_wan_interface.name)
logging.debug("Bridge to create: " + bridge.__str__())
if self.create_bridge(bridge) is True:
Bash('route del default')
Bash('/usr/sbin/dhclient ' + bridge.name + ' -nw')
br_iface = self.interfaceController.get_interface_by_name(
bridge.name)
policy = Policy(
description="drop all traffic from fw_host to lan_iface",
action="drop",
protocol="ipv4",
out_interface=to_lan_interface.name,
src_address=br_iface.ipv4_configuration.address)
self.policyController.add_policy(policy,
table="FILTER",
chain="OUTPUT")
#Bash('ebtables -A OUTPUT -p IPv4 --ip-src ' + br_iface.ipv4_configuration.address + ' --out-interface ' + to_lan_interface + ' -j DROP')
json_policies = self.policyParser.parse_policies(conf_firewall)
for json_policy in json_policies[::-1]:
self.add_policy(json_policy)
json_blacklist = self.blacklistParser.parse_blacklist(conf_firewall)
for json_url in json_blacklist:
url = self.blacklistParser.parse_url(json_url)
self.add_blacklist_url(url)
json_whitelist = self.whitelistParser.parse_whitelist(conf_firewall)
for json_url in json_whitelist:
url = self.whitelistParser.parse_url(json_url)
self.add_whitelist_url(url)
def get_full_status(self):
status = {}
status["config-firewall:interfaces"] = self.get_interfaces_status()
status["config-firewall:firewall"] = self.get_firewall_status()
return status
# Interfaces
def get_interfaces_status(self):
conf_interfaces = {}
conf_interfaces["ifEntry"] = self.get_interfaces()
conf_interfaces["wan-interface"] = self.get_wan_interface()
return conf_interfaces
# Interfaces/ifEntry
def get_interfaces(self):
interfaces = self.interfaceController.get_interfaces()
interfaces_dict = []
for interface in interfaces:
interfaces_dict.append(
self.interfaceParser.get_interface_dict(interface))
return interfaces_dict
def get_interface(self, name):
interface = self.interfaceController.get_interface_by_name(name)
if interface is None:
raise ValueError("could not find interface: " + name)
interface_dict = self.interfaceParser.get_interface_dict(interface)
return interface_dict
def configure_interface(self, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type == "transparent":
self.transparent_intefaces.append(interface)
logging.debug("Found a transparent interface: " +
interface.__str__())
return
else:
iface_found = self.interfaceController.get_interface_by_name(
interface.name)
if iface_found is not None:
if iface_found.__eq__(interface):
return
self.interfaceController.configure_interface(interface)
logging.debug("Configured interface: " + interface.__str__())
def update_interface(self, name, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
if self.interfaceController.interface_exists(name):
self.interfaceController.configure_interface(interface)
logging.debug("Updated interface: " + interface.__str__())
else:
raise ValueError("could not find interface: " + name)
def reset_interface(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
self.interfaceController.reset_interface(name)
def update_interface_ipv4Configuration(self, ifname,
json_ipv4Configuration):
ipv4Configuration = self.interfaceParser.parse_ipv4_configuration(
json_ipv4Configuration)
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration(
ifname, ipv4Configuration)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_address(self, ifname, address):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_address(
ifname, address)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_netmask(self, ifname, netmask):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_netmask(
ifname, netmask)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_default_gw(self, ifname,
default_gw):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_default_gw(
ifname, default_gw)
else:
raise ValueError("could not find interface: " + ifname)
def get_interface_ipv4Configuration(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
ipv4_configuration_dict = self.interfaceParser.get_interface_ipv4Configuration(
interface.ipv4_configuration)
return ipv4_configuration_dict
def get_interface_ipv4Configuration_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.address
def get_interface_ipv4Configuration_netmask(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.netmask
def get_interface_ipv4Configuration_default_gw(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.default_gw
def get_interface_ipv4Configuration_mac_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.mac_address
# Interfaces/Wan-interface
def get_wan_interface(self):
return self.wan_interface
def set_wan_interface(self, json_configuration):
self.wan_interface = json_configuration['wan-interface']
# Bridge
def create_bridge(self, bridge):
br_found = self.interfaceController.get_interface_by_name(bridge.name)
if br_found is None:
self.bridgeController.create_bridge(bridge)
logging.debug("Bridge created")
return True
else:
logging.debug("Bridge already existent")
return False
# Firewall
def get_firewall_status(self):
firewall = {}
firewall['policies'] = self.get_policies()
firewall['blacklist'] = self.get_blacklist()
firewall['whitelist'] = self.get_whitelist()
return firewall
# Firewall/Policies
def add_policy(self, json_policy):
policy = self.policyParser.parse_policy(json_policy)
policies = self.policyController.get_policies()
for pol in policies:
if pol.__eq__(policy):
logging.debug("The policy already exists, return")
return
id = self.policyController.add_policy(policy)
logging.debug("Configured policy: " + policy.__str__())
return id
def update_policy(self, id, json_policy):
pass
def update_policy_description(self, id, description):
pass
def update_policy_action(self, id, action):
pass
def update_policy_protocol(self, id, protocol):
pass
def update_policy_in_interface(self, id, in_interface):
pass
def update_policy_out_interface(self, id, out_interface):
pass
def update_policy_src_address(self, id, src_address):
pass
def update_policy_dst_address(self, id, dst_address):
pass
def update_policy_src_port(self, id, src_port):
pass
def update_policy_dst_port(self, id, dst_port):
pass
def get_policies(self):
policies = self.policyController.get_policies()
policies_dict = []
for policy in policies:
policies_dict.append(self.policyParser.get_policy_dict(policy))
return policies_dict
def get_policy(self, id):
policy = self.policyController.get_policy(id)
if policy is None:
raise ValueError("could not find policy: " + id)
policy_dict = self.policyParser.get_policy_dict(policy)
return policy_dict
def get_policy_description(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.description
def get_policy_action(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.action
def get_policy_protocol(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.protocol
def get_policy_in_interface(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.in_interface
def get_policy_out_interface(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.out_interface
def get_policy_src_address(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.src_address
def get_policy_dst_address(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.dst_address
def get_policy_src_port(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.src_port
def get_policy_dst_port(self, id):
if not self.policyController.policy_exists(id):
raise ValueError("could not find policy: " + id)
policy = self.policyController.get_policy(id)
return policy.dst_port
def delete_policies(self):
self.policyController.delete_policies()
def delete_policy(self, id):
if self.policyController.policy_exists(id):
self.policyController.delete_policy(id)
else:
raise ValueError("could not find policy: " + id)
def clear_policy_repo(self):
self.policyController.clear_policy_repo()
# Firewall/Blacklist
def add_blacklist_url(self, url):
blacklist = self.blacklistController.get_blacklist()
for curr_url in blacklist:
if curr_url.__eq__(url):
return
self.blacklistController.configure_url(url)
logging.debug("Configured blacklist url: " + url)
def get_blacklist(self):
blacklist = self.blacklistController.get_blacklist()
blacklist_dict = []
for url in blacklist:
blacklist_dict.append(self.blacklistParser.get_url_dict(url))
return blacklist_dict
def delete_blacklist(self):
pass
def delete_blacklist_url(self, url):
if self.blacklistController.url_exists(url):
self.blacklistController.delete_url(url)
else:
raise ValueError("could not find url " + url + " in blacklist")
# Firewall/Whitelist
def add_whitelist_url(self, url):
whitelist = self.whitelistController.get_whitelist()
for curr_url in whitelist:
if curr_url.__eq__(url):
return
self.whitelistController.configure_url(url)
logging.debug("Configured whitelist url: " + url)
def get_whitelist(self):
whitelist = self.whitelistController.get_whitelist()
whitelist_dict = []
for url in whitelist:
whitelist_dict.append(self.whitelistParser.get_url_dict(url))
return whitelist_dict
def delete_whitelist(self):
pass
def delete_whitelist_url(self, url):
if self.whitelistController.url_exists(url):
self.whitelistController.delete_url(url)
else:
raise ValueError("could not find url " + url + " in whitelist")
class TrafficShaperController():
def __init__(self):
self.trafficShaperParser = TrafficShaperParser()
self.interfaceController = InterfaceController()
self.interfaceParser = InterfaceParser()
self.bridgeController = BridgeController()
self.trafficShaperCoreController = TrafficShaperCoreController()
self.trafficShaperCoreParser = TrafficShaperCoreParser()
self.transparent_interfaces = []
def set_configuration(self, json_configuration):
json_interfaces = self.trafficShaperParser.parse_interfaces(
json_configuration)
for json_iface in json_interfaces:
self.configure_interface(json_iface)
if len(self.transparent_interfaces) == 2:
iface1 = self.transparent_interfaces[0].name
iface2 = self.transparent_interfaces[1].name
bridge = Bridge("br0", iface1, iface2)
logging.debug("Bridge to create: " + bridge.__str__())
self.create_bridge(bridge)
elif len(self.transparent_interfaces) == 0:
self.enable_ip_forwarding()
else:
logging.debug("Error: transparent interfaces must be two")
json_traffic_shaper = self.trafficShaperParser.parse_traffic_shaper_configuration(
json_configuration)
if 'configuration' in json_traffic_shaper:
json_traffic_shaper_configuration = self.trafficShaperCoreParser.parse_configuration(
json_traffic_shaper)
self.start_bandwitdh_shaping(json_traffic_shaper_configuration)
def get_full_status(self):
status = {}
status[
"config-traffic-shaper:interfaces"] = self.get_interfaces_status()
configuration = {}
configuration['configuration'] = self.get_all_traffic_shapers()
status["config-traffic-shaper:traffic_shaper"] = configuration
return status
# Interfaces
def get_interfaces_status(self):
conf_interfaces = {}
conf_interfaces["ifEntry"] = self.get_interfaces()
return conf_interfaces
# Bridge
def create_bridge(self, bridge):
br_found = self.interfaceController.get_interface_by_name(bridge.name)
if br_found is None:
self.bridgeController.create_bridge(bridge)
logging.debug("Bridge created")
return True
else:
logging.debug("Bridge already existent")
return False
# Interfaces/ifEntry
def get_interfaces(self):
interfaces = self.interfaceController.get_interfaces()
interfaces_dict = []
for interface in interfaces:
interfaces_dict.append(
self.interfaceParser.get_interface_dict(interface))
return interfaces_dict
def get_interface(self, name):
interface = self.interfaceController.get_interface_by_name(name)
if interface is None:
raise ValueError("could not find interface: " + name)
interface_dict = self.interfaceParser.get_interface_dict(interface)
return interface_dict
def configure_interface(self, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type == "transparent":
self.transparent_interfaces.append(interface)
logging.debug("Found a transparent interface: " +
interface.__str__())
return
else:
iface_found = self.interfaceController.get_interface_by_name(
interface.name)
if iface_found is not None:
if iface_found.__eq__(interface):
return
self.interfaceController.configure_interface(interface)
logging.debug("Configured interface: " + interface.__str__())
def update_interface(self, name, json_interface):
interface = self.interfaceParser.parse_interface(json_interface)
if interface.type != "transparent":
if self.interfaceController.interface_exists(name):
self.interfaceController.configure_interface(interface)
logging.debug("Updated interface: " + interface.__str__())
else:
raise ValueError("could not find interface: " + name)
def reset_interface(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
self.interfaceController.reset_interface(name)
def get_interface_ipv4Configuration(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
ipv4_configuration_dict = self.interfaceParser.get_interface_ipv4Configuration(
interface.ipv4_configuration)
return ipv4_configuration_dict
def get_interface_ipv4Configuration_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.address
def get_interface_ipv4Configuration_netmask(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.netmask
def get_interface_ipv4Configuration_default_gw(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.default_gw
def get_interface_ipv4Configuration_mac_address(self, name):
if not self.interfaceController.interface_exists(name):
raise ValueError("could not find interface: " + name)
interface = self.interfaceController.get_interface_by_name(name)
return interface.ipv4_configuration.mac_address
def update_interface_ipv4Configuration(self, ifname,
json_ipv4Configuration):
ipv4Configuration = self.interfaceParser.parse_ipv4_configuration(
json_ipv4Configuration)
print(ipv4Configuration)
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration(
ifname, ipv4Configuration)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_address(self, ifname, address):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_address(
ifname, address)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_netmask(self, ifname, netmask):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_netmask(
ifname, netmask)
else:
raise ValueError("could not find interface: " + ifname)
def update_interface_ipv4Configuration_default_gw(self, ifname,
default_gw):
if self.interfaceController.interface_exists(ifname):
self.interfaceController.configure_interface_ipv4Configuration_default_gw(
ifname, default_gw)
else:
raise ValueError("could not find interface: " + ifname)
def enable_ip_forwarding(self):
self.trafficShaperCoreController.enable_ip_forwarding()
logging.debug("ip_forwarding enabled")
# Traffic Shaper
def start_bandwitdh_shaping(self, json_traffic_shaper):
logging.debug(json_traffic_shaper)
for json_interface_to_shape in json_traffic_shaper:
traffic_shaper = self.trafficShaperCoreParser.parse_traffic_shaper_configuration(
json_interface_to_shape)
logging.debug(traffic_shaper.__str__())
interface_name = self.trafficShaperCoreParser.parse_interface_to_control(
json_interface_to_shape)
interface = self.interfaceController.get_interface_by_name(
interface_name)
traffic_shaper.add_interface_name(interface.name)
traffic_shaper.add_interface_address(
interface.ipv4_configuration.address)
self.trafficShaperCoreController.start_bandwitdh_shaping(
traffic_shaper)
def stop_bandwitdh_shaping(self, interface_name):
if self.trafficShaperCoreController.traffic_shaper_exists(
interface_name):
self.trafficShaperCoreController.stop_bandwitdh_shaping(
interface_name)
else:
raise ValueError("could not find traffic shaper for interface: " +
interface_name)
def update_bandwitdh_shaping(self, interface_name, json_traffic_shaper):
if self.trafficShaperCoreController.traffic_shaper_exists(
interface_name):
traffic_shaper = self.trafficShaperCoreParser.parse_traffic_shaper_configuration(
json_traffic_shaper)
logging.debug(traffic_shaper.__str__())
interface = self.interfaceController.get_interface_by_name(
interface_name)
traffic_shaper.add_interface_name(interface.name)
traffic_shaper.add_interface_address(
interface.ipv4_configuration.address)
self.trafficShaperCoreController.update_bandwidth_shaping(
traffic_shaper)
def update_bandwitdh_shaping_download_limit(self, interface_name,
download_limit):
if self.trafficShaperCoreController.traffic_shaper_exists(
interface_name):
self.trafficShaperCoreController.update_bandwidth_shaping_download_limit(
interface_name, download_limit)
else:
raise ValueError("could not find traffic shaper for interface: " +
interface_name)
def update_bandwitdh_shaping_upload_limit(self, interface_name,
upload_limit):
if self.trafficShaperCoreController.traffic_shaper_exists(
interface_name):
self.trafficShaperCoreController.update_bandwidth_shaping_upload_limit(
interface_name, upload_limit)
else:
raise ValueError("could not find traffic shaper for interface: " +
interface_name)
def get_all_traffic_shapers(self):
traffic_shapers_dict = []
traffic_shaper_list = self.trafficShaperCoreController.get_all_traffic_shapers(
)
for traffic_shaper in traffic_shaper_list:
traffic_shapers_dict.append(
self.trafficShaperCoreParser.get_traffic_shaper_dict(
traffic_shaper))
return traffic_shapers_dict
def get_traffic_shaper(self, interface_name):
if interface_name is not None:
if self.trafficShaperCoreController.traffic_shaper_exists(
interface_name):
traffic_shaper = self.trafficShaperCoreController.get_traffic_shaper(
interface_name)
return self.trafficShaperCoreParser.get_traffic_shaper_dict(
traffic_shaper)
else:
raise ValueError(
"could not find traffic shaper for interface: " +
interface_name)