def __init__(self):
QtGui.QDialog.__init__(self)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.usb = USB()
self.usb_disk = ""
self.imager_iso_link = ""
self.iso_size = ""
self.process = QtCore.QProcess(self)
def __init__(self):
QtGui.QDialog.__init__(self)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.usb = USB()
self.usb_disk = ""
self.imager_iso_link = ""
self.iso_size = ""
self.process = QtCore.QProcess(self)
def main():
# uart = UART(0, 115200)
# hid = RN42(uart)
usb_hid = pyb.USB_HID()
hid = USB(usb_hid)
k = Keyboard()
# last_scan_codes hold the last scan codes to detect key press and key release
last_scan_codes = bytearray(b'\x00\x00\x00\x00\x00\x00')
last_modifier = 0
while 1:
scan_codes, modifier = k.read_matrix()
# Send scan codes if the scan codes is different from the last data.
if last_scan_codes != scan_codes or last_modifier != modifier:
hid.send_keyboard_report(scan_codes, modifier)
last_scan_codes = scan_codes
last_modifier = modifier
# print(scan_codes, modifier)
pyb.delay(1)
def start_algorithm(self, config, pyboard_port, recreate_usb=True):
"""
Connect with board using usb, send config and START command
@param config: board readable communicate with required parameters
@param pyboard_port: `board communciation USB port
@param recreate_usb: if False usb is not initialized (when unpausing)
"""
operation = "START"
print(recreate_usb)
if recreate_usb:
pyboard_port = pyboard_port
if len(pyboard_port) != 0:
self.usb = USB(pyboard_port)
else:
self.usb = USB()
pyboard_port = "/dev/ttyACM1 (default Linux PyBoard port)"
self.usb.attach("type", 2)
self.usb.attach("config", config)
self.usb.send()
self.usb.attach("type", 4)
self.usb.attach("operation", operation)
self.usb.send()
self.is_running = True
return pyboard_port
def __init__(self):
self.usb = USB()
class UnInstall():
"""
Main class related to uninstalling distro.
"""
def __init__(self):
self.usb = USB()
def uninstall_distro(self):
"""
Uninstall selected distro from selected USB disk.
:return:
"""
print os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "multibootusb.cfg")
if os.path.exists(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "multibootusb.cfg")):
with open(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "multibootusb.cfg"), "r") as multibootusb_cfg:
distro = multibootusb_cfg.read().replace('\n', '')
print "Uninstall distro type is " + distro
else:
distro = ""
if os.path.exists(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "iso_file_list.cfg")):
with open(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "iso_file_list.cfg"), "r") as f:
iso_file_list = f.readlines()
#print iso_file_list
for path, subdirs, files in os.walk(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro)):
for name in files:
if name.endswith('ldlinux.sys'):
os.chmod(os.path.join(path, name), 0777)
os.unlink(os.path.join(path, name))
if distro == "opensuse":
if os.path.exists(os.path.join(config.usb_mount, config.uninstall_distro + ".iso")):
os.remove(os.path.join(config.usb_mount, config.uninstall_distro + ".iso"))
elif distro == "windows":
self.delete_frm_file_list(iso_file_list)
if distro == "ipfire":
files = os.listdir(config.usb_mount)
for f in files:
if f.endswith('.tlz'):
os.remove(os.path.join(config.usb_mount, f))
if os.path.exists(os.path.join(config.usb_mount, "distro.img")):
os.remove(os.path.join(config.usb_mount, "distro.img"))
elif distro == "trinity-rescue":
shutil.rmtree(os.path.join(config.usb_mount, "trk3"))
elif distro == "alpine":
self.delete_frm_file_list(iso_file_list)
elif distro == "generic":
self.delete_frm_file_list(iso_file_list)
if os.path.exists(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro)):
self.delete_frm_file_list(iso_file_list)
shutil.rmtree(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro))
def delete_frm_file_list(self, iso_file_list):
"""
Generic way to remove files.
:param iso_file_list: Path to file as list.
:return:
"""
for f in iso_file_list:
if platform.system() == "Windows":
f = f.replace('\n', '').strip("/").replace("/", "\\")
else:
f = f.replace('\n', '').strip("/")
print "Removing " + (os.path.join(config.usb_mount, f))
if os.path.isfile(os.path.join(config.usb_mount, f)):
os.remove(os.path.join(config.usb_mount, f))
elif os.path.isdir(os.path.join(config.usb_mount, f)):
shutil.rmtree(os.path.join(config.usb_mount, f))
if os.path.exists(os.path.join(config.usb_mount, "ldlinux.sys")):
os.chmod(os.path.join(config.usb_mount, "ldlinux.sys"), 0777)
os.unlink(os.path.join(config.usb_mount, "ldlinux.sys"))
if os.path.exists(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "generic.cfg")):
with open(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "generic.cfg"), "r") as generic_cfg:
if platform.system() == "Windows":
generic = generic_cfg.read().replace('\n', '').replace("/", "\\")
else:
generic = generic_cfg.read().replace('\n', '')
if os.path.exists(os.path.join(config.usb_mount, generic.strip("/"))):
os.remove(os.path.join(config.usb_mount, generic.strip("/")))
def update_sys_cfg_file(self):
"""
Main function to remove uninstall distro specific operations.
:return:
"""
sys_cfg_file = os.path.join(config.usb_mount, "multibootusb", "syslinux.cfg")
if not os.path.exists(sys_cfg_file):
print "syslinux.cfg file not found for updating changes."
else:
print "Updating syslinux.cfg file..."
string = open(sys_cfg_file).read()
string = re.sub(r'#start ' + config.uninstall_distro + '.*?' + '#end ' + config.uninstall_distro + '\s*', '', string, flags=re.DOTALL)
config_file = open(sys_cfg_file, "w")
config_file.write(string)
config_file.close()
def uninstall_progress(self):
"""
Calculate uninstall progress percentage.
:return:
"""
if os.path.exists(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "multibootusb.cfg")):
with open(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro, "multibootusb.cfg"), "r") as multibootusb_cfg:
distro = multibootusb_cfg.read().replace('\n', '')
else:
distro = ""
print "Installed distro type is " + distro
if distro == "opensuse":
if os.path.exists(os.path.join(config.usb_mount, config.uninstall_distro) + ".iso"):
folder_size_to_remove = os.path.getsize(os.path.join(config.usb_mount, config.uninstall_distro) + ".iso")
else:
folder_size_to_remove = 0
folder_size_to_remove += self.usb.disk_usage(str(config.usb_mount) + "/multibootusb/" + config.uninstall_distro).used
elif distro == "windows" or distro == "Windows":
folder_size_to_remove = self.usb.disk_usage(str(config.usb_mount) + "/SOURCES").used
elif distro == "ipfire":
folder_size_to_remove = self.usb.disk_usage(str(config.usb_mount) + "/multibootusb/" + config.uninstall_distro).used
files = os.listdir(os.path.join(str(config.usb_mount)))
for f in files:
if f.endswith('.tlz'):
folder_size_to_remove += os.path.getsize(os.path.join(config.usb_mount, f))
elif distro == "trinity-rescue":
folder_size_to_remove = self.usb.disk_usage(os.path.join(config.usb_mount, "trk3")).used
folder_size_to_remove += self.usb.disk_usage(config.usb_mount + "/multibootusb/" + config.uninstall_distro).used
else:
folder_size_to_remove = self.usb.disk_usage(os.path.join(config.usb_mount, "multibootusb", config.uninstall_distro)).used
thrd = threading.Thread(target=self.uninstall_distro, name="uninstall_progress")
initial_usb_size = self.usb.disk_usage(config.usb_mount).used
thrd.start()
while thrd.is_alive():
config.status_text = "Uninstalling " + config.uninstall_distro
current_size = self.usb.disk_usage(config.usb_mount).used
diff_size = int(initial_usb_size - current_size)
config.percentage = round(float(diff_size)/folder_size_to_remove*100)
if not thrd.is_alive():
config.persistence = 0
config.status_text = ""
self.update_sys_cfg_file()
print ("Distro directory has been removed successfully...")
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
class Syslinux():
"""
Main Syslinux class.
"""
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
def install_default(self):
"""
Install default syslinux/extlinux (version 4) on selected USB disk.
"""
if config.iso_link:
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
mbr_bin = gen_fun.resource_path(os.path.join("tools", "mbr.bin"))
config.status_text = "Installing default syslinux..."
if filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs" or filesystem == "ntfs":
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux",
"bin", "extlinux4")
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True)
path = os.path.join(
self.usb.get_usb(config.usb_disk).mount, "multibootusb")
quoted_exe = "\"" + syslinux_path.replace('"', '\\"') + "\""
quoted_path = "\"" + path.replace('"', '\\"') + "\""
quoted_mbusb = "\"" + gen_fun.mbusb_dir().replace('"',
'\\"') + "\""
if filesystem == "ntfs":
ext_fix = []
else:
ext_fix = [
"&&", "chattr", "-i", quoted_path + "/ldlinux.sys"
]
long_cmd = ["mkdir", "-p", quoted_path,
"&&", "chown", "--reference", quoted_mbusb, quoted_path,
"&&", quoted_exe, "--install", quoted_path] + ext_fix + \
["&&", "echo", "Default Extlinux install is success...",
"&&", "dd", "bs=440", "count=1", "conv=notrunc", "\"if=" + mbr_bin + "\"", "of=" + config.usb_disk[:-1],
"&&", "echo", "mbr install is success...",
"&&"] + self.set_boot_flag_cmd()
return admin.adminCmd(long_cmd) == 0
elif filesystem == "vfat" or filesystem == "FAT32":
if platform.system() == "Linux":
syslinux = gen_fun.resource_path(
os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin",
"syslinux4"))
if os.access(syslinux, os.X_OK) is False:
subprocess.call(['chmod', '+x', syslinux])
quoted_exe = "\"" + syslinux.replace('"', '\\"') + "\""
long_cmd = [
quoted_exe, "-i", "-d", "multibootusb", config.usb_disk,
"&&", "echo", "Default syslinux install is success...",
"&&", "dd", "bs=440", "count=1", "conv=notrunc",
"\"if=" + mbr_bin + "\"", "of=" + config.usb_disk[:-1],
"&&", "echo", "mbr install is success...", "&&"
] + self.set_boot_flag_cmd()
return admin.adminCmd(long_cmd) == 0
elif platform.system() == "Windows":
syslinux = gen_fun.resource_path(
os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin",
"syslinux4.exe"))
if subprocess.call(syslinux + ' -maf -d multibootusb ' +
config.usb_disk,
shell=True) == 0:
print "\nDefault syslinux install is success...\n"
return True
else:
print "\nFailed to install default syslinux...\n"
return False
def install_distro(self):
"""
Install syslinux/extlinux on distro isolinux directory.
"""
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
config.status_text = "Installing distro specific syslinux..."
if self.iso.isolinux_bin_exist() is not True:
print "Distro does not use isolinux/syslinux for booting ISO."
else:
self.iso.iso_extract_file(
os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"),
"isolinux.bin")
self.iso.iso_extract_file(
os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"),
"ISOLINUX.BIN")
syslinux_version = self.iso.isolinux_version(
self.iso.isolinux_bin_path(
os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir")))
if config.distro == "generic" or config.distro == "alpine":
install_dir = self.usb.get_usb(config.usb_disk).mount
distro_syslinux_install_dir = os.path.join(
install_dir,
self.iso.isolinux_bin_dir().strip("/")).replace(
self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(
install_dir,
self.iso.isolinux_bin_dir().strip("/"),
config.distro + '.bs')
else:
install_dir = os.path.join(
self.usb.get_usb(config.usb_disk).mount, "multibootusb",
self.iso.iso_basename())
distro_syslinux_install_dir = os.path.join(
install_dir,
self.iso.isolinux_bin_dir().strip("/")).replace(
self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(
install_dir,
self.iso.isolinux_bin_dir().strip("/"),
config.distro + '.bs')
if filesystem == "vfat" or filesystem == "FAT32":
if syslinux_version == str(3):
if config.distro == "generic" and self.iso.isolinux_bin_dir(
) == "/":
option = ""
else:
option = " -d "
else:
if config.distro == "generic" and self.iso.isolinux_bin_dir(
) == "/":
option = " -i "
else:
option = " -i -d "
print "distro_syslinux_install_dir is " + distro_syslinux_install_dir
print "distro_sys_install_bs is " + distro_sys_install_bs
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(),
"syslinux", "bin",
"syslinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path,
shell=True) == 0
quoted_exe = "\"" + syslinux_path.replace('"',
'\\"') + "\""
quoted_install_dir = distro_syslinux_install_dir.replace(
'"', '\\"')
quoted_bs = "of=\"" + distro_sys_install_bs.replace(
'"', '\\"') + "\""
long_cmd = [
quoted_exe, option, quoted_install_dir,
config.usb_disk, "&&", "dd", "count=1",
"if=" + config.usb_disk, quoted_bs
]
return admin.adminCmd(long_cmd) == 0
elif platform.system() == "Windows":
syslinux_path = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin")) + \
"\syslinux" + syslinux_version + ".exe"
distro_syslinux_install_dir = "/" + distro_syslinux_install_dir.replace(
"\\", "/")
distro_sys_install_bs = distro_sys_install_bs.replace(
"/", "\\")
print "\nExecuting ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' ' + \
distro_sys_install_bs + "\n"
if subprocess.call(syslinux_path + option +
distro_syslinux_install_dir + ' ' +
config.usb_disk + ' ' +
distro_sys_install_bs,
shell=True) == 0:
print "\nSyslinux install was successful on distro directory...\n"
else:
print "\nFailed to install syslinux on distro directory...\n"
elif filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs" or filesystem == "ntfs":
distro_syslinux_install_dir = os.path.join(
install_dir,
self.iso.isolinux_bin_dir().strip("/"))
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(),
"syslinux", "bin",
"extlinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path,
shell=True) == 0
quoted_exe = "\"" + syslinux_path.replace('"',
'\\"') + "\""
quoted_install_dir = distro_syslinux_install_dir.replace(
'"', '\\"')
quoted_bs = "of=\"" + distro_sys_install_bs.replace(
'"', '\\"') + "\""
long_cmd = [
quoted_exe, "--install", quoted_install_dir, "&&",
"dd", "count=1", "if=" + config.usb_disk, quoted_bs
]
return admin.adminCmd(long_cmd) == 0
def set_boot_flag_cmd(self):
disk = config.usb_disk[:-1]
return [
"echo", "Checking boot flag on " + disk, "&&", "if", "parted",
"-m", "-s", disk, "print", "|", "grep", "-q", "boot", ";", "then",
"echo", "Disk already has boot flag.", ";", "else", "echo",
"Disk has no boot flag.", ";", "if", "parted", disk, "set", "1",
"boot", "on", ";", "then", "echo",
"Boot flag set to bootable on " + disk, ";", "else", "echo",
"Unable to set boot flag on " + disk, ";", "fi", ";", "fi"
]
class Controller:
"""
Handles Board controlling and communication
@author: Krzysztof Greczka
"""
def __init__(self):
self.is_running = False
def stop_algorithm(self):
"""
Send STOP command
"""
self.is_running = False
self.usb.attach("type", 4)
operation = "STOP"
self.usb.attach("operation", operation)
self.usb.send()
def start_algorithm(self, config, pyboard_port, recreate_usb=True):
"""
Connect with board using usb, send config and START command
@param config: board readable communicate with required parameters
@param pyboard_port: `board communciation USB port
@param recreate_usb: if False usb is not initialized (when unpausing)
"""
operation = "START"
print(recreate_usb)
if recreate_usb:
pyboard_port = pyboard_port
if len(pyboard_port) != 0:
self.usb = USB(pyboard_port)
else:
self.usb = USB()
pyboard_port = "/dev/ttyACM1 (default Linux PyBoard port)"
self.usb.attach("type", 2)
self.usb.attach("config", config)
self.usb.send()
self.usb.attach("type", 4)
self.usb.attach("operation", operation)
self.usb.send()
self.is_running = True
return pyboard_port
def pause_algorithm(self):
"""
Send PAUSE command
"""
self.usb.attach("type", 4)
operation = "PAUSE"
self.usb.attach("operation", operation)
self.usb.send()
def board_reply(self):
"""
Function handling board replies and requests
"""
reply = self.usb.read()
type = reply['type']
if type != 0:
try:
if type == 9:
operator = reply['operator']
fitness = get_fitness(operator)
self.usb.attach("type", 9)
self.usb.attach('fitness', fitness)
self.usb.send()
to_ret = {"type": 9,
"operator": operator,
"fitness": fitness}
elif type == 2 or type == 4:
to_ret = reply
except KeyError as error:
raise IOError("Pyboard reply without expected field" + repr(error))
finally:
return to_ret
class Imager(QtGui.QDialog, Ui_Dialog):
"""
Raw write to USB disk using dd.
"""
def __init__(self):
QtGui.QDialog.__init__(self)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.usb = USB()
self.usb_disk = ""
self.imager_iso_link = ""
self.iso_size = ""
self.process = QtCore.QProcess(self)
def on_Imager_Browse_iso_Click(self):
"""
Browse and choose an ISO.
:return:
"""
self.ui.lineEdit_3.clear()
self.imager_iso_link = str(QtGui.QFileDialog.getOpenFileName(self, 'Select an iso...', "", "ISO Files (*.iso)"))
if self.imager_iso_link:
if platform.system() == "Windows":
if "/" in self.imager_iso_link:
self.imager_iso_link = self.imager_iso_link.strip().replace("/", "\\")
self.ui.lineEdit_3.insert(str(self.imager_iso_link))
self.iso_imager = iso.ISO(self.imager_iso_link)
config.imager_iso_link = self.imager_iso_link
self.add_iso_gui_label_text()
else:
print ("File not selected...")
def add_iso_gui_label_text(self):
"""
Simple function to add text label to GUI widgets.
:return:
"""
print "Testing ISO..."
if self.iso_imager.is_bootable():
self.ui.imager_bootable.setText("Bootable ISO :: Yes")
print "ISO is bootable."
else:
self.ui.imager_bootable.setText("Bootable ISO :: No")
print "ISO is not bootable."
if os.path.exists(self.imager_iso_link):
print "Path " + self.imager_iso_link + " is exist..."
self.iso_size = str(os.path.getsize(self.imager_iso_link) / 1024 / 1024)
self.ui.imager_iso_size.setText("ISO Size :: " + self.iso_size + " MB")
print "ISO Size is " + self.iso_size + " MB"
def imager_list_usb(self, partition=1):
"""
Function to detect whole USB disk. It uses lsblk package on Linux.
:param partition: What to return. By default partition is set.
:return: USB disk/partition as list
"""
disk = []
if platform.system() == "Linux":
output = subprocess.check_output("lsblk -i", shell=True)
if not partition == 1:
for line in output.splitlines():
line = line.split()
if str(line[2].strip()) == "1" and line[5].strip() == "disk":
#print line[0].strip()
disk.append(str("/dev/" + line[0].strip()))
elif partition == 1:
for line in output.splitlines():
line = line.split()
if str(line[2].strip()) == "1" and line[5].strip() == "part":
disk.append(str("/dev/" + line[0].strip()[2:]))
else:
if partition == 1 or not partition == 1:
oFS = win32com.client.Dispatch("Scripting.FileSystemObject")
oDrives = oFS.Drives
for drive in oDrives:
if drive.DriveType == 1 and drive.IsReady:
disk.append(drive)
return disk
def imager_usb_detail(self, usb_disk, partition=1):
"""
Function to detect details of USB disk using lsblk
:param usb_disk: path to usb disk
:param partition: by default partition is set (but yet to code for it)
:return: details of size, type and model as tuples
"""
_ntuple_diskusage = collections.namedtuple('usage', 'total_size usb_type model')
if platform.system() == "Linux":
output = subprocess.check_output("lsblk -ib " + usb_disk, shell=True)
for line in output.splitlines():
line = line.split()
if not partition == 1:
if str(line[2].strip()) == "1" and line[5].strip() == "disk":
total_size = line[3]
if not total_size:
total_size = "Unknown"
usb_type = "Removable"
model = subprocess.check_output("lsblk -in -f -o MODEL " + usb_disk, shell=True)
if not model:
model = "Unknown"
else:
try:
selected_usb_part = str(usb_disk)
oFS = win32com.client.Dispatch("Scripting.FileSystemObject")
d = oFS.GetDrive(oFS.GetDriveName(oFS.GetAbsolutePathName(selected_usb_part)))
selected_usb_device = d.DriveLetter
label = (d.VolumeName).strip()
if not label.strip():
label = "No label."
total_size = d.TotalSize
usb_type = "Removable"
model = label
except:
print "Error detecting USB details."
return _ntuple_diskusage(total_size, usb_type, model)
def get_usb_size(self, usb_disk):
"""
Function to detect USB disk space. Useful but not used in multibootusb as of now.
:param usb_disk: USB disk like "/dev/sdb"
:return: Size of the disk as integer
"""
if platform.system() == "Linux":
cat_output = subprocess.check_output("cat /proc/partitions | grep " + usb_disk[5:], shell=True)
usb_size = int(cat_output.split()[2]) * 1024
print usb_size
return usb_size
else:
usb_size = self.usb.disk_usage(self.usb.get_usb(usb_disk).mount).total
return usb_size
class Imager(QtGui.QDialog, Ui_Dialog):
"""
Raw write to USB disk using dd.
"""
def __init__(self):
QtGui.QDialog.__init__(self)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.usb = USB()
self.usb_disk = ""
self.imager_iso_link = ""
self.iso_size = ""
self.process = QtCore.QProcess(self)
def on_Imager_Browse_iso_Click(self):
"""
Browse and choose an ISO.
:return:
"""
self.ui.lineEdit_3.clear()
self.imager_iso_link = str(
QtGui.QFileDialog.getOpenFileName(self, 'Select an iso...', "",
"ISO Files (*.iso)"))
if self.imager_iso_link:
if platform.system() == "Windows":
if "/" in self.imager_iso_link:
self.imager_iso_link = self.imager_iso_link.strip(
).replace("/", "\\")
self.ui.lineEdit_3.insert(str(self.imager_iso_link))
self.iso_imager = iso.ISO(self.imager_iso_link)
config.imager_iso_link = self.imager_iso_link
self.add_iso_gui_label_text()
else:
print("File not selected...")
def add_iso_gui_label_text(self):
"""
Simple function to add text label to GUI widgets.
:return:
"""
print "Testing ISO..."
if self.iso_imager.is_bootable():
self.ui.imager_bootable.setText("Bootable ISO :: Yes")
print "ISO is bootable."
else:
self.ui.imager_bootable.setText("Bootable ISO :: No")
print "ISO is not bootable."
if os.path.exists(self.imager_iso_link):
print "Path " + self.imager_iso_link + " is exist..."
self.iso_size = str(
os.path.getsize(self.imager_iso_link) / 1024 / 1024)
self.ui.imager_iso_size.setText("ISO Size :: " + self.iso_size +
" MB")
print "ISO Size is " + self.iso_size + " MB"
def imager_list_usb(self, partition=1):
"""
Function to detect whole USB disk. It uses lsblk package on Linux.
:param partition: What to return. By default partition is set.
:return: USB disk/partition as list
"""
disk = []
if platform.system() == "Linux":
output = subprocess.check_output("lsblk -i", shell=True)
if not partition == 1:
for line in output.splitlines():
line = line.split()
if str(line[2].strip()) == "1" and line[5].strip(
) == "disk":
#print line[0].strip()
disk.append(str("/dev/" + line[0].strip()))
elif partition == 1:
for line in output.splitlines():
line = line.split()
if str(line[2].strip()) == "1" and line[5].strip(
) == "part":
disk.append(str("/dev/" + line[0].strip()[2:]))
else:
if partition == 1 or not partition == 1:
oFS = win32com.client.Dispatch("Scripting.FileSystemObject")
oDrives = oFS.Drives
for drive in oDrives:
if drive.DriveType == 1 and drive.IsReady:
disk.append(drive)
return disk
def imager_usb_detail(self, usb_disk, partition=1):
"""
Function to detect details of USB disk using lsblk
:param usb_disk: path to usb disk
:param partition: by default partition is set (but yet to code for it)
:return: details of size, type and model as tuples
"""
_ntuple_diskusage = collections.namedtuple(
'usage', 'total_size usb_type model')
if platform.system() == "Linux":
output = subprocess.check_output("lsblk -ib " + usb_disk,
shell=True)
for line in output.splitlines():
line = line.split()
if not partition == 1:
if str(line[2].strip()) == "1" and line[5].strip(
) == "disk":
total_size = line[3]
if not total_size:
total_size = "Unknown"
usb_type = "Removable"
model = subprocess.check_output(
"lsblk -in -f -o MODEL " + usb_disk, shell=True)
if not model:
model = "Unknown"
else:
try:
selected_usb_part = str(usb_disk)
oFS = win32com.client.Dispatch("Scripting.FileSystemObject")
d = oFS.GetDrive(
oFS.GetDriveName(
oFS.GetAbsolutePathName(selected_usb_part)))
selected_usb_device = d.DriveLetter
label = (d.VolumeName).strip()
if not label.strip():
label = "No label."
total_size = d.TotalSize
usb_type = "Removable"
model = label
except:
print "Error detecting USB details."
return _ntuple_diskusage(total_size, usb_type, model)
def get_usb_size(self, usb_disk):
"""
Function to detect USB disk space. Useful but not used in multibootusb as of now.
:param usb_disk: USB disk like "/dev/sdb"
:return: Size of the disk as integer
"""
if platform.system() == "Linux":
cat_output = subprocess.check_output(
"cat /proc/partitions | grep " + usb_disk[5:], shell=True)
usb_size = int(cat_output.split()[2]) * 1024
print usb_size
return usb_size
else:
usb_size = self.usb.disk_usage(
self.usb.get_usb(usb_disk).mount).total
return usb_size
class Syslinux():
"""
Main Syslinux class.
"""
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
def install_default(self):
"""
Install default syslinux/extlinux (version 4) on selected USB disk.
"""
if config.iso_link:
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
mbr_bin = gen_fun.resource_path(os.path.join("tools", "mbr.bin"))
config.status_text = "Installing default syslinux..."
if filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs" or filesystem == "ntfs":
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "extlinux4")
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True)
path = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb")
quoted_exe = "\"" + syslinux_path.replace('"', '\\"') + "\""
quoted_path = "\"" + path.replace('"', '\\"') + "\""
quoted_mbusb = "\"" + gen_fun.mbusb_dir().replace('"', '\\"') + "\""
if filesystem == "ntfs":
ext_fix = []
else:
ext_fix = ["&&", "chattr", "-i", quoted_path + "/ldlinux.sys"]
long_cmd = ["mkdir", "-p", quoted_path,
"&&", "chown", "--reference", quoted_mbusb, quoted_path,
"&&", quoted_exe, "--install", quoted_path] + ext_fix + \
["&&", "echo", "Default Extlinux install is success...",
"&&", "dd", "bs=440", "count=1", "conv=notrunc", "\"if=" + mbr_bin + "\"", "of=" + config.usb_disk[:-1],
"&&", "echo", "mbr install is success...",
"&&"] + self.set_boot_flag_cmd()
return admin.adminCmd(long_cmd) == 0
elif filesystem == "vfat" or filesystem == "FAT32":
if platform.system() == "Linux":
syslinux = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux4"))
if os.access(syslinux, os.X_OK) is False:
subprocess.call(['chmod', '+x', syslinux])
quoted_exe = "\"" + syslinux.replace('"', '\\"') + "\""
long_cmd = [quoted_exe, "-i", "-d", "multibootusb", config.usb_disk,
"&&", "echo", "Default syslinux install is success...",
"&&", "dd", "bs=440", "count=1", "conv=notrunc", "\"if=" + mbr_bin + "\"", "of=" + config.usb_disk[:-1],
"&&", "echo", "mbr install is success...",
"&&"] + self.set_boot_flag_cmd()
return admin.adminCmd(long_cmd) == 0
elif platform.system() == "Windows":
syslinux = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux4.exe"))
if subprocess.call(syslinux + ' -maf -d multibootusb ' + config.usb_disk, shell=True) == 0:
print "\nDefault syslinux install is success...\n"
return True
else:
print "\nFailed to install default syslinux...\n"
return False
def install_distro(self):
"""
Install syslinux/extlinux on distro isolinux directory.
"""
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
config.status_text = "Installing distro specific syslinux..."
if self.iso.isolinux_bin_exist() is not True:
print "Distro doesnot use isolinux/syslinux for booting ISO."
else:
self.iso.iso_extract_file(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"), "isolinux.bin")
self.iso.iso_extract_file(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"), "ISOLINUX.BIN")
syslinux_version = self.iso.isolinux_version(self.iso.isolinux_bin_path(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir")))
if config.distro == "generic" or config.distro == "alpine":
install_dir = self.usb.get_usb(config.usb_disk).mount
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/")).replace(self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"), config.distro + '.bs')
else:
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/")).replace(self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"), config.distro + '.bs')
if filesystem == "vfat" or filesystem == "FAT32":
if syslinux_version == str(3):
if config.distro == "generic" and self.iso.isolinux_bin_dir() == "/":
option = ""
else:
option = " -d "
else:
if config.distro == "generic" and self.iso.isolinux_bin_dir() == "/":
option = " -i "
else:
option = " -i -d "
print "distro_syslinux_install_dir is " + distro_syslinux_install_dir
print "distro_sys_install_bs is " + distro_sys_install_bs
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True) == 0
quoted_exe = "\"" + syslinux_path.replace('"', '\\"') + "\""
quoted_install_dir = distro_syslinux_install_dir.replace('"', '\\"')
quoted_bs = "of=\"" + distro_sys_install_bs.replace('"', '\\"') + "\""
long_cmd = [quoted_exe, option, quoted_install_dir, config.usb_disk,
"&&", "dd", "count=1", "if=" + config.usb_disk, quoted_bs]
return admin.adminCmd(long_cmd) == 0
elif platform.system() == "Windows":
syslinux_path = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin")) + \
"\syslinux" + syslinux_version + ".exe"
distro_syslinux_install_dir = "/" + distro_syslinux_install_dir.replace("\\", "/")
distro_sys_install_bs = distro_sys_install_bs.replace("/", "\\")
print "\nExecuting ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' ' + \
distro_sys_install_bs + "\n"
if subprocess.call(syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' '
+ distro_sys_install_bs, shell=True) == 0:
print "\nSyslinux install was successful on distro directory...\n"
else:
print "\nFailed to install syslinux on distro directory...\n"
elif filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs" or filesystem == "ntfs":
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"))
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "extlinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True) == 0
quoted_exe = "\"" + syslinux_path.replace('"', '\\"') + "\""
quoted_install_dir = distro_syslinux_install_dir.replace('"', '\\"')
quoted_bs = "of=\"" + distro_sys_install_bs.replace('"', '\\"') + "\""
long_cmd = [quoted_exe, "--install", quoted_install_dir,
"&&", "dd", "count=1", "if=" + config.usb_disk, quoted_bs]
return admin.adminCmd(long_cmd) == 0
def set_boot_flag_cmd(self):
disk = config.usb_disk[:-1]
return ["echo", "Checking boot flag on " + disk,
"&&", "if", "parted", "-m", "-s", disk, "print", "|", "grep", "-q", "boot", ";", "then",
"echo", "Disk already has boot flag.",
";", "else",
"echo", "Disk has no boot flag.", ";",
"if", "parted", disk, "set", "1", "boot", "on", ";", "then",
"echo", "Boot flag set to bootable on " + disk,
";", "else",
"echo", "Unable to set boot flag on " + disk,
";", "fi",
";", "fi"]
class UpdateCfgFile():
"""
Update distro and multibootusb congig file(s).
"""
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
def distro_cfg_files(self):
"""
Main function to modify/update distro specific strings on distro config files.
:return:
"""
#self.usb = USB()
self.iso = ISO(config.iso_link)
config.status_text = "Updating config files..."
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
for dirpath, dirnames, filenames in os.walk(install_dir):
for f in filenames:
if f.endswith(".cfg"):
cfg_file = os.path.join(dirpath, f)
try:
string = open(cfg_file).read()
except IOError:
print "Unable to read " + cfg_file
else:
if not config.distro == "generic":
replace_text = r'\1/multibootusb/' + self.iso.iso_basename() + '/'
string = re.sub(r'([ \t =,])/', replace_text, string)
if config.distro == "ubuntu":
string = re.sub(r'boot=casper',
'boot=casper cdrom-detect/try-usb=true floppy.allowed_drive_mask=0 ignore_uuid ignore_bootid root=UUID=' + self.usb.get_usb(config.usb_disk).uuid + ' live-media-path=/multibootusb/' +
self.iso.iso_basename() + '/casper', string)
if not config.persistence == 0:
string = re.sub(r'boot=casper', 'boot=casper persistent persistent-path=/multibootusb/' +
self.iso.iso_basename() + "/", string)
elif config.distro == "debian":
string = re.sub(r'boot=live', 'boot=live ignore_bootid live-media-path=/multibootusb/' +
self.iso.iso_basename() + '/live', string)
if not config.persistence == 0:
string = re.sub(r'boot=live', 'boot=live persistent persistent-path=/multibootusb/' +
self.iso.iso_basename() + "/", string)
elif config.distro == "ubuntu-server":
string = re.sub(r'file', 'cdrom-detect/try-usb=true floppy.allowed_drive_mask=0 ignore_uuid ignore_bootid root=UUID=' + self.usb.get_usb(config.usb_disk).uuid + ' file', string)
elif config.distro == "fedora":
string = re.sub(r'root=\S*', 'root=UUID=' + self.usb.get_usb(config.usb_disk).uuid, string)
if re.search(r'liveimg', string, re.I):
string = re.sub(r'liveimg', 'liveimg live_dir=/multibootusb/' +
self.iso.iso_basename() + '/LiveOS', string)
elif re.search(r'rd.live.image', string, re.I):
string = re.sub(r'rd.live.image', 'rd.live.image rd.live.dir=/multibootusb/' +
self.iso.iso_basename() + '/LiveOS', string)
if not config.persistence == 0:
if re.search(r'liveimg', string, re.I):
string = re.sub(r'liveimg', 'liveimg overlay=UUID=' + self.usb.get_usb(config.usb_disk).uuid, string)
elif re.search(r'rd.live.image', string, re.I):
string = re.sub(r'rd.live.image', 'rd.live.image rd.live.overlay=UUID=' + self.usb.get_usb(config.usb_disk).uuid, string)
string = re.sub(r' ro ', ' rw ', string)
elif config.distro == "parted-magic":
if re.search(r'append', string, re.I):
string = re.sub(r'append', 'append directory=/multibootusb/' + self.iso.iso_basename(), string, flags=re.I)
string = re.sub(r'initrd=', 'directory=/multibootusb/' + self.iso.iso_basename() + '/ initrd=',
string)
elif config.distro == "ubcd":
string = re.sub(r'iso_filename=\S*', 'directory=/multibootusb/' + self.iso.iso_basename(),
string, flags=re.I)
elif config.distro == "ipcop":
string = re.sub(r'ipcopboot=cdrom\S*', 'ipcopboot=usb', string)
elif config.distro == "puppy":
string = re.sub(r'pmedia=cd\S*',
'pmedia=usbflash psubok=TRUE psubdir=/multibootusb/' + self.iso.iso_basename() + '/',
string)
elif config.distro == "slax":
string = re.sub(r'initrd=', r'from=/multibootusb/' + self.iso.iso_basename() + '/slax fromusb initrd=', string)
elif config.distro == "knoppix":
string = re.sub(r'(append)',
r'\1 knoppix_dir=/multibootusb/' + self.iso.iso_basename() + '/KNOPPIX',
string)
elif config.distro == "gentoo":
string = re.sub(r'append ', 'append real_root=' + config.usb_disk + ' slowusb subdir=/multibootusb/' +
self.iso.iso_basename() + '/ ', string, flags=re.I)
elif config.distro == "systemrescuecd":
rows = []
subdir = '/multibootusb/' + self.iso.iso_basename() + '/'
for line in string.splitlines(True):
addline = True
if re.match(r'append.*--.*', line, flags=re.I):
line = re.sub(r'(append)(.*)--(.*)', r'\1\2subdir=' + subdir + r' --\3 subdir=' + subdir,
line, flags=re.I)
elif re.match(r'append', line, flags=re.I):
line = re.sub(r'(append)', r'\1 subdir=' + subdir, line, flags=re.I)
elif re.match(r'label rescue(32|64)_1', line, flags=re.I):
rows.append(line)
rows.append('append subdir=%s\n' % (subdir,))
addline = False
if addline:
rows.append(line)
string = ''.join(rows)
elif config.distro == "arch" or config.distro == "chakra":
string = re.sub(r'isolabel=\S*', 'isodevice=/dev/disk/by-uuid/' + self.usb.get_usb(config.usb_disk).uuid, string,
flags=re.I)
string = re.sub(r'isobasedir=',
'isobasedir=/multibootusb/' + self.iso.iso_basename() + '/', string,
flags=re.I)
elif config.distro == "suse" or config.distro == "opensuse":
if re.search(r'opensuse_12', string, re.I):
string = re.sub(r'append', 'append loader=syslinux isofrom_system=/dev/disk/by-uuid/' + self.usb.get_usb(config.usb_disk).uuid + ":/" + self.iso.iso_name(), string, flags=re.I)
else:
string = re.sub(r'append', 'append loader=syslinux isofrom_device=/dev/disk/by-uuid/' + self.usb.get_usb(config.usb_disk).uuid + ' isofrom_system=/multibootusb/' + self.iso.iso_basename() + '/'+ self.iso.iso_name(), string, flags=re.I)
elif config.distro == "pclinuxos":
string = re.sub(r'livecd=',
'fromusb livecd=' + '/multibootusb/' + self.iso.iso_basename() + '/',
string)
string = re.sub(r'prompt', '#prompt', string)
string = re.sub(r'ui gfxboot.com', '#ui gfxboot.com', string)
string = re.sub(r'timeout', '#timeout', string)
elif config.distro == "porteus" or config.distro == "wifislax":
string = re.sub(r'initrd=',
'from=' + '/multibootusb/' + self.iso.iso_basename() + ' initrd=', string)
elif config.distro == "hbcd":
string = re.sub(r'/HBCD', '/multibootusb/' + self.iso.iso_basename() + '/HBCD', string)
elif config.distro == "zenwalk":
string = re.sub(r'initrd=', 'from=/multibootusb/' + self.iso.iso_basename() + '/' + self.iso.iso_name() + ' initrd=', string)
elif config.distro == "mageialive":
string = re.sub(r'LABEL=\S*', 'LABEL=' + self.usb.get_usb(config.usb_disk).label, string)
elif config.distro == "antix":
string = re.sub(r'APPEND', 'image_dir=/multibootusb/' + self.iso.iso_basename(), string)
elif config.distro == "solydx":
string = re.sub(r'live-media-path=', 'live-media-path=/multibootusb/' + self.iso.iso_basename(), string)
elif config.distro == "salix-live":
string = re.sub(r'iso_path', '/multibootusb/' + self.iso.iso_basename() + '/' + self.iso.iso_name(), string)
config_file = open(cfg_file, "wb")
config_file.write(string)
config_file.close()
# Patch for Ubuntu 14.10 and above which uses syslinux version 6
if config.distro == "ubuntu" and config.sys_version == "6":
print "Applying Ubuntu patch..."
for module in os.listdir(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux")):
if module.endswith(".c32"):
if os.path.exists(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux", module)):
try:
os.remove(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux", module))
print "Copying " + module
shutil.copy(gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "modules", "ubuntu_patch", module)),
os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux", module))
except:
print "Could not copy " + module
self.main_cfg_file()
def main_cfg_file(self):
"""
Update main multibootusb suslinux.cfg file after distro is installed.
:return:
"""
#self.usb = USB()
self.iso = ISO(config.iso_link)
sys_cfg_file = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", "syslinux.cfg")
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
print "Updating main syslinux config file..."
if os.path.exists(sys_cfg_file):
if config.distro == "hbcd":
if os.path.exists(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", "menu.lst")):
config_file = open(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", "menu.lst"), "wb")
string = re.sub(r'/HBCD', '/multibootusb/' + self.iso.iso_basename() + '/HBCD', config_file)
config_file.write(string)
config_file.close()
if config.distro == "Windows":
if os.path.exists(sys_cfg_file):
config_file = open(sys_cfg_file, "a")
config_file.write("#start " + self.iso.iso_basename() + "\n")
config_file.write("LABEL " + self.iso.iso_basename() + "\n")
config_file.write("MENU LABEL " + self.iso.iso_basename() + "\n")
config_file.write("KERNEL chain.c32 hd0 1 ntldr=/bootmgr" + "\n")
config_file.write("#end " + self.iso.iso_basename() + "\n")
config_file.close()
else:
admin.adminCmd(["mount", "-o", "remount,rw", config.usb_disk])
config_file = open(sys_cfg_file, "a")
config_file.write("#start " + self.iso.iso_basename() + "\n")
config_file.write("LABEL " + self.iso.iso_basename() + "\n")
config_file.write("MENU LABEL " + self.iso.iso_basename() + "\n")
if config.distro == "salix-live":
config_file.write(
"LINUX " + '/multibootusb/' + self.iso.iso_basename() + '/boot/grub2-linux.img' + "\n")
elif config.distro == "pclinuxos":
config_file.write("kernel " + '/multibootusb/' + self.iso.iso_basename() + '/isolinux/vmlinuz' + "\n")
config_file.write("append livecd=livecd root=/dev/rd/3 acpi=on vga=788 keyb=us vmalloc=256M nokmsboot "
"fromusb root=UUID=" + self.usb.get_usb(config.usb_disk).uuid + " bootfromiso=/multibootusb/" +
self.iso.iso_basename() +"/" + self.iso.iso_name() + " initrd=/multibootusb/"
+ self.iso.iso_basename() + '/isolinux/initrd.gz' + "\n")
elif config.distro == "mentest":
config_file.write("kernel " + '/multibootusb/' + self.iso.iso_basename() + '/BOOT/MEMTEST.IMG\n')
else:
if config.distro == "ubuntu" and config.sys_version == "6":
config_file.write("CONFIG " + "/multibootusb/" + self.iso.iso_basename() +
"/isolinux/isolinux.cfg" + "\n")
config_file.write("APPEND " + "/multibootusb/" + self.iso.iso_basename() +
"/isolinux" + "\n")
else:
if config.distro == "generic":
distro_syslinux_install_dir = self.iso.isolinux_bin_dir()
if not self.iso.isolinux_bin_dir() == "/":
distro_sys_install_bs = os.path.join(self.usb.get_usb(config.usb_disk).mount, self.iso.isolinux_bin_dir()) + '/' + config.distro + '.bs'
else:
distro_sys_install_bs = '/' + config.distro + '.bs'
else:
distro_syslinux_install_dir = install_dir
distro_syslinux_install_dir = distro_syslinux_install_dir.replace(self.usb.get_usb(config.usb_disk).mount, '')
distro_sys_install_bs = distro_syslinux_install_dir + self.iso.isolinux_bin_dir() + '/' + config.distro + '.bs'
distro_sys_install_bs = "/" + distro_sys_install_bs.replace("\\", "/") # Windows path issue.
config_file.write("BOOT " + distro_sys_install_bs.replace("//", "/") + "\n")
config_file.write("#end " + self.iso.iso_basename() + "\n")
config_file.close()
for dirpath, dirnames, filenames in os.walk(install_dir):
for f in filenames:
if f.endswith("isolinux.cfg"):
shutil.copy2(os.path.join(dirpath, f), os.path.join(dirpath, "syslinux.cfg"))
import config
import threading
import time
from g4_logger import G4
from usb import USB
if config.console_only == 'True':
while True:
time.sleep(1800)
config.logging.warning("No app running, console only")
else:
config.logging.info(' ----> Main App Running! <---- ')
# Create Lock for running file in permanent USB memory
running_file_lock = threading.Lock()
# launch USB Drive scanning and file backup process
usb_storage = USB(running_file_lock)
scan_and_backup = threading.Thread(target=usb_storage.check_for_devices)
scan_and_backup.daemon = True
scan_and_backup.start()
# launch polling to serial device
serial_g4_device = G4(running_file_lock)
polling = threading.Thread(target=serial_g4_device.serial_polling)
polling.daemon = True
polling.start()
while True:
pass
class UpdateCfgFile():
"""
Update distro and multibootusb congig file(s).
"""
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
def distro_cfg_files(self):
"""
Main function to modify/update distro specific strings on distro config files.
:return:
"""
#self.usb = USB()
self.iso = ISO(config.iso_link)
config.status_text = "Updating config files..."
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
for dirpath, dirnames, filenames in os.walk(install_dir):
for f in filenames:
if f.endswith(".cfg"):
cfg_file = os.path.join(dirpath, f)
try:
string = open(cfg_file).read()
except IOError:
print "Unable to read " + cfg_file
else:
if not config.distro == "generic":
replace_text = r'\1/multibootusb/' + self.iso.iso_basename() + '/'
string = re.sub(r'([ \t =,])/', replace_text, string)
if config.distro == "ubuntu":
string = re.sub(r'boot=casper',
'boot=casper cdrom-detect/try-usb=true floppy.allowed_drive_mask=0 ignore_uuid ignore_bootid root=UUID=' + self.usb.get_usb(config.usb_disk).uuid + ' live-media-path=/multibootusb/' +
self.iso.iso_basename() + '/casper', string)
if not config.persistence == 0:
string = re.sub(r'boot=casper', 'boot=casper persistent persistent-path=/multibootusb/' +
self.iso.iso_basename() + "/", string)
elif config.distro == "debian":
string = re.sub(r'boot=live', 'boot=live ignore_bootid live-media-path=/multibootusb/' +
self.iso.iso_basename() + '/live', string)
if not config.persistence == 0:
string = re.sub(r'boot=live', 'boot=live persistent persistent-path=/multibootusb/' +
self.iso.iso_basename() + "/", string)
elif config.distro == "ubuntu-server":
string = re.sub(r'file', 'cdrom-detect/try-usb=true floppy.allowed_drive_mask=0 ignore_uuid ignore_bootid root=UUID=' + self.usb.get_usb(config.usb_disk).uuid + ' file', string)
elif config.distro == "fedora":
string = re.sub(r'root=\S*', 'root=UUID=' + self.usb.get_usb(config.usb_disk).uuid, string)
if re.search(r'liveimg', string, re.I):
string = re.sub(r'liveimg', 'liveimg live_dir=/multibootusb/' +
self.iso.iso_basename() + '/LiveOS', string)
elif re.search(r'rd.live.image', string, re.I):
string = re.sub(r'rd.live.image', 'rd.live.image rd.live.dir=/multibootusb/' +
self.iso.iso_basename() + '/LiveOS', string)
if not config.persistence == 0:
if re.search(r'liveimg', string, re.I):
string = re.sub(r'liveimg', 'liveimg overlay=UUID=' + self.usb.get_usb(config.usb_disk).uuid, string)
elif re.search(r'rd.live.image', string, re.I):
string = re.sub(r'rd.live.image', 'rd.live.image rd.live.overlay=UUID=' + self.usb.get_usb(config.usb_disk).uuid, string)
string = re.sub(r' ro ', ' rw ', string)
elif config.distro == "parted-magic":
if re.search(r'append', string, re.I):
string = re.sub(r'append ', 'append directory=/multibootusb/' + self.iso.iso_basename(), string, flags=re.I)
string = re.sub(r'initrd=', 'directory=/multibootusb/' + self.iso.iso_basename() + '/ initrd=',
string)
elif config.distro == "ubcd":
string = re.sub(r'iso_filename=\S*', 'directory=/multibootusb/' + self.iso.iso_basename(),
string, flags=re.I)
elif config.distro == "ipcop":
string = re.sub(r'ipcopboot=cdrom\S*', 'ipcopboot=usb', string)
elif config.distro == "puppy":
string = re.sub(r'pmedia=cd\S*',
'pmedia=usbflash psubok=TRUE psubdir=/multibootusb/' + self.iso.iso_basename() + '/',
string)
elif config.distro == "slax":
string = re.sub(r'initrd=', r'from=/multibootusb/' + self.iso.iso_basename() + '/slax fromusb initrd=', string)
elif config.distro == "knoppix":
string = re.sub(r'(append)',
r'\1 knoppix_dir=/multibootusb/' + self.iso.iso_basename() + '/KNOPPIX',
string)
elif config.distro == "gentoo":
string = re.sub(r'append ', 'append real_root=' + config.usb_disk + ' slowusb subdir=/multibootusb/' +
self.iso.iso_basename() + '/ ', string, flags=re.I)
elif config.distro == "systemrescuecd":
rows = []
subdir = '/multibootusb/' + self.iso.iso_basename() + '/'
for line in string.splitlines(True):
addline = True
if re.match(r'append.*--.*', line, flags=re.I):
line = re.sub(r'(append)(.*)--(.*)', r'\1\2subdir=' + subdir + r' --\3 subdir=' + subdir,
line, flags=re.I)
elif re.match(r'append', line, flags=re.I):
line = re.sub(r'(append)', r'\1 subdir=' + subdir, line, flags=re.I)
elif re.match(r'label rescue(32|64)_1', line, flags=re.I):
rows.append(line)
rows.append('append subdir=%s\n' % (subdir,))
addline = False
if addline:
rows.append(line)
string = ''.join(rows)
elif config.distro == "arch" or config.distro == "chakra":
string = re.sub(r'isolabel=\S*', 'isodevice=/dev/disk/by-uuid/' + self.usb.get_usb(config.usb_disk).uuid, string,
flags=re.I)
string = re.sub(r'isobasedir=',
'isobasedir=/multibootusb/' + self.iso.iso_basename() + '/', string,
flags=re.I)
elif config.distro == "suse" or config.distro == "opensuse":
if re.search(r'opensuse_12', string, re.I):
string = re.sub(r'append', 'append loader=syslinux isofrom_system=/dev/disk/by-uuid/' + self.usb.get_usb(config.usb_disk).uuid + ":/" + self.iso.iso_name(), string, flags=re.I)
else:
string = re.sub(r'append', 'append loader=syslinux isofrom_device=/dev/disk/by-uuid/' + self.usb.get_usb(config.usb_disk).uuid + ' isofrom_system=/multibootusb/' + self.iso.iso_basename() + '/'+ self.iso.iso_name(), string, flags=re.I)
elif config.distro == "pclinuxos":
string = re.sub(r'livecd=',
'fromusb livecd=' + '/multibootusb/' + self.iso.iso_basename() + '/',
string)
string = re.sub(r'prompt', '#prompt', string)
string = re.sub(r'ui gfxboot.com', '#ui gfxboot.com', string)
string = re.sub(r'timeout', '#timeout', string)
elif config.distro == "porteus" or config.distro == "wifislax":
string = re.sub(r'initrd=',
'from=' + '/multibootusb/' + self.iso.iso_basename() + ' initrd=', string)
elif config.distro == "hbcd":
string = re.sub(r'/HBCD', '/multibootusb/' + self.iso.iso_basename() + '/HBCD', string)
elif config.distro == "zenwalk":
string = re.sub(r'initrd=', 'from=/multibootusb/' + self.iso.iso_basename() + '/' + self.iso.iso_name() + ' initrd=', string)
elif config.distro == "mageialive":
string = re.sub(r'LABEL=\S*', 'LABEL=' + self.usb.get_usb(config.usb_disk).label, string)
elif config.distro == "antix":
string = re.sub(r'APPEND', 'image_dir=/multibootusb/' + self.iso.iso_basename(), string)
elif config.distro == "solydx":
string = re.sub(r'live-media-path=', 'live-media-path=/multibootusb/' + self.iso.iso_basename(), string)
elif config.distro == "salix-live":
string = re.sub(r'iso_path', '/multibootusb/' + self.iso.iso_basename() + '/' + self.iso.iso_name(), string)
config_file = open(cfg_file, "wb")
config_file.write(string)
config_file.close()
# Patch for Ubuntu 14.10 and above which uses syslinux version 6
if config.distro == "ubuntu" and config.sys_version == "6":
print "Applying Ubuntu patch..."
for module in os.listdir(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux")):
if module.endswith(".c32"):
if os.path.exists(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux", module)):
try:
os.remove(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux", module))
print "Copying " + module
shutil.copy(gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "modules", "ubuntu_patch", module)),
os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename(), "isolinux", module))
except:
print "Could not copy " + module
self.main_cfg_file()
def main_cfg_file(self):
"""
Update main multibootusb suslinux.cfg file after distro is installed.
:return:
"""
#self.usb = USB()
self.iso = ISO(config.iso_link)
sys_cfg_file = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", "syslinux.cfg")
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
print "Updating main syslinux config file..."
if os.path.exists(sys_cfg_file):
if config.distro == "hbcd":
if os.path.exists(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", "menu.lst")):
config_file = open(os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", "menu.lst"), "wb")
string = re.sub(r'/HBCD', '/multibootusb/' + self.iso.iso_basename() + '/HBCD', config_file)
config_file.write(string)
config_file.close()
if config.distro == "Windows":
if os.path.exists(sys_cfg_file):
config_file = open(sys_cfg_file, "a")
config_file.write("#start " + self.iso.iso_basename() + "\n")
config_file.write("LABEL " + self.iso.iso_basename() + "\n")
config_file.write("MENU LABEL " + self.iso.iso_basename() + "\n")
config_file.write("KERNEL chain.c32 hd0 1 ntldr=/bootmgr" + "\n")
config_file.write("#end " + self.iso.iso_basename() + "\n")
config_file.close()
else:
config_file = open(sys_cfg_file, "a")
config_file.write("#start " + self.iso.iso_basename() + "\n")
config_file.write("LABEL " + self.iso.iso_basename() + "\n")
config_file.write("MENU LABEL " + self.iso.iso_basename() + "\n")
if config.distro == "salix-live":
config_file.write(
"LINUX " + '/multibootusb/' + self.iso.iso_basename() + '/boot/grub2-linux.img' + "\n")
elif config.distro == "pclinuxos":
config_file.write("kernel " + '/multibootusb/' + self.iso.iso_basename() + '/isolinux/vmlinuz' + "\n")
config_file.write("append livecd=livecd root=/dev/rd/3 acpi=on vga=788 keyb=us vmalloc=256M nokmsboot "
"fromusb root=UUID=" + self.usb.get_usb(config.usb_disk).uuid + " bootfromiso=/multibootusb/" +
self.iso.iso_basename() +"/" + self.iso.iso_name() + " initrd=/multibootusb/"
+ self.iso.iso_basename() + '/isolinux/initrd.gz' + "\n")
else:
if config.distro == "ubuntu" and config.sys_version == "6":
config_file.write("CONFIG " + "/multibootusb/" + self.iso.iso_basename() +
"/isolinux/isolinux.cfg" + "\n")
config_file.write("APPEND " + "/multibootusb/" + self.iso.iso_basename() +
"/isolinux" + "\n")
else:
if config.distro == "generic":
distro_syslinux_install_dir = self.iso.isolinux_bin_dir()
if not self.iso.isolinux_bin_dir() == "/":
distro_sys_install_bs = os.path.join(self.usb.get_usb(config.usb_disk).mount, self.iso.isolinux_bin_dir()) + '/' + config.distro + '.bs'
else:
distro_sys_install_bs = '/' + config.distro + '.bs'
else:
distro_syslinux_install_dir = install_dir
distro_syslinux_install_dir = distro_syslinux_install_dir.replace(self.usb.get_usb(config.usb_disk).mount, '')
distro_sys_install_bs = distro_syslinux_install_dir + self.iso.isolinux_bin_dir() + '/' + config.distro + '.bs'
distro_sys_install_bs = "/" + distro_sys_install_bs.replace("\\", "/") # Windows path issue.
config_file.write("BOOT " + distro_sys_install_bs.replace("//", "/") + "\n")
config_file.write("#end " + self.iso.iso_basename() + "\n")
config_file.close()
for dirpath, dirnames, filenames in os.walk(install_dir):
for f in filenames:
if f.endswith("isolinux.cfg"):
shutil.copy2(os.path.join(dirpath, f), os.path.join(dirpath, "syslinux.cfg"))
class Syslinux():
"""
Main Syslinux class.
"""
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
def install_default(self):
"""
Install default syslinux/extlinux (version 4) on selected USB disk.
"""
if config.iso_link:
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
mbr_bin = gen_fun.resource_path(os.path.join("tools", "mbr.bin"))
config.status_text = "Installing default syslinux..."
if filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs":
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "extlinux4")
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True)
if config.user_password:
print "\nExecuting ==> " + syslinux_path + " --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb\n")
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux_path +
" --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount,
"multibootusb"), shell=True) == 0:
print "Default Extlinux install is success..."
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd bs=440 count=1 conv=notrunc if=' + mbr_bin +
' of=' + config.usb_disk[:-1], shell=True) == 0:
print "mbr install is success..."
self.set_boot_flag()
return True
else:
print "Failed to install default extlinux..."
return False
else:
print "\nExecuting ==> " + syslinux_path + " --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb\n")
if subprocess.call(syslinux_path + " --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount,
"multibootusb"), shell=True) == 0:
print "\nExtlinux install on distro directory is success...\n"
if subprocess.call('dd bs=440 count=1 conv=notrunc if=' + mbr_bin +
' of=' + config.usb_disk[:-1], shell=True) == 0:
print "\nmbr install is success...\n"
self.set_boot_flag()
return True
else:
print "\nFailed to install default extlinux...\n"
return False
elif filesystem == "vfat" or filesystem == "ntfs" or filesystem == "FAT32":
if platform.system() == "Linux":
syslinux = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux4"))
if os.access(syslinux, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux, shell=True)
if config.user_password:
print "Executing ==> " + syslinux + ' -i -d multibootusb ' + config.usb_disk
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux + ' -i -d multibootusb ' +
config.usb_disk, shell=True) == 0:
print "Default syslinux install is success..."
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd bs=440 count=1 conv=notrunc if=' + mbr_bin +
' of=' + config.usb_disk[:-1], shell=True) == 0:
print "mbr install is success..."
self.set_boot_flag()
return True
else:
print "Failed to install default syslinux..."
return False
else:
print "\nExecuting ==> " + syslinux + ' -i -d multibootusb ' + config.usb_disk + "\n"
if subprocess.call(syslinux + ' -i -d multibootusb ' + config.usb_disk, shell=True) == 0:
print "\nDefault syslinux install is success...\n"
if subprocess.call('dd bs=440 count=1 conv=notrunc if=' + mbr_bin + ' of=' + config.usb_disk[:-1],
shell=True) == 0:
print "\nmbr install is success...\n"
self.set_boot_flag()
return True
else:
print "\nFailed to install default syslinux...\n"
return False
elif platform.system() == "Windows":
syslinux = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux4.exe"))
if subprocess.call(syslinux + ' -maf -d multibootusb ' + config.usb_disk, shell=True) == 0:
print "\nDefault syslinux install is success...\n"
return True
else:
print "\nFailed to install default syslinux...\n"
return False
self.set_boot_flag()
def install_distro(self):
"""
Install syslinux/extlinux on distro isolinux directory.
"""
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
config.status_text = "Installing distro specific syslinux..."
if self.iso.isolinux_bin_exist() is not True:
print "Distro doesnot use isolinux/syslinux for booting ISO."
else:
self.iso.iso_extract_file(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"), "isolinux.bin")
self.iso.iso_extract_file(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"), "ISOLINUX.BIN")
syslinux_version = self.iso.isolinux_version(self.iso.isolinux_bin_path(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir")))
if config.distro == "generic" or config.distro == "alpine":
install_dir = self.usb.get_usb(config.usb_disk).mount
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/")).replace(self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"), config.distro + '.bs')
else:
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/")).replace(self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"), config.distro + '.bs')
if filesystem == "vfat" or filesystem == "ntfs" or filesystem == "FAT32":
if syslinux_version == str(3):
if config.distro == "generic" and self.iso.isolinux_bin_dir() == "/":
option = ""
else:
option = " -d "
else:
if config.distro == "generic" and self.iso.isolinux_bin_dir() == "/":
option = " -i "
else:
option = " -i -d "
print "distro_syslinux_install_dir is " + distro_syslinux_install_dir
print "distro_sys_install_bs is " + distro_sys_install_bs
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True) == 0
if config.user_password:
print "Executing ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk, shell=True) == 0:
print "\nSyslinux install on distro directory is success..."
print "\nExecuting ==> " + 'dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1\n'
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success..."
else:
print "\nFailed to install syslinux on distro directory...\n"
else:
print "Executing ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk
if subprocess.call(syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk, shell=True) == 0:
print "Syslinux install on distro directory is success..."
print 'Executing ==> dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1'
if subprocess.call('dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success...\n"
else:
print "\nFailed to copy boot sector...\n"
else:
print "\nFailed to install syslinux on distro directory...\n"
elif platform.system() == "Windows":
syslinux_path = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin")) + \
"\syslinux" + syslinux_version + ".exe"
distro_syslinux_install_dir = "/" + distro_syslinux_install_dir.replace("\\", "/")
distro_sys_install_bs = distro_sys_install_bs.replace("/", "\\")
print "\nExecuting ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' ' + \
distro_sys_install_bs + "\n"
if subprocess.call(syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' '
+ distro_sys_install_bs, shell=True) == 0:
print "\nSyslinux install was successful on distro directory...\n"
else:
print "\nFailed to install syslinux on distro directory...\n"
elif filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs":
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"))
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "extlinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True) == 0
if config.user_password:
print "Executing ==> " + syslinux_path + " --install " + distro_syslinux_install_dir
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux_path + " --install " + distro_syslinux_install_dir, shell=True) == 0:
print "\nSyslinux install on distro directory is success..."
print "Executing ==> " + 'dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1'
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success..."
else:
print "Failed to install syslinux on distro directory..."
else:
print "Executing ==> " + syslinux_path + " --install " + distro_syslinux_install_dir
if subprocess.call(syslinux_path + " --install " + distro_syslinux_install_dir, shell=True) == 0:
print "Syslinux install on distro directory is success..."
print "Executing ==> " + 'dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1'
if subprocess.call('dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success..."
else:
print "Failed to install syslinux on distro directory..."
def set_boot_flag(self):
if platform.system() == "Linux":
print "Checking boot flag on " + config.usb_disk[:-1]
if config.user_password:
cmd_out = subprocess.check_output("echo " + config.user_password + " | sudo -S parted -m -s " + config.usb_disk[:-1] + " print", shell=True)
if "boot" in cmd_out:
print "Disk already has boot flag."
else:
print "Executing ==> parted " + config.usb_disk[:-1] + " set 1 boot on"
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + " parted " + config.usb_disk[:-1]+ " set 1 boot on", shell=True) == 0:
print "Boot flag set to bootable on " + config.usb_disk[:-1]
else:
print "Unable to set boot flag on " + config.usb_disk[:-1]
else:
cmd_out = subprocess.check_output("parted -m -s " + config.usb_disk[:-1] + " print", shell=True)
if "boot" in cmd_out:
print "Disk " + config.usb_disk[:-1] + " already has boot flag."
else:
print "Executing ==> parted " + config.usb_disk[:-1] + " set 1 boot on"
if subprocess.call("parted " + config.usb_disk[:-1]+ " set 1 boot on", shell=True) == 0:
print "Boot flag set to bootable " + config.usb_disk[:-1]
else:
print "Unable to set boot flag on " + config.usb_disk[:-1]
def __init__(self):
from usb import USB
self.usb = USB()
class InstallDistro():
def __init__(self):
from usb import USB
self.usb = USB()
def install(self):
"""
Install selected ISO to USB disk.
:return:
"""
self.iso = iso.ISO(config.iso_link)
install_dir = os.path.join(config.usb_mount, "multibootusb", self.iso.iso_basename())
if not os.path.exists(os.path.join(config.usb_mount, "multibootusb")):
print "Copying multibootusb directory to " + config.usb_mount
shutil.copytree(gen_fun.resource_path(os.path.join("tools", "multibootusb")),
os.path.join(config.usb_mount, "multibootusb"))
if not os.path.exists(install_dir):
os.mkdir(install_dir)
with open(os.path.join(install_dir, "multibootusb.cfg"), "w") as f:
f.write(config.distro)
with open(os.path.join(install_dir, "iso_file_list.cfg"), 'w') as f:
for file_path in self.iso.iso_file_list():
f.write(file_path + "\n")
print "Install dir is " + install_dir
if config.distro == "opensuse":
self.iso.iso_extract_file(install_dir, "boot")
config.status_text = "Copying ISO..."
if platform.system() == "Windows":
subprocess.call(["xcopy", config.iso_link, config.usb_mount], shell=True) # Have to use xcopy as python file copy is dead slow.
elif platform.system() == "Linux":
print config.iso_link, config.usb_mount
shutil.copy(config.iso_link, config.usb_mount)
elif config.distro == "Windows":
print "Extracting iso to " + config.usb_mount
self.iso.iso_extract_full(config.usb_mount)
elif config.distro == "trinity-rescue":
self.iso.iso_extract_file(config.usb_mount, "trk3")
elif config.distro == "ipfire":
self.iso.iso_extract_file(install_dir, "boot")
self.iso.iso_extract_file(config.usb_mount, ".tlz")
self.iso.iso_extract_file(config.usb_mount, "distro.img")
elif config.distro == "alpine":
self.iso.iso_extract_full(config.usb_mount)
elif config.distro == "zenwalk":
self.iso.iso_extract_file(install_dir, "kernel")
self.iso.iso_extract_file(install_dir, "kernel")
if platform.system() == "Windows":
subprocess.call(["xcopy",config.iso_link, install_dir], shell=True)
elif platform.system() == "Linux":
shutil.copy(config.iso_link, install_dir)
elif config.distro == "salix-live":
self.iso.iso_extract_file(install_dir, "boot")
config.status_text = "Copying ISO..."
if platform.system() == "Windows":
subprocess.call("xcopy " + config.iso_link + " " + install_dir, shell=True)
elif platform.system() == "Linux":
shutil.copy(config.iso_link, install_dir)
elif config.distro == "generic":
with open(os.path.join(install_dir, "generic.cfg"), "w") as f:
f.write(os.path.join(self.iso.isolinux_bin_dir(), "generic") + ".bs")
self.iso.iso_extract_full(config.usb_mount)
else:
self.iso.iso_extract_full(install_dir)
if not config.persistence == 0:
import persistence
config.status_text = "Extracting persistance file..."
home = gen_fun.mbusb_dir()
persistence.persistence_extract(config.distro, str(config.persistence), home, install_dir)
def install_progress(self):
"""
Function to get the progress of install function as percentage.
:return:
"""
thrd = threading.Thread(target=self.install, name="install_progress")
#thrd.daemon()
install_size = self.usb.disk_usage(config.usb_mount).used / 1024
thrd.start()
while thrd.is_alive():
current_size = self.usb.disk_usage(config.usb_mount).used / 1024
diff_size = abs(int(current_size - install_size))
config.percentage = round(float(1.0 * diff_size) / config.install_size * 100)
#print config.percentage
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
class InstallDistro():
def __init__(self):
from usb import USB
self.usb = USB()
def install(self):
"""
Install selected ISO to USB disk.
:return:
"""
self.iso = iso.ISO(config.iso_link)
install_dir = os.path.join(config.usb_mount, "multibootusb", self.iso.iso_basename())
if not os.path.exists(os.path.join(config.usb_mount, "multibootusb")):
print "Copying multibootusb directory to " + config.usb_mount
shutil.copytree(gen_fun.resource_path(os.path.join("tools", "multibootusb")),
os.path.join(config.usb_mount, "multibootusb"))
if not os.path.exists(install_dir):
os.mkdir(install_dir)
with open(os.path.join(install_dir, "multibootusb.cfg"), "w") as f:
f.write(config.distro)
with open(os.path.join(install_dir, "iso_file_list.cfg"), 'w') as f:
for file_path in self.iso.iso_file_list():
f.write(file_path + "\n")
print "Install dir is " + install_dir
if config.distro == "opensuse":
self.iso.iso_extract_file(install_dir, "boot")
config.status_text = "Copying ISO..."
if platform.system() == "Windows":
subprocess.call(["xcopy", config.iso_link, config.usb_mount], shell=True) # Have to use xcopy as python file copy is dead slow.
elif platform.system() == "Linux":
print config.iso_link, config.usb_mount
shutil.copy(config.iso_link, config.usb_mount)
elif config.distro == "Windows":
print "Extracting iso to " + config.usb_mount
self.iso.iso_extract_full(config.usb_mount)
elif config.distro == "trinity-rescue":
self.iso.iso_extract_file(config.usb_mount, "trk3")
elif config.distro == "ipfire":
self.iso.iso_extract_file(install_dir, "boot")
self.iso.iso_extract_file(config.usb_mount, ".tlz")
self.iso.iso_extract_file(config.usb_mount, "distro.img")
elif config.distro == "zenwalk":
self.iso.iso_extract_file(install_dir, "kernel")
self.iso.iso_extract_file(install_dir, "kernel")
if platform.system() == "Windows":
subprocess.call(["xcopy",config.iso_link, install_dir], shell=True)
elif platform.system() == "Linux":
shutil.copy(config.iso_link, install_dir)
elif config.distro == "salix-live":
self.iso.iso_extract_file(install_dir, "boot")
config.status_text = "Copying ISO..."
if platform.system() == "Windows":
subprocess.call("xcopy " + config.iso_link + " " + install_dir, shell=True)
elif platform.system() == "Linux":
shutil.copy(config.iso_link, install_dir)
elif config.distro == "generic":
with open(os.path.join(install_dir, "generic.cfg"), "w") as f:
f.write(os.path.join(self.iso.isolinux_bin_dir(), "generic") + ".bs")
self.iso.iso_extract_full(config.usb_mount)
else:
self.iso.iso_extract_full(install_dir)
if not config.persistence == 0:
import persistence
config.status_text = "Extracting persistance file..."
home = gen_fun.mbusb_dir()
persistence.persistence_extract(config.distro, str(config.persistence), home, install_dir)
def install_progress(self):
"""
Function to get the progress of install function as percentage.
:return:
"""
print "\n\ninstall_progress " + config.usb_disk + "\n\n"
thrd = threading.Thread(target=self.install, name="install_progress")
#thrd.daemon()
install_size = self.usb.disk_usage(config.usb_mount).used / 1024
thrd.start()
while thrd.is_alive():
current_size = self.usb.disk_usage(config.usb_mount).used / 1024
diff_size = abs(int(current_size - install_size))
config.percentage = round(float(1.0 * diff_size) / config.install_size * 100)
#print config.percentage
def __init__(self):
from usb import USB
self.usb = USB()
class Syslinux():
"""
Main Syslinux class.
"""
def __init__(self):
self.usb_disk = config.usb_disk
self.usb = USB()
def install_default(self):
"""
Install default syslinux/extlinux (version 4) on selected USB disk.
"""
if config.iso_link:
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
mbr_bin = gen_fun.resource_path(os.path.join("tools", "mbr.bin"))
config.status_text = "Installing default syslinux..."
if filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs":
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "extlinux4")
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True)
if config.user_password:
print "\nExecuting ==> " + syslinux_path + " --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb\n")
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux_path +
" --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount,
"multibootusb"), shell=True) == 0:
print "Default Extlinux install is success..."
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd bs=440 count=1 conv=notrunc if=' + mbr_bin +
' of=' + config.usb_disk[:-1], shell=True) == 0:
print "mbr install is success..."
self.set_boot_flag()
return True
else:
print "Failed to install default extlinux..."
return False
else:
print "\nExecuting ==> " + syslinux_path + " --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb\n")
if subprocess.call(syslinux_path + " --install " + os.path.join(self.usb.get_usb(config.usb_disk).mount,
"multibootusb"), shell=True) == 0:
print "\nExtlinux install on distro directory is success...\n"
if subprocess.call('dd bs=440 count=1 conv=notrunc if=' + mbr_bin +
' of=' + config.usb_disk[:-1], shell=True) == 0:
print "\nmbr install is success...\n"
self.set_boot_flag()
return True
else:
print "\nFailed to install default extlinux...\n"
return False
elif filesystem == "vfat" or filesystem == "ntfs" or filesystem == "FAT32":
if platform.system() == "Linux":
syslinux = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux4"))
if os.access(syslinux, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux, shell=True)
if config.user_password:
print "Executing ==> " + syslinux + ' -i -d multibootusb ' + config.usb_disk
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux + ' -i -d multibootusb ' +
config.usb_disk, shell=True) == 0:
print "Default syslinux install is success..."
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd bs=440 count=1 conv=notrunc if=' + mbr_bin +
' of=' + config.usb_disk[:-1], shell=True) == 0:
print "mbr install is success..."
self.set_boot_flag()
return True
else:
print "Failed to install default syslinux..."
return False
else:
print "\nExecuting ==> " + syslinux + ' -i -d multibootusb ' + config.usb_disk + "\n"
if subprocess.call(syslinux + ' -i -d multibootusb ' + config.usb_disk, shell=True) == 0:
print "\nDefault syslinux install is success...\n"
if subprocess.call('dd bs=440 count=1 conv=notrunc if=' + mbr_bin + ' of=' + config.usb_disk[:-1],
shell=True) == 0:
print "\nmbr install is success...\n"
self.set_boot_flag()
return True
else:
print "\nFailed to install default syslinux...\n"
return False
elif platform.system() == "Windows":
syslinux = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux4.exe"))
if subprocess.call(syslinux + ' -maf -d multibootusb ' + config.usb_disk, shell=True) == 0:
print "Default syslinux install is success..."
return True
else:
print "Failed to install default syslinux..."
return False
self.set_boot_flag()
def install_distro(self):
"""
Install syslinux/extlinux on distro isolinux directory.
"""
self.iso = ISO(config.iso_link)
filesystem = self.usb.get_usb(config.usb_disk).filesystem
config.status_text = "Installing distro specific syslinux..."
if self.iso.isolinux_bin_exist() is not True:
print "Distro doesnot use isolinux/syslinux for booting ISO."
else:
self.iso.iso_extract_file(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"), "isolinux.bin")
self.iso.iso_extract_file(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir"), "ISOLINUX.BIN")
syslinux_version = self.iso.isolinux_version(self.iso.isolinux_bin_path(os.path.join(gen_fun.mbusb_dir(), "iso_cfg_ext_dir")))
if config.distro == "generic":
install_dir = self.usb.get_usb(config.usb_disk).mount
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/")).replace(self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"), config.distro + '.bs')
else:
install_dir = os.path.join(self.usb.get_usb(config.usb_disk).mount, "multibootusb", self.iso.iso_basename())
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/")).replace(self.usb.get_usb(config.usb_disk).mount, "")
distro_sys_install_bs = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"), config.distro + '.bs')
if filesystem == "vfat" or filesystem == "ntfs" or filesystem == "FAT32":
if syslinux_version == str(3):
if config.distro == "generic" and self.iso.isolinux_bin_dir() == "/":
option = ""
else:
option = " -d "
else:
if config.distro == "generic" and self.iso.isolinux_bin_dir() == "/":
option = " -i "
else:
option = " -i -d "
print "distro_syslinux_install_dir is " + distro_syslinux_install_dir
print "distro_sys_install_bs is " + distro_sys_install_bs
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "syslinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True) == 0
if config.user_password:
print "Executing ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk, shell=True) == 0:
print "\nSyslinux install on distro directory is success..."
print "\nExecuting ==> " + 'dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1\n'
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success..."
else:
print "\nFailed to install syslinux on distro directory...\n"
else:
print "Executing ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk
if subprocess.call(syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk, shell=True) == 0:
print "Syslinux install on distro directory is success..."
print 'Executing ==> dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1'
if subprocess.call('dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success...\n"
else:
print "\nFailed to copy boot sector...\n"
else:
print "\nFailed to install syslinux on distro directory...\n"
elif platform.system() == "Windows":
syslinux_path = gen_fun.resource_path(os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin")) + \
"\syslinux" + syslinux_version + ".exe"
distro_syslinux_install_dir = "/" + distro_syslinux_install_dir.replace("\\", "/")
distro_sys_install_bs = distro_sys_install_bs.replace("/", "\\")
print "\nExecuting ==> " + syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' ' + \
distro_sys_install_bs + "\n"
if subprocess.call(syslinux_path + option + distro_syslinux_install_dir + ' ' + config.usb_disk + ' '
+ distro_sys_install_bs, shell=True) == 0:
print "\nSyslinux install was successful on distro directory...\n"
else:
print "\nFailed to install syslinux on distro directory...\n"
elif filesystem == "ext2" or filesystem == "ext3" or filesystem == "ext4" or filesystem == "Btrfs":
distro_syslinux_install_dir = os.path.join(install_dir, self.iso.isolinux_bin_dir().strip("/"))
if platform.system() == "Linux":
syslinux_path = os.path.join(gen_fun.mbusb_dir(), "syslinux", "bin", "extlinux") + syslinux_version
if os.access(syslinux_path, os.X_OK) is False:
subprocess.call('chmod +x ' + syslinux_path, shell=True) == 0
if config.user_password:
print "Executing ==> " + syslinux_path + " --install " + distro_syslinux_install_dir
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + syslinux_path + " --install " + distro_syslinux_install_dir, shell=True) == 0:
print "\nSyslinux install on distro directory is success..."
print "Executing ==> " + 'dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1'
if subprocess.call('echo ' + config.user_password + ' | sudo -S dd if=' + config.usb_disk + ' ' + 'of=' + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success..."
else:
print "Failed to install syslinux on distro directory..."
else:
print "Executing ==> " + syslinux_path + " --install " + distro_syslinux_install_dir
if subprocess.call(syslinux_path + " --install " + distro_syslinux_install_dir, shell=True) == 0:
print "Syslinux install on distro directory is success..."
if subprocess.call('dd if=' + self.usb_disk + ' ' + 'of=' + self.usb.get_usb(config.usb_disk).mount + distro_sys_install_bs + ' count=1', shell=True) == 0:
print "\nBootsector copy is success..."
else:
print "Failed to install syslinux on distro directory..."
def set_boot_flag(self):
if platform.system() == "Linux":
print "Checking boot flag on " + config.usb_disk[:-1]
if config.user_password:
cmd_out = subprocess.check_output("echo " + config.user_password + " | sudo -S parted -m -s " + config.usb_disk[:-1] + " print", shell=True)
if "boot" in cmd_out:
print "Disk already has boot flag."
else:
print "Executing ==> parted " + config.usb_disk[:-1] + " set 1 boot on"
if subprocess.call('echo ' + config.user_password + ' | sudo -S ' + " parted " + config.usb_disk[:-1]+ " set 1 boot on", shell=True) == 0:
print "Boot flag set to bootable on " + config.usb_disk[:-1]
else:
print "Unable to set boot flag on " + config.usb_disk[:-1]
else:
cmd_out = subprocess.check_output("parted -m -s " + config.usb_disk[:-1] + " print", shell=True)
if "boot" in cmd_out:
print "Disk " + config.usb_disk[:-1] + " already has boot flag."
else:
print "Executing ==> parted " + config.usb_disk[:-1] + " set 1 boot on"
if subprocess.call("parted " + config.usb_disk[:-1]+ " set 1 boot on", shell=True) == 0:
print "Boot flag set to bootable " + config.usb_disk[:-1]
else:
print "Unable to set boot flag on " + config.usb_disk[:-1]
