def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int,
ip: str, ip_mask: int, config_ip: str, config_ip_mask: int,
usr_name: str, usr_password: str, power_socket: int):
RemoteSystem.__init__(self)
self._id = id
self._ip = ip
self._ip_mask = ip_mask
self._config_ip = config_ip
self._config_ip_mask = config_ip_mask
self._vlan_iface_id = vlan_iface_id
self._vlan_iface_name = vlan_iface_name
self._namespace_name = "nsp" + str(self._vlan_iface_id)
self._power_socket = power_socket
# Optional values
self._mode = Mode.unknown
self._model = ""
self._usr_name = usr_name
self._usr_password = usr_password
self._mac = '00:00:00:00:00:00'
self._ssid = ''
self.interfaces = dict()
self.cpu_processes = list()
self.sockets = list()
self._ram = None
self._flashdriver = None
self._firmware = Firmware.get_default_firmware()
def _verified_download(self, firmware: Firmware, hash_firmware: str,
max_attempts: int) -> bool:
"""
Downloads the given Firmware and checks if the download was correct and if the hash is matching
:param firmware:
:param hash_firmware:
:param max_attempts: max number of attemps to download a firmware
:return: bool
"""
valid_download = False
count = 0
while (not valid_download) & (count < max_attempts):
valid_download = self._download_file(firmware.url, firmware.file,
firmware.release_model)
if valid_download:
valid_download = firmware.check_hash(hash_firmware)
count += 1
if count >= max_attempts:
Logger().debug(
"[-] The Firmware(" + firmware.name +
") couldn't be downloaded", 3)
return False
else:
Logger().debug(
"[+] The Firmware(" + firmware.name +
") was successfully downloaded", 3)
return True
def import_firmwares(self, release_model: str):
"""
Imports the stored Firmwares, so the firmware_handler can use them.
:param release_model: stable, beta, experimental
"""
path = FIRMWARE_PATH + '/' + release_model + '/' + self.UPDATE_TYPE + '/'
logging.debug("%sImport Firmwares from '" + path + "'", LoggerSetup.get_log_deep(2))
count = 0
try:
files = os.listdir(path)
except Exception:
logging.debug("%sNo Firmwares available for import at path '" + path + "'", LoggerSetup.get_log_deep(3))
return
for firmware_name in files:
try:
freifunk_verein = firmware_name.split('-')[1]
firmware_version = firmware_name.split('-')[2]
file = path + firmware_name
url = self.url + '/' + release_model + '/' + self.UPDATE_TYPE + '/' + firmware_name
self.firmwares.append(Firmware(firmware_name, firmware_version, freifunk_verein,
release_model, file, url))
count += 1
except Exception:
logging.warning("%s[-] Couldn't import " + firmware_name, LoggerSetup.get_log_deep(3))
continue
logging.debug("%s" + str(count) + " Firmwares imported", LoggerSetup.get_log_deep(3))
def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int, ip: str, ip_mask: int,
config_ip: str, config_ip_mask: int, usr_name: str, usr_password: str, power_socket: int):
RemoteSystem.__init__(self)
self._id = id
self._ip = ip
self._ip_mask = ip_mask
self._config_ip = config_ip
self._config_ip_mask = config_ip_mask
self._vlan_iface_id = vlan_iface_id
self._vlan_iface_name = vlan_iface_name
self._namespace_name = "nsp" + str(self._vlan_iface_id)
self._power_socket = power_socket
# Optional values
self._mode = Mode.unknown
self._model = ""
self._usr_name = usr_name
self._usr_password = usr_password
self._mac = '00:00:00:00:00:00'
self._ssid = ''
self.interfaces = dict()
self.cpu_processes = list()
self.sockets = list()
self._ram = None
self._flashdriver = None
self._firmware = Firmware.get_default_firmware()
def _get_all_firmwares(self, release_model: str):
"""
Creats a list of Firmwares and a list of related Hashs.
All Firmwares are given from the Manifest which is downloaded first.
:param release_model: stable, beta, experimental
:return:
"""
firmwares = []
hashs = []
non_parsed_firmwares = self._read_firmwares_from_manifest(
release_model)
for firmware in non_parsed_firmwares:
firmware_name = "gluon" + firmware.split("gluon")[1].split("-sysupgrade")[0] + "-" + \
FirmwareHandler.UPDATE_TYPE + "." + firmware.split(".")[-1].replace("\n", "")
hash_firmware = firmware.split(' ')[4]
freifunk_verein = firmware_name.split('-')[1]
firmware_version = firmware_name.split('-')[2]
file = (self.FIRMWARE_PATH + '/' + release_model + '/' +
FirmwareHandler.UPDATE_TYPE + '/' + firmware_name)
url = self.url + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' + firmware_name
firmwares.append(
Firmware(firmware_name, firmware_version, freifunk_verein,
release_model, file, url))
hashs.append(hash_firmware)
return [firmwares, hashs]
def _get_all_firmwares(self, release_model: str):
"""
Creats a list of Firmwares and a list of related hashs.
All Firmwares are given from the Manifest which is downloaded first.
:param release_model: Can be set to: 'stable', 'beta' or 'experimental'. Used in the url
:return: Tuple of a list of Firmware-Obj and a list of hashs
"""
firmwares = []
hashs = []
non_parsed_firmwares = self._read_firmwares_from_manifest(release_model)
for firmware in non_parsed_firmwares:
if firmware.find("---\n") != -1: # skip the end of the file
continue
firmware_name = "gluon" + firmware.split("gluon")[1].split("-sysupgrade")[0] + "-" + \
FirmwareHandler.UPDATE_TYPE + "." + firmware.split(".")[-1].replace("\n", "")
hash_firmware = firmware.split(' ')[4]
freifunk_verein = firmware_name.split('-')[1]
firmware_version = firmware_name.split('-')[2]
file = (FIRMWARE_PATH + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' +
firmware_name)
url = self.url + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' + firmware_name
firmwares.append(Firmware(firmware_name, firmware_version, freifunk_verein, release_model, file, url))
hashs.append(hash_firmware)
return [firmwares, hashs]
def import_firmwares(self, release_model: str):
"""
Imports the stored Firmwares, so the firmware_handler can use them.
:param release_model: stable, beta, experimental
"""
path = self.FIRMWARE_PATH + '/' + release_model + '/' + self.UPDATE_TYPE + '/'
Logger().debug("Import Firmwares from '" + path + "'", 2)
count = 0
try:
files = os.listdir(path)
except Exception as e:
Logger().debug("No Firmwares available for download at path '" + path + "'", 3)
return
for firmware_name in files:
try:
freifunk_verein = firmware_name.split('-')[1]
firmware_version = firmware_name.split('-')[2]
file = path + firmware_name
url = self.url + '/' + release_model + '/' + self.UPDATE_TYPE + '/' + firmware_name
self.firmwares.append(Firmware(firmware_name, firmware_version, freifunk_verein,
release_model, file, url))
count += 1
except Exception as e:
Logger().warning("[-] Couldn't import " + firmware_name, 3)
continue
Logger().debug(str(count) + " Firmwares imported", 3)
def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int,
ip: str, ip_mask: int, config_ip: str, config_ip_mask: int,
usr_name: str, usr_password: str, power_socket: int):
ProxyObject.__init__(self)
self._id = id
self._ip = ip
self._ip_mask = ip_mask
self._config_ip = config_ip
self._config_ip_mask = config_ip_mask
self._vlan_iface_id = vlan_iface_id
self._vlan_iface_name = vlan_iface_name
self._namespace_name = "nsp" + str(self._vlan_iface_id)
self._power_socket = power_socket
# Optional values
self._mode = Mode.unknown
self._model = None
self._usr_name = usr_name
self._usr_password = usr_password
self._mac = '00:00:00:00:00:00'
self._wlan_mode = WlanMode.unknown
self._ssid = ''
self._firmware = Firmware.get_default_firmware()
def test_create_Firmware(self):
firmware_name = "gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin"
url = "https://firmware.darmstadt.freifunk.net"
firmware = Firmware(firmware_name, "0.7.3", "ffda", "stable",
"/folder/folder/file", url)
assert isinstance(firmware, Firmware)
self.assertEqual(firmware_name, firmware.name)
self.assertEqual("0.7.3", firmware.version)
self.assertEqual("ffda", firmware.freifunk_verein)
self.assertEqual("stable", firmware.release_model)
self.assertEqual("/folder/folder/file", firmware.file)
self.assertEqual(url, firmware.url)
def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int,
ip: str, ip_mask: int, config_ip: str, config_ip_mask: int,
usr_name: str, usr_password: str, power_socket: int):
"""
:param id: The id of the Router
:param vlan_iface_name: The name of the VLAN, which the Router is connected to
:param vlan_iface_id: The id of the VLAN, which the RemoteSystem is connected to
:param ip: The IP on which the RemoteSystem is listening in normal-mode
:param ip_mask: Mask of the IP on which the RemoteSystem is listening in normal-mode
:param config_ip: The IP on which the RemoteSystem is listening in configuration-mode
:param config_ip_mask: Mask of the IP on which the RemoteSystem is listening in configuration-mode
:param usr_name: The user-name that is used via SSH
:param usr_password: The password that is used via SSH
:param power_socket: The port on the power_socker where the Router is connected to.
:return:
"""
RemoteSystem.__init__(self)
self._id = id
self._ip = ip
self._ip_mask = ip_mask
self._config_ip = config_ip
self._config_ip_mask = config_ip_mask
self._vlan_iface_id = vlan_iface_id
self._vlan_iface_name = vlan_iface_name
self._namespace_name = "nsp" + str(self._vlan_iface_id)
self._usr_name = usr_name
self._usr_password = usr_password
self._power_socket = power_socket
# Optional values
self._mode = Mode.unknown
self._model = ""
self._mac = '00:00:00:00:00:00'
self._node_name = ""
self._public_key = ""
self.network_interfaces = dict()
self.cpu_processes = list()
self.sockets = list()
self._ram = None
self._flashdriver = None
self._firmware = Firmware.get_default_firmware()
self.uci = dict()
self.bat_originators = list()
def __init__(
self,
id: int,
vlan_iface_name: str,
vlan_iface_id: int,
ip: str,
ip_mask: int,
config_ip: str,
config_ip_mask: int,
usr_name: str,
usr_password: str,
power_socket: int,
):
ProxyObject.__init__(self)
self._id = id
self._ip = ip
self._ip_mask = ip_mask
self._config_ip = config_ip
self._config_ip_mask = config_ip_mask
self._vlan_iface_id = vlan_iface_id
self._vlan_iface_name = vlan_iface_name
self._namespace_name = "nsp" + str(self._vlan_iface_id)
self._power_socket = power_socket
# Optional values
self._mode = Mode.unknown
self._model = None
self._usr_name = usr_name
self._usr_password = usr_password
self._mac = "00:00:00:00:00:00"
self._wlan_mode = WlanMode.unknown
self._ssid = ""
self._firmware = Firmware.get_default_firmware()
def _verified_download(self, firmware: Firmware, hash_firmware: str, max_attempts: int) -> bool:
"""
Downloads the given Firmware and checks if the download was correct and if the hash is matching
:param firmware:
:param hash_firmware:
:param max_attempts: max number of attemps to download a firmware
:return: bool
"""
valid_download = False
count = 0
while (not valid_download) & (count < max_attempts):
valid_download = self._download_file(firmware.url, firmware.file, firmware.release_model)
if valid_download:
valid_download = firmware.check_hash(hash_firmware)
count += 1
if count >= max_attempts:
Logger().debug("[-] The Firmware(" + firmware.name + ") couldn't be downloaded", 3)
return False
else:
Logger().debug("[+] The Firmware(" + firmware.name + ") was successfully downloaded", 3)
return True
def test_setter(self):
firmware_name = "gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin"
url = "https://firmware.darmstadt.freifunk.net"
firmware = Firmware("", "", "", "", "", "")
assert isinstance(firmware, Firmware)
firmware.name = firmware_name
firmware.version = "0.7.3"
firmware.freifunk_verein = "ffda"
firmware.release_model = "stable"
firmware.file = "/folder/folder/file"
firmware.url = url
self.assertEqual(firmware_name, firmware.name)
self.assertEqual("0.7.3", firmware.version)
self.assertEqual("ffda", firmware.freifunk_verein)
self.assertEqual("stable", firmware.release_model)
self.assertEqual("/folder/folder/file", firmware.file)
self.assertEqual(url, firmware.url)
def _verified_download(self, firmware: Firmware, hash_firmware: str, max_attempts: int) -> bool:
"""
Downloads the given Firmware and checks if the download was correct and if the hash is matching.
:param firmware: Firmware-Obj
:param hash_firmware: Expected hash
:param max_attempts: Maximal number of attempts to download a Firmware
:return: 'True' if the Firmware could be downloaded and the hash is correct
"""
valid_download = False
count = 0
while (not valid_download) & (count < max_attempts):
valid_download = self._download_file(firmware.url, firmware.file, firmware.release_model)
if valid_download:
valid_download = firmware.check_hash(hash_firmware)
count += 1
if count >= max_attempts:
logging.warning("%s[-] The Firmware(" + firmware.name + ") couldn't be downloaded",
LoggerSetup.get_log_deep(3))
return False
else:
logging.info("%s[+] The Firmware(" + firmware.name + ") was successfully downloaded",
LoggerSetup.get_log_deep(3))
return True
