-#!/usr/bin/env python
+#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0302
"""
This script installs a Grml system (either a running system or ISO[s]) to a USB device
-:copyright: (c) 2009, 2010, 2011 by Michael Prokop <mika@grml.org>
+:copyright: (c) 2009-2019 by Michael Prokop <mika@grml.org>
:license: GPL v2 or any later version
:bugreports: http://grml.org/bugs/
"""
-from __future__ import print_function
+
from optparse import OptionParser
from inspect import isroutine, isclass
import datetime
import shutil
# The line following this line is patched by debian/rules and tarball.sh.
-PROG_VERSION = '***UNRELEASED***'
+PROG_VERSION = '***UNKNOWN***'
+
+# when running from inside git, try to report version information via git-describe
+try:
+ git_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
+ with open(os.devnull, 'w') as devnull:
+ PROG_VERSION = subprocess.check_output(["git",
+ "-C",
+ git_dir,
+ "describe",
+ "--always",
+ "--dirty"],
+ stderr=devnull).strip().decode('utf-8', errors='replace') + \
+ " (git)"
+except Exception:
+ pass
# global variables
MOUNTED = set() # register mountpoints
GRML_FLAVOURS = set() # which flavours are being installed?
GRML_DEFAULT = None
UUID = None
-SYSLINUX_LIBS = "/usr/lib/syslinux/"
-GPT_HEADER = "\x55\xaa\x45\x46\x49\x20\x50\x41\x52\x54" # original GPT header
+SYSLINUX_LIBS = "/usr/lib/syslinux/modules/bios/"
+GPT_HEADER = b"\x55\xaa\x45\x46\x49\x20\x50\x41\x52\x54" # original GPT header
GRUB_INSTALL = None
RE_PARTITION = re.compile(r'([a-z/]*?)(\d+)$')
setattr(opt_parser.values, option.dest, True)
setattr(opt_parser.values, 'syslinux', False)
+
# cmdline parsing
-USAGE = "Usage: %prog [options] <[ISO[s] | /lib/live/mount/medium]> </dev/sdX#>\n\
+USAGE = "Usage: %prog [options] <[ISO[s] | /run/live/medium]> </dev/sdX#>\n\
\n\
%prog installs Grml ISO[s] to an USB device to be able to boot from it.\n\
-Make sure you have at least one Grml ISO or a running Grml system (/lib/live/mount/medium),\n\
+Make sure you have at least one Grml ISO or a running Grml system (/run/live/medium),\n\
grub or syslinux and root access.\n\
\n\
Run %prog --help for usage hints, further information via: man grml2usb"
help="do not output anything but just errors on console")
parser.add_option("--remove-bootoption", dest="removeoption", action="append",
help="regex for removing existing bootoptions")
+parser.add_option("--rw-blockdev", dest="rwblockdev", action="store_true",
+ help="enforce read-write mode on involved block devices")
parser.add_option("--skip-addons", dest="skipaddons", action="store_true",
help="do not install /boot/addons/ files")
parser.add_option("--skip-bootflag", dest="skipbootflag", action="store_true",
try:
unmount(device, "")
logging.debug('Unmounted %s' % device)
- except StandardError:
+ except Exception:
logging.debug('RuntimeError while umount %s, ignoring' % device)
for tmppath in TMPFILES.copy():
os.unlink(tmppath)
logging.debug('temporary file %s deleted' % tmppath)
unregister_tmpfile(tmppath)
- except StandardError:
+ except Exception:
msg = 'RuntimeError while removing temporary %s, ignoring'
logging.debug(msg % tmppath)
def get_function_name(obj):
- """Helper function for use in execute() to retrive name of a function
+ """Helper function for use in execute() to retrieve name of a function
@obj: the function object
"""
return obj.__module__ + '.' + obj.__name__
+def set_rw(device):
+ if not options.rwblockdev:
+ return
+
+ logging.debug("executing: blockdev --setrw %s", device)
+ proc = subprocess.Popen(["blockdev", "--setrw", device])
+ proc.wait()
+ if proc.returncode != 0:
+ raise Exception("error executing blockdev on %s" % device)
+
+
def execute(f, *exec_arguments):
"""Wrapper for executing a command. Either really executes
the command (default) or when using --dry-run commandline option
"""
bootloader_dirs = ['/boot/isolinux/', '/boot/syslinux/']
for directory in bootloader_dirs:
- for name in name, \
- "%s_%s" % (get_flavour_filename(flavour), name):
+ for name in name, "%s_%s" % (get_flavour_filename(flavour), name):
if os.path.isfile(iso_mount + directory + name):
return (directory, name)
return ('', '')
-def search_file(filename, search_path='/bin' + os.pathsep + '/usr/bin', lst_return=False):
+def search_file(filename, search_path='/bin' + os.pathsep + '/usr/bin', lst_return=False, required=False):
"""Given a search path, find file
@filename: name of file to search for
retval.append(os.path.abspath(os.path.join(current_dir, filename)))
if not lst_return:
break
+
+ if required and not retval:
+ raise CriticalException("Required file %s not found in %s" % (filename, search_path))
+
if lst_return:
return retval
elif retval:
if part.getFlag(parted.PARTITION_BOOT):
logging.debug("bootflag is enabled on %s" % device)
return
- except HodorException, e:
+ except HodorException as e:
logging.info("%s, falling back to old bootflag detection", e)
- except ImportError, e:
+ except ImportError as e:
logging.debug("could not import parted, falling back to old bootflag detection")
- with open(boot_dev, 'r') as image:
+ with open(boot_dev, 'rb') as image:
data = image.read(520)
bootcode = data[440:]
gpt_data = bootcode[70:80]
if gpt_data == GPT_HEADER:
logging.info("GPT detected, skipping bootflag check")
- elif bootcode[6] == '\x80':
+ elif bootcode[6] == b"\x80":
logging.debug("bootflag is enabled")
else:
logging.debug("bootflag is NOT enabled")
device_mountpoint = tempfile.mkdtemp(prefix="grml2usb")
register_tmpfile(device_mountpoint)
try:
- mount(device, device_mountpoint, "")
-
# If using --grub-mbr then make sure we install grub in MBR instead of PBR
if options.grubmbr:
logging.debug("Using option --grub-mbr ...")
else:
grub_device = device
+ set_rw(device)
+ mount(device, device_mountpoint, "")
+
logging.info("Installing grub as bootloader")
- for opt in ["", "--force"]:
- logging.debug("grub-install --recheck %s --no-floppy --root-directory=%s %s",
- opt, device_mountpoint, grub_device)
- proc = subprocess.Popen([GRUB_INSTALL, "--recheck", opt,
+ for opt in ["--", "--force"]:
+ set_rw(device)
+ set_rw(grub_device)
+ logging.debug("%s --recheck --no-floppy --target=i386-pc --root-directory=%s %s %s",
+ GRUB_INSTALL, device_mountpoint, opt, grub_device)
+ proc = subprocess.Popen([GRUB_INSTALL, "--recheck",
"--no-floppy", "--target=i386-pc",
- "--root-directory=%s" % device_mountpoint, grub_device],
- stdout=file(os.devnull, "r+"))
+ "--root-directory=%s" % device_mountpoint,
+ opt, grub_device],
+ stdout=open(os.devnull, "r+"))
proc.wait()
if proc.returncode == 0:
break
if proc.returncode != 0:
# raise Exception("error executing grub-install")
- logging.critical("Fatal: error executing grub-install "
- + "(please check the grml2usb FAQ or drop the --grub option)")
- logging.critical("Note: if using grub2 consider using "
- + "the --grub-mbr option as grub considers PBR problematic.")
+ logging.critical("Fatal: error executing grub-install " +
+ "(please check the grml2usb FAQ or drop the --grub option)")
+ logging.critical("Note: if using grub2 consider using " +
+ "the --grub-mbr option as grub considers PBR problematic.")
cleanup()
sys.exit(1)
except CriticalException as error:
logging.info("Would install syslinux as bootloader on %s", device)
return 0
+ set_rw(device)
+
# syslinux -d boot/isolinux /dev/sdb1
logging.info("Installing syslinux as bootloader")
logging.debug("syslinux -d boot/syslinux %s", device)
logging.debug("executing: dd if='%s' of='%s' bs=512 count=1", device, tmpf.name)
proc = subprocess.Popen(["dd", "if=%s" % device, "of=%s" % tmpf.name, "bs=512", "count=1"],
- stderr=file(os.devnull, "r+"))
+ stderr=open(os.devnull, "r+"))
proc.wait()
if proc.returncode != 0:
raise Exception("error executing dd (first run)")
logging.debug("executing: dd if=%s of=%s bs=%s count=1 conv=notrunc", mbrtemplate,
tmpf.name, nmbrbytes)
proc = subprocess.Popen(["dd", "if=%s" % mbrtemplate, "of=%s" % tmpf.name, "bs=%s" % nmbrbytes,
- "count=1", "conv=notrunc"], stderr=file(os.devnull, "r+"))
+ "count=1", "conv=notrunc"], stderr=open(os.devnull, "r+"))
proc.wait()
if proc.returncode != 0:
raise Exception("error executing dd (second run)")
if partition is not None:
if ismirbsdmbr:
- mbrcode = mbrcode[0:439] + chr(partition) + \
- mbrcode[440:510] + "\x55\xAA"
+ mbrcode = mbrcode[0:439] + chr(partition).encode('latin-1') + \
+ mbrcode[440:510] + b"\x55\xAA"
else:
- actives = ["\x00", "\x00", "\x00", "\x00"]
- actives[partition] = "\x80"
+ actives = [b"\x00", b"\x00", b"\x00", b"\x00"]
+ actives[partition] = b"\x80"
mbrcode = mbrcode[0:446] + actives[0] + \
mbrcode[447:462] + actives[1] + \
mbrcode[463:478] + actives[2] + \
mbrcode[479:494] + actives[3] + \
- mbrcode[495:510] + "\x55\xAA"
+ mbrcode[495:510] + b"\x55\xAA"
tmpf.file.seek(0)
tmpf.file.truncate()
tmpf.file.write(mbrcode)
tmpf.file.close()
+ set_rw(device)
+
logging.debug("executing: dd if='%s' of='%s' bs=512 count=1 conv=notrunc", tmpf.name, device)
proc = subprocess.Popen(["dd", "if=%s" % tmpf.name, "of=%s" % device, "bs=512", "count=1",
- "conv=notrunc"], stderr=file(os.devnull, "r+"))
+ "conv=notrunc"], stderr=open(os.devnull, "r+"))
proc.wait()
if proc.returncode != 0:
raise Exception("error executing dd (third run)")
proc = subprocess.Popen(["sync"])
proc.wait()
+ set_rw(device)
+
def is_writeable(device):
"""Check if the device is writeable for the current user
if not device:
return False
- #raise Exception("no device for checking write permissions")
if not os.path.exists(device):
return False
# note: options.dryrun does not work here, as we have to
# locate files and identify the grml flavour
- for x in file('/proc/mounts').readlines():
+ for x in open('/proc/mounts', 'r').readlines():
if x.startswith(source):
- raise CriticalException("Error executing mount: %s already mounted - " % source
- + "please unmount before invoking grml2usb")
+ raise CriticalException("Error executing mount: %s already mounted - " % source +
+ "please unmount before invoking grml2usb")
if os.path.isdir(source):
logging.debug("Source %s is not a device, therefore not mounting.", source)
try:
udev_info = subprocess.Popen(["/sbin/blkid", "-s", "TYPE", "-o", "value", partition],
- stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
filesystem = udev_info.communicate()[0].rstrip()
if filesystem != "vfat":
# update the existing flavours on the target
for line in fileinput.input([target_grml_version_file], inplace=1):
flavour = get_flavour(line)
- if flavour in iso_versions.keys():
+ if flavour in list(iso_versions.keys()):
print(iso_versions.pop(flavour))
else:
print(line.strip())
# ipxe.lkrn
handle_addon_copy('ipxe.lkrn', addons, iso_mount)
+ # netboot.xyz
+ handle_addon_copy('netboot.xyz.lkrn', addons, iso_mount)
+
def build_loopbackcfg(target):
"""Generate GRUB's loopback.cfg based on existing config files.
grub_target = target + '/boot/grub/'
execute(mkdir, grub_target)
- logo = search_file('logo.16', iso_mount)
+ logo = search_file('logo.16', iso_mount, required=True)
exec_rsync(logo, syslinux_target + 'logo.16')
bootx64_efi = search_file('bootx64.efi', iso_mount)
if efi_img:
mkdir(target + '/boot/')
exec_rsync(efi_img, target + '/boot/efi.img')
+ handle_secure_boot(target, efi_img)
for ffile in ['f%d' % number for number in range(1, 11)]:
search_and_copy(ffile, iso_mount, syslinux_target + ffile)
logging.warning("Warning: Grml releases older than 2011.12 support only one flavour in grub.")
for expr in name, 'distri.cfg', \
- defaults_file, 'grml.png', 'hd.cfg', 'isolinux.cfg', 'isolinux.bin', \
- 'isoprompt.cfg', 'options.cfg', \
- 'prompt.cfg', 'vesamenu.cfg', 'grml.png', '*.c32':
+ defaults_file, 'grml.png', 'hd.cfg', 'isolinux.cfg', 'isolinux.bin', \
+ 'isoprompt.cfg', 'options.cfg', \
+ 'prompt.cfg', 'vesamenu.cfg', 'grml.png', '*.c32':
glob_and_copy(iso_mount + source_dir + expr, syslinux_target)
for filename in glob.glob1(syslinux_target, "*.c32"):
# copy all grub files from ISO
glob_and_copy(iso_mount + '/boot/grub/*', grub_target)
- # finally (after all GRUB files have been been installed) build static loopback.cfg
+ # finally (after all GRUB files have been installed) build static loopback.cfg
build_loopbackcfg(target)
version_files = search_file('grml-version', mountpath, lst_return=True)
if not version_files:
- if mountpath.startswith("/lib/live/mount/medium"):
+ if mountpath.startswith("/run/live/medium"):
logging.critical("Error: could not find grml-version file.")
logging.critical("Looks like your system is running from RAM but required files are not available.")
logging.critical("Please either boot without toram=... or use boot option toram instead of toram=...")
logging.debug("Updating grub configuration")
grub_target = target + '/boot/grub/'
+ secureboot_target = target + '/EFI/ubuntu/'
bootid_re = re.compile("bootid=[\w_-]+")
live_media_path_re = re.compile("live-media-path=[\w_/-]+")
remove_regexes.append(re.compile(regex))
shortname = get_shortname(grml_flavour)
- for filename in glob.glob(grub_target + '*.cfg'):
+ for filename in glob.glob(grub_target + '*.cfg') + glob.glob(secureboot_target + '*.cfg'):
for line in fileinput.input(filename, inplace=1):
line = line.rstrip("\r\n")
if option_re.search(line):
if shortname in filename:
line = live_media_path_re.sub('', line)
line = line.rstrip() + ' live-media-path=/live/%s/ ' % (grml_flavour)
+ if bootopt.strip():
+ line = line.replace(' {} '.format(bootopt.strip()), ' ')
+ if line.endswith(bootopt):
+ line = line[:-len(bootopt)]
line = line.rstrip() + r' bootid=%s %s ' % (UUID, bootopt)
for regex in remove_regexes:
line = regex.sub(' ', line)
def initial_syslinux_config(target):
- """Generates intial syslinux configuration
+ """Generates initial syslinux configuration
@target path of syslinux's configuration files"""
add_syslinux_entry("%s/additional.cfg" % syslinux_target, flavour_filename)
+def handle_secure_boot(target, efi_img):
+ """Provide secure boot support by extracting files from /boot/efi.img
+
+ @target: path where grml's main files should be copied to
+ @efi_img: path to the efi.img file that includes the files for secure boot
+ """
+
+ mkdir(target + '/efi/boot/')
+ efi_mountpoint = tempfile.mkdtemp(prefix="grml2usb", dir=os.path.abspath(options.tmpdir))
+ logging.debug("efi_mountpoint = %s" % efi_mountpoint)
+ register_tmpfile(efi_mountpoint)
+
+ try:
+ logging.debug("mount(%s, %s, ['-o', 'ro', '-t', 'vfat']" % (efi_img, efi_mountpoint))
+ mount(efi_img, efi_mountpoint, ['-o', 'ro', '-t', 'vfat'])
+ except CriticalException as error:
+ logging.critical("Fatal: %s", error)
+ sys.exit(1)
+
+ ubuntu_cfg = search_file('grub.cfg', efi_mountpoint + '/EFI/ubuntu')
+ logging.debug("ubuntu_cfg = %s" % ubuntu_cfg)
+ if not ubuntu_cfg:
+ logging.info("No /EFI/ubuntu/grub.cfg found inside EFI image, looks like Secure Boot support is missing.")
+ else:
+ mkdir(target + '/efi/ubuntu')
+ logging.debug("exec_rsync(%s, %s + '/efi/ubuntu/grub.cfg')" % (ubuntu_cfg, target))
+ exec_rsync(ubuntu_cfg, target + '/efi/ubuntu/grub.cfg')
+
+ logging.debug("exec_rsync(%s + '/EFI/BOOT/grubx64.efi', %s + '/efi/boot/grubx64.efi')'" % (efi_mountpoint, target))
+ exec_rsync(efi_mountpoint + '/EFI/BOOT/grubx64.efi', target + '/efi/boot/grubx64.efi')
+
+ # NOTE - we're overwriting /efi/boot/bootx64.efi from copy_bootloader_files here
+ logging.debug("exec_rsync(%s + '/EFI/BOOT/bootx64.efi', %s + '/efi/boot/bootx64.efi')'" % (efi_mountpoint, target))
+ exec_rsync(efi_mountpoint + '/EFI/BOOT/bootx64.efi', target + '/efi/boot/bootx64.efi')
+
+ try:
+ unmount(efi_mountpoint, "")
+ logging.debug('Unmounted %s' % efi_mountpoint)
+ os.rmdir(efi_mountpoint)
+ logging.debug('Removed directory %s' % efi_mountpoint)
+ except Exception:
+ logging.critical('RuntimeError while umount %s' % efi_mountpoint)
+ sys.exit(1)
+
+
def handle_bootloader_config(grml_flavour, device, target):
"""Main handler for generating bootloader's configuration
if options.force or os.path.exists(os.path.join(image, 'live')):
logging.info("Using %s as install base", image)
else:
- q = raw_input("%s does not look like a Grml system. "
+ q = input("%s does not look like a Grml system. "
"Do you really want to use this image? y/N " % image)
if q.lower() == 'y':
logging.info("Using %s as install base", image)
def install_grml(mountpoint, device):
"""Main logic for copying files of the currently running Grml system.
- @mountpoint: directory where currently running live system resides (usually /lib/live/mount/medium)
+ @mountpoint: directory where currently running live system resides (usually /run/live/medium)
@device: partition where the specified ISO should be installed to"""
device_mountpoint = device
check_for_fat(device)
if not options.skipbootflag:
check_boot_flag(device)
+
+ set_rw(device)
mount(device, device_mountpoint, ['-o', 'utf8,iocharset=iso8859-1'])
except CriticalException as error:
mount(device, device_mountpoint, "")
print("Forcing mkfs.fat16 on %s as requested via option --force." % device)
else:
# make sure the user is aware of what he is doing
- f = raw_input("Are you sure you want to format the specified partition with fat16? y/N ")
+ f = input("Are you sure you want to format the specified partition with fat16? y/N ")
if f == "y" or f == "Y":
logging.info("Note: you can skip this question using the option --force")
else:
if not os.path.isdir(device) and not check_for_usbdevice(device) and not options.force:
print("Warning: the specified device %s does not look like a removable usb device." % device)
- f = raw_input("Do you really want to continue? y/N ")
+ f = input("Do you really want to continue? y/N ")
if f.lower() != "y":
sys.exit(1)
print("Instead of using grml2usb /path/to/iso %s you might" % device)
print("want to use grml2usb /path/to/iso /dev/... instead.")
print("Please check out the grml2usb manpage for details.")
- f = raw_input("Do you really want to continue? y/N ")
+ f = input("Do you really want to continue? y/N ")
if f.lower() != "y":
sys.exit(1)
def check_options(opts):
- """Check compability of provided user opts
+ """Check compatibility of provided user opts
@opts option dict from OptionParser
"""
global GRUB_INSTALL
GRUB_INSTALL = which("grub-install") or which("grub2-install")
if not GRUB_INSTALL:
- logging.critical("Fatal: grub-install not available (please install the "
- + "grub package or drop the --grub option)")
+ logging.critical("Fatal: grub-install not available (please install the " +
+ "grub package or drop the --grub option)")
sys.exit(1)
if options.syslinux:
if not which("syslinux"):
- logging.critical("Fatal: syslinux not available (please install the "
- + "syslinux package or use the --grub option)")
+ logging.critical("Fatal: syslinux not available (please install the " +
+ "syslinux package or use the --grub option)")
sys.exit(1)
if not which("rsync"):
def load_loop():
- """Runs modprobe loop and throws away it's output"""
+ """Runs modprobe loop and throws away its output"""
if not which("modprobe"):
logging.critical("Fatal: modprobe not available, can not continue - sorry.")
logging.critical("Hint: is /sbin missing in PATH?")
sys.exit(1)
proc = subprocess.Popen(["modprobe", "loop"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- proc.wait()
+ proc.communicate()
def main():
if not os.path.isdir(device):
if device[-1:].isdigit():
if int(device[-1:]) > 4 or device[-2:].isdigit():
- logging.critical("Fatal: installation on partition number >4 not supported. (BIOS won't support it.)")
- sys.exit(1)
+ logging.warn("Warning: installing on partition number >4, booting *might* fail depending on your system.")
# provide upgrade path
handle_compat_warning(device)
except Exception as error:
logging.critical("Fatal: %s", str(error))
+ if options.verbose:
+ logging.exception("Exception:")
sys.exit(1)
logging.info("Received KeyboardInterrupt")
cleanup()
-## END OF FILE #################################################################
+# END OF FILE ##################################################################
# vim:foldmethod=indent expandtab ai ft=python tw=120 fileencoding=utf-8
projects / grml2usb.git / blobdiff