Ejemplo n.º 1
0
    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
Ejemplo n.º 2
0
def persistence_extract(distro, persistence_size, mbusb_dir, install_dir):
    """
    Function to detect and extract persistence files to distro install directory.
    :param distro: Detected distro name.
    :param persistence_size: Size of the choosen persistence size.
    :param mbusb_dir: Path to multibootusb directory on host system.
    :param install_dir: Path to distro install directory.
    :return:
    """
    if distro == "ubuntu" or distro == "debian":
        extension = ".ext4.tar.bz2"
    elif distro == "fedora":
        extension = ".tar.bz2"
    persistence_host_file_path = gen_fun.resource_path(
        os.path.join(mbusb_dir, "persistence_data",
                     persistence_size + extension))
    extract_file(persistence_host_file_path, install_dir)
    if os.path.exists(os.path.join(install_dir, persistence_size + ".ext4")):
        if distro == "ubuntu":
            os.rename(os.path.join(install_dir, persistence_size + ".ext4"),
                      os.path.join(install_dir, "casper-rw"))
        elif distro == "debian":
            os.rename(os.path.join(install_dir, persistence_size + ".ext4"),
                      os.path.join(install_dir, "live-rw"))
    elif os.path.exists(os.path.join(install_dir, persistence_size)):
        if distro == "fedora":
            os.rename(
                os.path.join(install_dir, persistence_size),
                os.path.join(install_dir, "overlay-UUID-" + gbl_usb_uuid))
Ejemplo n.º 3
0
    def on_Qemu_Boot_usb_Click(self, usb_disk):
        """
        Main function to boot a selected USB disk.
        :param usb_disk: Path to usb disk.
        :return:
        """
        qemu = self.check_qemu_exist()

        if qemu is None:
            print "QEMU does not exist.\nPlease install qemu package to avail this feature."
            QtGui.QMessageBox.information(self, 'No QEMU...', 'Please install qemu to avail this feature.')
        else:
            ram = self.qemu_usb_ram()
            if ram is None:
                QtGui.QMessageBox.information(self, 'No ram...', 'No ram selected.\n\nPlease choose any ram value and click Boot USB.')
            else:
                if platform.system() == "Windows":
                    disk_number = self.get_physical_disk_number(usb_disk)
                    parent_dir = os.getcwd()
                    os.chdir(gen_fun.resource_path(os.path.join("tools", "qemu")))
                    try:
                        print "Executing ==>  " + qemu + " -L . -boot c -m " + ram + " -hda //./PhysicalDrive" + disk_number
                        subprocess.Popen("qemu-system-x86_64.exe -L . -boot c -m "  + ram + " -hda //./PhysicalDrive" + disk_number, shell=True)
                    except:
                        QtGui.QMessageBox.information(self, 'Error...', 'Error booting USB\n'
                                                                            'Unable to start QEMU.')
                    os.chdir(parent_dir)
                elif platform.system() == "Linux":
                    try:
                        admin.adminCmd([qemu, '-hda', usb_disk[:-1], '-m', ram, '-vga std'], gui=True)
                    except:
                        QtGui.QMessageBox.information(self, 'Error...', 'Error booting USB\n\nUnable to start QEMU.')
Ejemplo n.º 4
0
    def check_qemu_exist(self):
        """
        Check if QEMU is available on host system.
        :return: path to QEMU program or None otherwise.
        """
        if platform.system() == "Linux":
            if subprocess.call('which qemu-system-x86_64', shell=True) == 0:
                print "qemu-system-x86_64 exists..."
                qemu = "qemu-system-x86_64"
            elif subprocess.call('which qemu', shell=True) == 0:
                print "qemu exists"
                qemu = "qemu"
            else:
                qemu = None

            if qemu:
                return qemu
            else:
                return None
        elif platform.system() == "Windows":
            print gen_fun.resource_path(os.path.join("tools", "qemu", "qemu-system-x86_64.exe"))
            return gen_fun.resource_path(os.path.join("tools", "qemu", "qemu-system-x86_64.exe"))
Ejemplo n.º 5
0
    def check_qemu_exist(self):
        """
        Check if QEMU is available on host system.
        :return: path to QEMU program or None otherwise.
        """
        if platform.system() == "Linux":
            if subprocess.call('which qemu-system-x86_64', shell=True) == 0:
                print "qemu-system-x86_64 exists..."
                qemu = "qemu-system-x86_64"
            elif subprocess.call('which qemu', shell=True) == 0:
                print "qemu exists"
                qemu = "qemu"
            else:
                qemu = None

            if qemu:
                return qemu
            else:
                return None
        elif platform.system() == "Windows":
            print gen_fun.resource_path(os.path.join("tools", "qemu", "qemu-system-x86_64.exe"))
            return gen_fun.resource_path(os.path.join("tools", "qemu", "qemu-system-x86_64.exe"))
Ejemplo n.º 6
0
def persistence_extract(distro, persistence_size, mbusb_dir, install_dir):
    """
    Function to detect and extract persistence files to distro install directory.
    :param distro: Detected distro name.
    :param persistence_size: Size of the choosen persistence size.
    :param mbusb_dir: Path to multibootusb directory on host system.
    :param install_dir: Path to distro install directory.
    :return:
    """
    if distro == "ubuntu" or distro == "debian":
        extension = ".ext4.tar.bz2"
    elif distro == "fedora":
        extension = ".tar.bz2"
    persistence_host_file_path = gen_fun.resource_path(os.path.join(mbusb_dir, "persistence_data", persistence_size + extension))
    extract_file(persistence_host_file_path, install_dir)
    if os.path.exists(os.path.join(install_dir, persistence_size + ".ext4")):
        if distro == "ubuntu":
            os.rename(os.path.join(install_dir, persistence_size + ".ext4"), os.path.join(install_dir, "casper-rw"))
        elif distro == "debian":
            os.rename(os.path.join(install_dir, persistence_size + ".ext4"), os.path.join(install_dir, "live-rw"))
    elif os.path.exists(os.path.join(install_dir, persistence_size)):
        if distro == "fedora":
            os.rename(os.path.join(install_dir, persistence_size),
                      os.path.join(install_dir, "overlay-UUID-" + gbl_usb_uuid))
Ejemplo n.º 7
0
    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..."
Ejemplo n.º 8
0
    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()
Ejemplo n.º 9
0
    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
Ejemplo n.º 10
0
    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
Ejemplo n.º 11
0
    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)
Ejemplo n.º 12
0
    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
Ejemplo n.º 13
0
    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()
Ejemplo n.º 14
0
    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()
Ejemplo n.º 15
0
    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()
Ejemplo n.º 16
0
    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..."
Ejemplo n.º 17
0
    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)